Validar os certificados de SSL com o Python

Adicionei uma distribuição ao índice de pacotes Python que torna a função match_hostname() do pacote Python 3.2 ssl disponível nas versões anteriores do Python.

Http://pypi.python.org/pypi/backports.ssl_match_hostname/

Pode instalá-lo com:

pip install backports.ssl_match_hostname

Ou pode torná-lo uma dependência listada no seu projecto setup.py. De qualquer forma, pode ser usado assim:

from backports.ssl_match_hostname import match_hostname, CertificateError
...
sslsock = ssl.wrap_socket(sock, ssl_version=ssl.PROTOCOL_SSLv3,
                      cert_reqs=ssl.CERT_REQUIRED, ca_certs=...)
try:
    match_hostname(sslsock.getpeercert(), hostname)
except CertificateError, ce:
    ...

Pode usar o Twisted para verificar os certificados. O principal API é CertificateOptions, que pode ser fornecido como contextFactory argumento para várias funções, tais como listenSSL e startTLS.

Aqui está uma implementação ingênua de uma amostra de um cliente de HTTPS que verifica Twisted, que ignora caracteres especiais e extensões de subjetaltname, e usa os certificados de Autoridade de certificado presentes no pacote 'ca-certificates' na maioria das distribuições Ubuntu. Tente com as suas páginas de certificados válidas e inválidas favoritas:).

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

PycURL faz isto lindamente.

Abaixo está um pequeno exemplo. Ele vai lançar um {[[2]} se algo é suspeito, onde você obtém uma tupla com código de erro e uma mensagem legível humana.

import pycurl

curl = pycurl.Curl()
curl.setopt(pycurl.CAINFO, "myFineCA.crt")
curl.setopt(pycurl.SSL_VERIFYPEER, 1)
curl.setopt(pycurl.SSL_VERIFYHOST, 2)
curl.setopt(pycurl.URL, "https://internal.stuff/")

curl.perform()

Você provavelmente vai querer configurar Mais opções, como onde armazenar os resultados, etc. Mas não há necessidade de confundir o exemplo com coisas não essenciais.

Exemplo das excepções que podem ser levantadas:

(60, 'Peer certificate cannot be authenticated with known CA certificates')
(51, "common name 'CN=something.else.stuff,O=Example Corp,C=SE' does not match 'internal.stuff'")

Algumas ligações que achei úteis são as libcurl-docs para setopt e getinfo.

• http://curl.haxx.se/libcurl/c/curl_easy_setopt.html
• http://curl.haxx.se/libcurl/c/curl_easy_getinfo.html

Aqui está um programa de exemplo que demonstra a validação do certificado:

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

Ou simplesmente tornar a sua vida mais fácil usando a biblioteca dos pedidos:

import requests
requests.get('https://somesite.com', cert='/path/server.crt', verify=True)

Mais algumas palavras sobre o seu uso.

M2Crypto can do the validation . Você também pode usar M2Crypto com Twisted Se quiser. O cliente de secretária do Chandler usa o Twisted para a ligação em rede e o M2Crypto para o SSL, incluindo a validação do certificado.

Com base no comentário dos glifos, parece que o M2Crypto faz uma melhor verificação do certificado por omissão do que o que pode fazer com o pyOpenSSL de momento, porque o M2Crypto também verifica o campo subjetaltname.

O Jython efectua a verificação do certificado por defeito, utilizando assim módulos de biblioteca normalizados, por exemplo, httplib.HTTPSConnection, etc, com jython irá verificar certificados e dar exceções para falhas, ou seja, identidades trocadas, certs expirados, etc.

Na verdade, você tem que fazer algum trabalho extra para que jython se comporte como cpython, ou seja, para que jython não verifique certs.

Escrevi um post no blog sobre como desactivar a verificação do certificado no jython, porque pode ser útil em fases de ensaio, etc.

O PyOpenSSL é uma interface para a biblioteca OpenSSL. Deve fornecer tudo o que precisa.

Eu estava tendo o mesmo problema ,mas queria minimizar as dependências de terceiros (porque este script único era para ser executado por muitos usuários). A minha solução era embrulhar uma chamada e certificar-me de que o código de saída era 0. Funcionou lindamente.