Ich habe nur einige sehr rudimentäre theoretische Kenntnisse über RSA.Exchange Public/Private Key in PKCS # 1 OAEP Verschlüsselung/Entschlüsselung
Beim Lesen verschiedener Quellen über die Verwendung in der Praxis schien PKCS # 1 OAEP eine gute Sache zu sein.
Für eine Test-Implementierung verwende ich Python mit PyCrypto. Z.B. this ist ein Beispiel mit PKCS # 1 OAEP.
Die Verschlüsselung mit dem öffentlichen Schlüssel und die Entschlüsselung mit dem privaten Schlüssel funktioniert einwandfrei. Z.B. Die Öffentlichkeit kann einige Daten mit dem privaten Schlüssel an Person X senden.
Von meinem grundlegenden Verständnis, wie RSA funktioniert, dachte ich, dass ich nur den öffentlichen/privaten Schlüssel austauschen kann, d.h. ich kann den öffentlichen Schlüssel zum Verschlüsseln und den privaten Schlüssel zum Entschlüsseln verwenden. Z.B. Person X kann einige Daten mit ihrem eigenen privaten Schlüssel verschlüsseln, und die Öffentlichkeit kann sie mit dem öffentlichen Schlüssel entschlüsseln. Wenn die Entschlüsselung funktioniert, gibt dies eine Art Beweis, dass die Daten von Person X stammen.
PyCrypto beschwert sich, wenn ich versuche, mit dem öffentlichen Schlüssel zu entschlüsseln.
Von den PyCrypto Quellcode zu lesen, in der _RSAKey._decrypt Funktion (here), so scheint es, dass der Schlüssel Objekt selbst weiß, ob es die private oder öffentliche Schlüssel ist, und unterscheidet sich zwischen ihnen (zu meiner Überraschung, wieder auf Grund meiner sehr einfach RSA Verständnis).
Von dort sieht es so aus, als könnte ich die Entschlüsselungsfunktion hacken, so dass sie den öffentlichen Schlüssel verwendet. Oder etwas anders: Ich könnte einfach den öffentlichen Exponenten e und den privaten Exponenten d in den Schlüsselobjekten austauschen.
Aber das alles scheint so zu sein, dass es nicht so verwendet werden soll. Also wollte ich hier nach meinen Missverständnissen fragen.
Auch nur aus Neugier, erzeugen ich einige Tasten (RSA.generate(2048)) und sah n, e und d. In allen Fällen war n und d sehr groß, während e in allen Fällen Konstante (65537) war (hätte ich nicht erwartet).
Ich denke von all dem, dass ich nicht wirklich e und d austauschen sollte.
Also ich denke, ich sollte eine andere Methode für die Signatur wie PKCS1_PSS verwenden.
Einige Code für die Verschlüsselungs-/Entschlüsselungs, wenn jemand interessiert: (. binstruct ist ein kleines Modul, das/Strukturen Baumdaten dekodieren kodieren kann - ähnlich wie JSON/BSON)
def randomString(l):
import random
return ''.join(chr(random.randint(0, 0xFF)) for i in range(l))
def genkeypair():
from Crypto.PublicKey import RSA
key = RSA.generate(2048)
pubkey = key.publickey().exportKey("DER")
privkey = key.exportKey("DER")
return (pubkey,privkey)
def encrypt(v, rsapubkey):
from Crypto.PublicKey import RSA
rsakey = RSA.importKey(rsapubkey)
from Crypto.Cipher import PKCS1_OAEP
rsa = PKCS1_OAEP.new(rsakey)
import binstruct
from array import array
aeskey = randomString(32)
iv = randomString(16)
from Crypto.Cipher import AES
aes = AES.new(aeskey, AES.MODE_CBC, iv)
data = binstruct.varEncode(v)
data += array("B", (0,) * (-len(data) % 16))
out = binstruct.strEncode(rsa.encrypt(aeskey + iv))
out += array("B", aes.encrypt(data))
return out
def decrypt(stream, rsaprivkey):
from array import array
from StringIO import StringIO
if isinstance(stream, array): stream = stream.tostring()
if isinstance(stream, str): stream = StringIO(stream)
from Crypto.PublicKey import RSA
rsakey = RSA.importKey(rsaprivkey)
from Crypto.Cipher import PKCS1_OAEP
rsa = PKCS1_OAEP.new(rsakey)
import binstruct
aesdata = binstruct.strDecode(stream)
aesdata = rsa.decrypt(aesdata)
aeskey = aesdata[0:32]
iv = aesdata[32:]
from Crypto.Cipher import AES
aes = AES.new(aeskey, AES.MODE_CBC, iv)
class Stream:
buffer = []
def read1(self):
if len(self.buffer) == 0:
nextIn = stream.read(16)
self.buffer += list(aes.decrypt(nextIn))
return self.buffer.pop(0)
def read(self, n):
return "".join([self.read1() for i in range(n)])
v = binstruct.varDecode(Stream())
return v
Das ist, wo ich dachte, ich könnte auch encrypt mit dem privaten Schlüssel und und decrypt mit dem öffentlichen Schlüssel verwenden.
Die endgültige Umsetzung mit (hoffentlich) richtige Signierung/Authentifizierung kann here in binstruct gefunden werden.
"PyCrypto beschwert sich, wenn ich versuche, mit dem öffentlichen Schlüssel zu entschlüsseln". Bitte seien Sie genauer und zeigen Sie Ihren Code. –
@GregS: Es wird 'TypeError (" Kein privater Schlüssel ")' in '_RSAKey._decrypt' ausgelöst. Wie Sie aus dem verknüpften Code sehen können. Das ist, was ich gesagt habe. Es scheint, dass es den privaten Schlüssel beim Entschlüsseln benötigt. – Albert
Wenn Sie nur über rudimentäre Kenntnisse der Kryptographie verfügen, können Sie die API nicht so verwenden, wie sie nicht verwendet werden soll. Ich habe 10 Jahre Erfahrung und bin sogar ziemlich vorsichtig, wenn ich kryptografische Bibliotheken auf eine Art und Weise verwende, die ich nicht sollte - und ich versuche, dies so weit wie möglich zu vermeiden. –