Validieren Sie SSL-Zertifikate mit Python

Aus der release-version 2.7.9/3.4.3, Python standardmäßig durchzuführen versucht Zertifikat Validierung.

Dieser hat vorgeschlagen, im PEP-467, das ist Wert, gelesen zu werden: https://www.python.org/dev/peps/pep-0476/

Wirken sich die änderungen auf alle relevanten stdlib Module (das urllib/urllib2, http, httplib).

Relevanten Dokumentationen:

https://docs.python.org/2/library/httplib.html#httplib.HTTPSConnection

Diese Klasse führt nun alle notwendigen Zertifikat und hostname überprüft standardmäßig. Um wieder den vorherigen, nicht überprüft, Verhalten von ssl._create_unverified_context() übergeben werden kann, um die context-parameter.

https://docs.python.org/3/library/http.client.html#http.client.HTTPSConnection

Änderungen in version 3.4.3: Diese Klasse führt nun alle notwendigen Zertifikat und hostname überprüft standardmäßig. Um wieder den vorherigen, nicht überprüft, Verhalten von ssl._create_unverified_context() übergeben werden kann, um die context-parameter.

Beachten Sie, dass die neue integrierte Prüfung auf Basis der system bereitgestellten Zertifikat-Datenbank. Im Gegensatz zu diesem, der Anfragen Paket liefert sein eigenes Zertifikat zu bündeln. Vor-und Nachteile der beiden Ansätze diskutiert werden, die Trust-Datenbank - Abschnitt der PEP 476.

InformationsquelleAutor der Antwort Jan-Philip Gehrcke

Können Sie Verdreht, um Zertifikate überprüfen. Die wichtigsten API ist CertificateOptionsdie bereitgestellt werden können als die contextFactory argument zu diversen Funktionen, wie listenSSL und startTLS.

Leider weder Python noch Twisted-kommt mit einem Haufen von CA-Zertifikate benötigt, um tatsächlich tun, HTTPS-überprüfung, noch die HTTPS-überprüfung der Logik. Aufgrund eine Einschränkung in PyOpenSSLman kann es nicht ganz korrekt gerade noch, aber Dank der Tatsache, dass fast alle Zertifikate beinhalten ein Thema, commonName, können Sie nahe genug kommen.

Hier ist ein naives Beispiel-Implementierung einer überprüfung Twisted HTTPS-client ignoriert wildcards und die subjectAltName-Erweiterungen, und verwendet die certificate-authority-Zertifikate präsentieren in der "ca-Zertifikate" - Paket in den meisten Ubuntu-Distributionen. Versuchen Sie es mit Ihrem Lieblings-gültige und ungültige Zertifikat-sites :).

import os
import glob
from OpenSSL.SSL import Context, TLSv1_METHOD, VERIFY_PEER, VERIFY_FAIL_IF_NO_PEER_CERT, OP_NO_SSLv2
from OpenSSL.crypto import load_certificate, FILETYPE_PEM
from twisted.python.urlpath import URLPath
from twisted.internet.ssl import ContextFactory
from twisted.internet import reactor
from twisted.web.client import getPage
certificateAuthorityMap = {}
for certFileName in glob.glob("/etc/ssl/certs/*.pem"):
    # There might be some dead symlinks in there, so let's make sure it's real.
    if os.path.exists(certFileName):
        data = open(certFileName).read()
        x509 = load_certificate(FILETYPE_PEM, data)
        digest = x509.digest('sha1')
        # Now, de-duplicate in case the same cert has multiple names.
        certificateAuthorityMap[digest] = x509
class HTTPSVerifyingContextFactory(ContextFactory):
    def __init__(self, hostname):
        self.hostname = hostname
    isClient = True
    def getContext(self):
        ctx = Context(TLSv1_METHOD)
        store = ctx.get_cert_store()
        for value in certificateAuthorityMap.values():
            store.add_cert(value)
        ctx.set_verify(VERIFY_PEER | VERIFY_FAIL_IF_NO_PEER_CERT, self.verifyHostname)
        ctx.set_options(OP_NO_SSLv2)
        return ctx
    def verifyHostname(self, connection, x509, errno, depth, preverifyOK):
        if preverifyOK:
            if self.hostname != x509.get_subject().commonName:
                return False
        return preverifyOK
def secureGet(url):
    return getPage(url, HTTPSVerifyingContextFactory(URLPath.fromString(url).netloc))
def done(result):
    print 'Done!', len(result)
secureGet("https://google.com/").addCallback(done)
reactor.run()

InformationsquelleAutor der Antwort Glyph

Hier ein Beispiel-script, welches zeigt, Zertifikat Validierung:

import httplib
import re
import socket
import sys
import urllib2
import ssl

class InvalidCertificateException(httplib.HTTPException, urllib2.URLError):
    def __init__(self, host, cert, reason):
        httplib.HTTPException.__init__(self)
        self.host = host
        self.cert = cert
        self.reason = reason

    def __str__(self):
        return ('Host %s returned an invalid certificate (%s) %s\n' %
                (self.host, self.reason, self.cert))

class CertValidatingHTTPSConnection(httplib.HTTPConnection):
    default_port = httplib.HTTPS_PORT

    def __init__(self, host, port=None, key_file=None, cert_file=None,
                             ca_certs=None, strict=None, **kwargs):
        httplib.HTTPConnection.__init__(self, host, port, strict, **kwargs)
        self.key_file = key_file
        self.cert_file = cert_file
        self.ca_certs = ca_certs
        if self.ca_certs:
            self.cert_reqs = ssl.CERT_REQUIRED
        else:
            self.cert_reqs = ssl.CERT_NONE

    def _GetValidHostsForCert(self, cert):
        if 'subjectAltName' in cert:
            return [x[1] for x in cert['subjectAltName']
                         if x[0].lower() == 'dns']
        else:
            return [x[0][1] for x in cert['subject']
                            if x[0][0].lower() == 'commonname']

    def _ValidateCertificateHostname(self, cert, hostname):
        hosts = self._GetValidHostsForCert(cert)
        for host in hosts:
            host_re = host.replace('.', '\.').replace('*', '[^.]*')
            if re.search('^%s$' % (host_re,), hostname, re.I):
                return True
        return False

    def connect(self):
        sock = socket.create_connection((self.host, self.port))
        self.sock = ssl.wrap_socket(sock, keyfile=self.key_file,
                                          certfile=self.cert_file,
                                          cert_reqs=self.cert_reqs,
                                          ca_certs=self.ca_certs)
        if self.cert_reqs & ssl.CERT_REQUIRED:
            cert = self.sock.getpeercert()
            hostname = self.host.split(':', 0)[0]
            if not self._ValidateCertificateHostname(cert, hostname):
                raise InvalidCertificateException(hostname, cert,
                                                  'hostname mismatch')


class VerifiedHTTPSHandler(urllib2.HTTPSHandler):
    def __init__(self, **kwargs):
        urllib2.AbstractHTTPHandler.__init__(self)
        self._connection_args = kwargs

    def https_open(self, req):
        def http_class_wrapper(host, **kwargs):
            full_kwargs = dict(self._connection_args)
            full_kwargs.update(kwargs)
            return CertValidatingHTTPSConnection(host, **full_kwargs)

        try:
            return self.do_open(http_class_wrapper, req)
        except urllib2.URLError, e:
            if type(e.reason) == ssl.SSLError and e.reason.args[0] == 1:
                raise InvalidCertificateException(req.host, '',
                                                  e.reason.args[1])
            raise

    https_request = urllib2.HTTPSHandler.do_request_

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print "usage: python %s CA_CERT URL" % sys.argv[0]
        exit(2)

    handler = VerifiedHTTPSHandler(ca_certs = sys.argv[1])
    opener = urllib2.build_opener(handler)
    print opener.open(sys.argv[2]).read()

InformationsquelleAutor der Antwort Eli Courtwright

M2Crypto kann dazu die Validierung. Sie können auch M2Crypto mit Twistedwenn Sie mögen. Die Chandler desktop-client verwendet Twisted-für die Vernetzung und M2Crypto für SSLeinschließlich der Zertifikat Validierung.

Basierend auf Glyphen Kommentar wie es scheint, M2Crypto ist besser-Zertifikat-Verifizierung standardmäßig als das, was Sie tun können, mit pyOpenSSL aktuell, da M2Crypto überprüft, subjectAltName-Feld zu.

Habe ich auch gebloggt, wie die Zertifikate erhalten Mozilla Firefox Schiffe mit Python und nutzbar mit Python SSL-Lösungen.

InformationsquelleAutor der Antwort Heikki Toivonen

Ich hatte das gleiche problem, aber wollte, um 3rd-party-Abhängigkeiten (weil dieser one-off-Skript ausgeführt werden, indem viele Benutzer). Meine Lösung war, um wickeln Sie ein curl rufen und stellen Sie sicher, dass der exit-code war 0. Arbeitete wie ein Charme.

InformationsquelleAutor der Antwort Ztyx