De la mousse sur https avec cert

Il semble que vous voulez authentifier à l'aide d'un client certificat, pas un serveur certificat comme cela a été dit dans certains commentaires. J'ai eu le même problème et a réussi à écrire un transport personnalisé pour de la MOUSSE. Voici le code qui fonctionne pour moi.

Vous aurez besoin de votre certificat au format PEM pour que cela fonctionne; OpenSSL pouvez facilement effectuer cette conversion, mais je ne me souviens plus de la syntaxe exacte.

import urllib2, httplib, socket
from suds.client import Client
from suds.transport.http import HttpTransport, Reply, TransportError
class HTTPSClientAuthHandler(urllib2.HTTPSHandler):
def __init__(self, key, cert):
urllib2.HTTPSHandler.__init__(self)
self.key = key
self.cert = cert
def https_open(self, req):
#Rather than pass in a reference to a connection class, we pass in
# a reference to a function which, for all intents and purposes,
# will behave as a constructor
return self.do_open(self.getConnection, req)
def getConnection(self, host, timeout=300):
return httplib.HTTPSConnection(host,
key_file=self.key,
cert_file=self.cert)
class HTTPSClientCertTransport(HttpTransport):
def __init__(self, key, cert, *args, **kwargs):
HttpTransport.__init__(self, *args, **kwargs)
self.key = key
self.cert = cert
def u2open(self, u2request):
"""
Open a connection.
@param u2request: A urllib2 request.
@type u2request: urllib2.Requet.
@return: The opened file-like urllib2 object.
@rtype: fp
"""
tm = self.options.timeout
url = urllib2.build_opener(HTTPSClientAuthHandler(self.key, self.cert))
if self.u2ver() < 2.6:
socket.setdefaulttimeout(tm)
return url.open(u2request)
else:
return url.open(u2request, timeout=tm)
# These lines enable debug logging; remove them once everything works.
import logging
logging.basicConfig(level=logging.INFO)
logging.getLogger('suds.client').setLevel(logging.DEBUG)
logging.getLogger('suds.transport').setLevel(logging.DEBUG)
c = Client('https://YOUR_URL_HERE',
transport = HTTPSClientCertTransport('PRIVATE_KEY.pem',
'CERTIFICATE_CHAIN.pem'))
print c

Basé sur @k4ml réponse, j'ai seulement ajouté les open() qui permet de récupérer le fichier WSDL à l'aide du certificat.

Cette méthode devrait résoudre le suds.transport.TransportError: HTTP Error 403: Forbidden lors de la tentative d'extraction d'un document WSDL (au Client création) servi derrière un service HTTPS.

import requests
from suds.transport.http import HttpAuthenticated
from suds.transport import Reply, TransportError
class RequestsTransport(HttpAuthenticated):
def __init__(self, **kwargs):
self.cert = kwargs.pop('cert', None)
# super won't work because not using new style class
HttpAuthenticated.__init__(self, **kwargs)
def open(self, request):
"""
Fetches the WSDL using cert.
"""
self.addcredentials(request)
resp = requests.get(request.url, data=request.message,
headers=request.headers, cert=self.cert)
result = io.StringIO(resp.content.decode('utf-8'))
return result
def send(self, request):
"""
Posts to service using cert.
"""
self.addcredentials(request)
resp = requests.post(request.url, data=request.message,
headers=request.headers, cert=self.cert)
result = Reply(resp.status_code, resp.headers, resp.content)
return result

Note de côté, j'ai aussi fait une suggestion de modifier à k4ml réponse, mais il peut prendre des heures avant qu'il soit approuvé.

De sécurité SSL fonction est automatiquement activée python 2.7.9+ qui rompt la mousse et d'autres bibliothèques python. Je partage un patch qui peut résoudre ce problème:

Vous localiser la mousse de bibliothèque et de les remplacer u2handlers fonction dans suds/trasnport/http.py fichier avec la ligne suivante:

import ssl
def u2handlers(self):
"""
Get a collection of urllib handlers.
@return: A list of handlers to be installed in the opener.
@rtype: [Handler,...]
"""
handlers = []
unverified_context = ssl.create_default_context()
unverified_context.check_hostname = False
unverified_context.verify_mode = ssl.CERT_NONE
unverified_handler = urllib2.HTTPSHandler(context=unverified_context)
handlers.append(unverified_handler)
handlers.append(urllib2.ProxyHandler(self.proxy))
#handlers.append(urllib2.ProxyHandler(self.proxy))
return handlers 

Remarque: Il n'est pas recommandé de le faire.