Extrait de la Clé Publique à l'aide de pyOpenSSL de certificat ou d'autres informations de connexion

Je suis en train d'essayer d'écrire un python script serveur qui doit authentifier le client actuel, basé sur sa clé publique. Depuis que je suis en utilisant tordu, exemple dans le tordu documenteation qui m'a.

Alors que je peux générer des clés, se connecter et communiquer à l'aide de l'exemple de code, je n'ai pas encore trouvé un moyen d'obtenir la clé publique du client dans un format utilisable. Dans cette question stackexchange quelqu'un a extrait la clé publique d'un OpenSSL.crypto.PKey objet, mais ne peuvent pas le transformer dans un format lisible. Depuis que j'ai accès à la PKey objet du certificat x509 dans le verifyCallback de la méthode ou par l'intermédiaire de self.transport.getPeerCertificate() à partir de n'importe quelle méthode de mon Protocole, ce serait une bonne façon d'aller. La (non accepté) réponse suggère d'essayer crypto.dump_privatekey(PKey). Malheureusement, ce n'est pas vraiment rendement le résultat attendu:
Alors que le BEGIN PRIVATE KEY et BEGIN PRIVATE KEY dans la réponse pourrait être résolu par une simple fonction de remplacement de texte, la chaîne base64 ne semble pas correspondre à la clé publique. J'ai extrait la clé publique avec openssl rsa -in client.key -pubout > client.pub comme mentionné ici. Il ne correspond pas au résultat de la dump_privatekey fonction.

Alors qu'il est encore bug ouvert vers OpenSSL sur launchpad, il n'est pas encore fixé. Il a été rapporté de 19 Mois, et il y a quelques récentes (octobre 2012), l'activité sur elle, je n'ai pas le moindre espoir d'un rapide fix dans le repos.

Avez-vous d'autres idées de comment je pourrais obtenir la clé publique dans un format comparable à la client.pub fichier je l'ai mentionné ci-dessus? Il est peut-être un tordu ou OpenSSL connexion spécifique de l'objet qui détient cette information. Veuillez noter que j'ai pour stocker la clé publique dans le protocole d'un objet, tel que je peux y accéder plus tard.

Pourquoi pas de Réponse acceptée?

M2Crypto par J. F. Sebastian

Désolé, que je n'avais pas pensé à une possibilité où je ne peut pas corréler le certificat pour la connexion. J'ai ajouté l'exigence que j'ai pour stocker la clé publique à l'intérieur du protocole de l'instance. Ainsi, à l'aide peerX509.as_pem() à l'intérieur de la postConnectionCheck fonction comme suggéré par J. F. Sebastian ne fonctionne pas. En outre, au moins dans la version 0.21.1-2ubuntu3 de python-m2crypto j'ai appeler peerX509.get_rsa().as_pem() pour obtenir le droit de clé publique. À l'aide de peerX509.as_pem(None) (depuis peerX509.as_pem() veut toujours un mot de passe), on obtient exactement le même résultat que crypto.dump_privatekey(PKey) dans PyOpenSSL. Peut-être il y a un bug.

En plus de cela, la réponse m'a montré un moyen possible d'écrire une autre solution en utilisant les éléments suivants Echo classe de protocole:

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)

Comme vous pouvez le voir il utilise certaines classes internes que je voudrais éviter. Je suis hésitant de la soumission d'un petit patch qui permettrait d'ajouter un getCert méthode à la TLSProtocolWrapper classe dans M2Crypto.Le protocole SSL.TwistedProtocolWrapper. Même si elle a été acceptée en amont, il serait de casser la compatibilité de mon script avec les mais la plupart des coupe-de-la-pointe versions de m2crypto. Que feriez-vous?

Externe OpenSSL appel par moi -

Bien, c'est un vilain solution de contournement externe, commandes du système juste ce qui me semble encore pire que l'accès à la non-public des attributs.

Connexes, voir la mise à jour de ma bibliothèque de cryptage de Mcrypt pour OpenSSL, Remplacer Mcrypt avec OpenSSL et Préparer le retrait de Mcrypt en PHP 7.2

OriginalL'auteur sumpfomat | 2012-12-12

6

Certaines des réponses précédentes produire (apparemment?) travail PEM clé publique de fichiers, mais jusqu'à présent, que j'ai essayé, aucun d'entre eux produisent le même résultat que le " openssl rsa -pubout -en priv.les principaux". C'est assez important à mon test de la suite, et après avoir farfouillé dans le (0.15.1) PyOpenSSL code, cela fonctionne bien pour le standard PKey des objets et de la clé publique seulement PKey les objets créés par la x509.get_pubkey() méthode:
```
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)
```
Pourriez-vous nous expliquer comment cela fonctionne un peu mieux @jessica-gadling
Fonctionne comme un charme!

OriginalL'auteur Jessica Gadling

Analogique de openssl rsa -in client.key -pubout > client.pub commande en M2Crypto (une plus complète openssl wrapper que pyOpenSSL) est:

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

Vous pouvez utiliser M2Crypto au lieu de pyOpenSSL tordues. Ajouter le protocole ssl capacités du serveur echo:

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

Vous pouvez:

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

De l'essayer, créer des certificats auto-signés:

$ 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

et de se connecter au serveur:

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

Le serveur enregistre le client de la clé publique à l' client.pub fichier. Il est identique à celui créé par openssl commande:

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

OriginalL'auteur jfs

Une possibilité d'obtenir la clé publique est un vilain solution de contournement par la tuyauterie de la version pem du certificat x509 par le biais d'un extérieur appelé openssl exemple:

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)

OriginalL'auteur sumpfomat

0

Je l'ai fait travailler enfin à l'aide de pyOpenSSL et DerSequence classe de Crypto.Util.asn1 (pyasn1 de la bibliothèque).

Ici est une méthode de mon RSAKey classe (pkey est une OpenSSL.crypto.PKey exemple) :
```
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])))
```
La clé ici est que le premier élément dans le pub_der._seq est zéro, et nous n'avons pas besoin il.
Que vous pouvez convertir clé RSA stockée dans l'auto.la clé de n'importe quel format que vous voulez:
```
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
```
Je suis actuellement en train de travailler avec CSpace projet, il utilise des "ncrypt" de la bibliothèque ( c'est un autre OpenSSL wrapper ) qui n'est pas pris en charge plus et il donne de l'Erreur de segmentation sur Linux. J'ai donc décidé de remplacer ncrypt bibliothèque avec pyOpenSSL parce que je l'utilise dans mon projet appelé DataHaven.NET. Et de l'obtention de la clé publique de l'hôte certificat au format PEM était vraiment un problème pour moi. Maintenant, il fonctionne parfaitement bien.

OriginalL'auteur Veselin Penev

Vous devez vous connecter pour publier un commentaire.