Extrahieren des Öffentlichen Schlüssels mit pyOpenSSL von Zertifikat oder andere Verbindungsinformationen

Derzeit bin ich versucht zu schreiben, ein python server script, das sollte die Authentifizierung der aktuellen client basierend auf Ihren öffentlichen Schlüssel. Da bin ich mit windenden, die Beispiel in der twisted-documenteation habe mich begonnen.

Während ich Schlüssel generieren, verbinden und kommunizieren mit dem Beispiel code, ich habe noch nicht einen Weg gefunden, um den öffentlichen Schlüssel des Clients in ein verwendbares format. In das stackexchange-Frage jemand extrahiert den öffentlichen Schlüssel aus einem OpenSSL.crypto.PKey Objekt, kann aber nicht verwandeln es in ein lesbares format. Da habe ich Zugang zu den PKey Objekt von x509-Zertifikat in der verifyCallback Methode oder über self.transport.getPeerCertificate() aus jede Methode meines Protokolls, das wäre ein guter Weg zu gehen. Der (nicht angenommenen) Antworten schlägt vor, zu versuchen crypto.dump_privatekey(PKey). Leider funktioniert das nicht so wirklich Ausbeute das erwartete Ergebnis:
Während die BEGIN PRIVATE KEY und BEGIN PRIVATE KEY in der Antwort könnte behoben werden, indem eine einfache text Ersatz-Funktion, die base64-string scheint nicht mit dem öffentlichen Schlüssel. Ich habe extrahiert den öffentlichen Schlüssel mit openssl rsa -in client.key -pubout > client.pub wie bereits erwähnt hier. Es entspricht nicht das Ergebnis der dump_privatekey Funktion.

Während es immer noch ein Fehler in Richtung OpenSSL auf launchpad, es steht noch nicht fest. Es wurde berichtet, 19 Monat, und es gibt einige aktuelle (Oktober 2012) - Aktivität auf, ich nicht haben jede Hoffnung auf ein schnelles Update in die repos.

Haben Sie andere Ideen, wie ich bekommen konnte, um den öffentlichen Schlüssel in einem format, das vergleichbar mit der client.pub Datei, die ich oben erwähnt habe? Gibt es vielleicht eine verdrehte oder OpenSSL-Verbindung bestimmtes Objekt hält diese Informationen. Bitte beachten Sie, dass ich zum speichern der public-key in das Protokoll-Objekt, so dass ich später darauf zugreifen kann.

Warum ist keine Antwort akzeptiert?

M2Crypto von J. F. Sebastian

Sorry, das hatte ich nicht gedacht eine Möglichkeit, wo ich nicht korreliert das Zertifikat für die Verbindung. Ich habe die Anforderung, dass ich zum speichern der public-key innerhalb des Protokoll-Instanz. So, mit peerX509.as_pem() innerhalb der postConnectionCheck Funktion wie vorgeschlagen von J. F. Sebastian funktioniert nicht. Des weiteren, mindestens in der version 0.21.1-2ubuntu3 von python-m2crypto ich habe zu nennen peerX509.get_rsa().as_pem() um den richtigen öffentlichen Schlüssel. Mit peerX509.as_pem(None) (seit peerX509.as_pem() will immer noch eine passphrase) Erträge excactly das gleiche Ausgang wie crypto.dump_privatekey(PKey) in PyOpenSSL. Vielleicht gibt es einen Fehler.

Neben dieser, die Antwort zeigte mir einen möglichen Weg zu schreiben, eine andere Problemumgehung mithilfe der folgenden Echo Protokoll Klasse:

class Echo(Protocol):
    def dataReceived(self, data):
        """As soon as any data is received, write it back."""
        if self.transport.checked and not self.pubkeyStored:
            self.pubkeyStored = True
            x509 = m2.ssl_get_peer_cert(self.transport.ssl._ptr())
            if x509 is not None:
                x509 = X509.X509(x509, 1)
                pk = x509.get_pubkey()
                self.pubkey = pk.get_rsa().as_pem()
                print pk.as_pem(None)
            print self.pubkey
        self.transport.write(data)

Wie Sie sehen können, verwendet einige interne Klassen, die würde ich gerne verhindern. Ich bin zu zögern Absenden ein kleines patch, das würde noch ein getCert Methode, um die TLSProtocolWrapper Klasse in M2Crypto.SSL.TwistedProtocolWrapper. Auch wenn es upstream akzeptiert, es würde die Kompatibilität von mein Skript mit alle, aber die meisten cut-of-the-edge-Versionen von m2crypto. Was würden Sie tun?

Externe OpenSSL-Aufruf von mir

Nun, es ist ein hässlicher workaround, basierend auf dem externen system-Befehle nur, die scheint mir sogar noch schlimmer als der Zugriff auf nicht-öffentliche Attribute.

InformationsquelleAutor sumpfomat | 2012-12-12

6

Einige der vorherigen Antworten produzieren (scheinbar?) arbeiten PEM-public-key-Dateien, aber so weit ich habe versucht, keiner von Ihnen produzieren die gleiche Ausgabe wie das " openssl rsa -pubout -in priv.- Taste' funktioniert. Dies ist ziemlich wichtig für meine test-suite, und nach stochern im (0.15.1) PyOpenSSL-code, die funktioniert gut für sowohl standard-als PKey Objekte und der public-key-nur PKey-Objekte erstellt, indem der x509.get_pubkey () - Methode:
```
from OpenSSL import crypto
from OpenSSL._util import lib as cryptolib


def pem_publickey(pkey):
    """ Format a public key as a PEM """
    bio = crypto._new_mem_buf()
    cryptolib.PEM_write_bio_PUBKEY(bio, pkey._pkey)
    return crypto._bio_to_string(bio)


key = crypto.PKey()
key.generate_key(crypto.TYPE_RSA, 2048)
print pem_publickey(key)
```
Würden Sie mir erklären, wie es funktioniert ein wenig besser @jessica-gadling
Funktioniert wie ein Charme!

InformationsquelleAutor Jessica Gadling

Analog openssl rsa -in client.key -pubout > client.pub Befehl in M2Crypto (eine komplette openssl wrapper als pyOpenSSL):

def save_pub_key(cert, filename):
    cert.get_pubkey().get_rsa().save_pub_key(filename)

Können Sie M2Crypto statt pyOpenSSL mit verdreht. Zum hinzufügen von ssl-Funktionen auf den echo-server:

from twisted.internet import protocol, reactor

class Echo(protocol.Protocol):
    def dataReceived(self, data):
        self.transport.write(data)

class EchoFactory(protocol.Factory):
    def buildProtocol(self, addr):
        return Echo()

Können Sie:

import sys
from twisted.python import log

from M2Crypto import SSL, X509
from M2Crypto.SSL import Checker
from M2Crypto.SSL.TwistedProtocolWrapper import listenSSL

log.startLogging(sys.stderr)    
cert = X509.load_cert('client.crt')
check = Checker.Checker(peerCertHash=cert.get_fingerprint('sha1'))

def postConnectionCheck(peerX509, expectedHost):
    log.msg("client cert in pem format:\n", peerX509.as_pem())
    save_pub_key(peerX509, 'client.pub')
    return check(peerX509, host=None) # don't check client hostname

class SSLContextFactory:
    def getContext(self):
        ctx = SSL.Context()
        ctx.load_verify_locations(cafile='ca.crt')
        ctx.load_cert(certfile='server.crt', keyfile='server.key',
                      callback=lambda *a,**kw: 'keyfile passphrase')
        ctx.set_verify(SSL.verify_peer | SSL.verify_fail_if_no_peer_cert,
                       depth=9, callback=None)
        return ctx
listenSSL(8000, EchoFactory(), SSLContextFactory(),
          interface='localhost',  reactor=reactor,
          postConnectionCheck=postConnectionCheck)
reactor.run()

Versuchen Sie es, erstellen Sie das selbst-signierte Zertifikate:

$ openssl req -new -x509 -nodes -out server.crt -keyout server.key
# NOTE: server.key is unencrypted!
$ cp {server,client}.crt
$ cp {server,client}.key
$ cp {server,ca}.crt

und die Verbindung zum server:

$ openssl s_client -cert client.crt -key client.key -CAfile ca.crt \
   -verify 9 -connect localhost:8000 -no_ssl2

Speichert der server dem client den öffentlichen Schlüssel, um die client.pub - Datei. Es ist identisch mit der erstellt von openssl Befehl:

$ openssl rsa -in client.key -pubout > openssl_client.pub
$ diff -s {openssl_,}client.pub

InformationsquelleAutor jfs

Einer Möglichkeit, den öffentlichen Schlüssel ist ein hässlicher workaround von Rohrleitungen der pem-version des x509-Zertifikats durch eine extern aufgerufene openssl Beispiel:

def extractpublickey(x509):
    x509pem = dump_certificate(FILETYPE_PEM,x509)
    ossl = Popen(['openssl','x509','-pubkey','-noout'] , stdout=PIPE, stderr=PIPE, stdin=PIPE)
    (stdout,_) = ossl.communicate(x509pem)
    res = ""
    if stdout[:26] != ("-----BEGIN PUBLIC KEY-----") or stdout[-24:] != ("-----END PUBLIC KEY-----"):
        raise AttributeError("Could not extract key from x509 certificate in PEM mode: %s"%x509pem)
    else:
        res = stdout
    return res

class Echo(Protocol):
    def dataReceived(self, data):
        """As soon as any data is received, write it back."""
        if self.transport.getPeerCertificate() == None:
            print("unknown client")
        else: 
            print extractpublickey(self.transport.getPeerCertificate())
        self.transport.write(data)

InformationsquelleAutor sumpfomat

0

Ich gemacht, es funktioniert endlich mit pyOpenSSL und DerSequence Klasse von Crypto.Util.asn1 (pyasn1-Bibliothek).

Hier ist eine Methode aus meinem RSAKey Klasse (pkey ist ein OpenSSL.crypto.PKey-Instanz) :
```
from OpenSSL.crypto import dump_privatekey, FILETYPE_ASN1
from Crypto.PublicKey import RSA
from Crypto.Util.asn1 import DerSequence
from base64 import b64decode, b64encode

...

def fromPKey_PublicKey(self, pkey):
    src = dump_privatekey(FILETYPE_ASN1, pkey)
    pub_der = DerSequence()
    pub_der.decode(src)
    self.key = RSA.construct((long(pub_der._seq[1]), long(pub_der._seq[2])))
```
Der Schlüssel hier ist, das erste Element in pub_der._seq ist null, und wir brauchen es.
Als Sie umwandeln kann RSA-Schlüssel gespeichert ist in sich selbst.der Schlüssel zu jedem format, das Sie wünschen:
```
def toPEM_PublicKey(self):
    pemSeq = DerSequence()
    pemSeq[:] = [ self.key.key.n, self.key.key.e ]
    s = b64encode(pemSeq.encode())
    src = '-----BEGIN RSA PUBLIC KEY-----\n'
    while True:
        src += s[:64] + '\n'
        s = s[64:]
        if s == '':
            break
    src += '-----END RSA PUBLIC KEY-----'
    return src
```
Ich arbeite derzeit mit CSpace Projekt, setzt es ein "ncrypt" Bibliothek ( das ist eine andere OpenSSL wrapper), welches nicht mehr unterstützt und es gibt segmentation Fault unter Linux. So entschied ich mich zu ersetzen, ncrypt Bibliothek mit pyOpenSSL, weil ich es mit in mein Projekt genannt DataHaven.NET. Und immer einen öffentlichen Schlüssel aus der peer-Zertifikat in PEM-format war wirklich ein problem für mich. Jetzt ist es gut funktioniert.

InformationsquelleAutor Veselin Penev

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.