Looking for python Keywords? Try Ask4Keywords

Python LanguageSockets und Nachrichtenverschlüsselung / Entschlüsselung zwischen Client und Server


Einführung

Kryptographie wird aus Sicherheitsgründen verwendet. Es gibt nicht viele Beispiele für die Verschlüsselung / Entschlüsselung in Python mit der IDEA-Verschlüsselung MODE CTR. Ziel dieser Dokumentation:

Erweiterung und Implementierung des RSA Digital Signature-Schemas in der Stationskommunikation. Das Verwenden von Hashing für die Integrität einer Nachricht ist SHA-1. Erstellen Sie ein einfaches Schlüsseltransportprotokoll. Schlüssel mit IDEA-Verschlüsselung verschlüsseln. Der Blockcipher-Modus ist der Counter-Modus

Bemerkungen

Verwendete Sprache: Python 2.7 (Download-Link: https://www.python.org/downloads/ )

Verwendete Bibliothek:

* PyCrypto (Download-Link: https://pypi.python.org/pypi/pycrypto )

* PyCryptoPlus (Download-Link: https://github.com/doegox/python-cryptoplus )

Bibliotheksinstallation:

PyCrypto: Entpacken Sie die Datei. Wechseln Sie in das Verzeichnis, und öffnen Sie das Terminal für Linux (Alt + Strg + T) und CMD (Umschalt + Rechtsklick + Eingabeaufforderung hier öffnen) für Windows. Danach schreiben Sie python setup.py install (Stellen Sie sicher, dass die Python-Umgebung im Windows-Betriebssystem richtig eingestellt ist).

PyCryptoPlus: Entspricht der letzten Bibliothek.

Aufgaben-Implementierung: Die Aufgabe ist in zwei Teile aufgeteilt. Einer ist ein Handshake-Prozess und ein anderer ist ein Kommunikationsprozess. Socket-Setup:

  • Da das Erstellen öffentlicher und privater Schlüssel sowie das Hashing des öffentlichen Schlüssels erforderlich ist, müssen wir den Socket jetzt einrichten. Um das Socket einzurichten, müssen wir ein anderes Modul mit "Socket importieren" importieren und (für den Client) verbinden oder (für den Server) die IP-Adresse und den Port mit dem Socket verbinden, der vom Benutzer abgerufen wird.

    ---------- Client-Seite ----------

      server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
      host = raw_input("Server Address To Be Connected -> ")
      port = int(input("Port of The Server -> "))
      server.connect((host, port))
    

    ---------- Serverseite ---------

      try:
      #setting up socket
      server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)     
      server.bind((host,port))
      server.listen(5)
      except BaseException: print "-----Check Server Address or Port-----"
    

    Mit "socket.AF_INET, socket.SOCK_STREAM" können wir die Funktion accept () und Messaging-Grundlagen verwenden. Anstelle dessen können wir auch "socket.AF_INET, socket.SOCK_DGRAM" verwenden, aber zu diesem Zeitpunkt müssen wir setblocking (value) verwenden.

Handshake-Prozess:

  • (KUNDEN) Die erste Aufgabe besteht darin, einen öffentlichen und einen privaten Schlüssel zu erstellen. Um den privaten und den öffentlichen Schlüssel zu erstellen, müssen wir einige Module importieren. Sie sind: aus Crypto-Import Random und aus Crypto.PublicKey-Import RSA. Um die Schlüssel zu erstellen, müssen wir einige einfache Codezeilen schreiben:
random_generator = Random.new().read
        key = RSA.generate(1024,random_generator) 
        public = key.publickey().exportKey()

random_generator wird vom Modul " Crypto import Random " abgeleitet. Der Schlüssel wird von " from Crypto.PublicKey import RSA " abgeleitet, der einen privaten Schlüssel mit der Größe 1024 erstellt, indem zufällige Zeichen generiert werden. Public exportiert den öffentlichen Schlüssel aus einem zuvor generierten privaten Schlüssel.

  • (KUNDEN) Nachdem Sie den öffentlichen und den privaten Schlüssel erstellt haben, müssen Sie den öffentlichen Schlüssel mit einem SHA-1-Hash an den Server senden. Um den SHA-1-Hash verwenden zu können, müssen Sie ein anderes Modul importieren, indem Sie „import hashlib“ schreiben. Um den öffentlichen Schlüssel zu haschen, müssen wir zwei Codezeilen schreiben:

      hash_object = hashlib.sha1(public) 
      hex_digest = hash_object.hexdigest()
    

Hier ist hash_object und hex_digest unsere Variable. Danach sendet der Client hex_digest und public an den Server, und der Server überprüft sie, indem er den vom Client erhaltenen Hash und den neuen Hash des öffentlichen Schlüssels vergleicht. Wenn der neue Hash und der Hash vom Client übereinstimmen, wird zur nächsten Prozedur übergegangen. Da das vom Client gesendete Publikum in Form einer Zeichenfolge vorliegt, kann es nicht als Schlüssel auf der Serverseite verwendet werden. Um dies zu verhindern und den öffentlichen String des öffentlichen Zeichens in einen öffentlichen rsa-Schlüssel zu konvertieren, müssen Sie server_public_key = RSA.importKey(getpbk) schreiben. Hier ist getpbk der öffentliche Schlüssel des Clients.

  • (SERVER) Als nächsten Schritt erstellen Sie einen Sitzungsschlüssel. Hier habe ich mit dem "os" -Modul einen zufälligen Schlüssel "key = os.urandom (16)" erstellt, der uns einen 16-Bit-langen Schlüssel geben wird. Danach habe ich diesen Schlüssel in "AES.MODE_CTR" verschlüsselt und ihn erneut hashiert mit SHA-1:

     #encrypt CTR MODE session key
     en = AES.new(key_128,AES.MODE_CTR,counter = lambda:key_128) encrypto = en.encrypt(key_128)
     #hashing sha1
     en_object = hashlib.sha1(encrypto)
     en_digest = en_object.hexdigest()
    

Der en_digest wird also unser Sitzungsschlüssel sein.

  • (SERVER) Der letzte Teil des Handshake-Prozesses besteht darin, den vom Client erhaltenen öffentlichen Schlüssel und den auf dem Server erstellten Sitzungsschlüssel zu verschlüsseln.

     #encrypting session key and public key
     E = server_public_key.encrypt(encrypto,16)
    

Nach der Verschlüsselung sendet der Server den Schlüssel als Zeichenfolge an den Client.

  • (CLIENT) Nachdem der verschlüsselte String (public und session key) vom Server abgerufen wurde, entschlüsselt der Client diese mit dem zuvor mit dem öffentlichen Schlüssel erstellten privaten Schlüssel. Da der verschlüsselte (öffentliche und Sitzungsschlüssel) in Form einer Zeichenfolge vorliegt, müssen wir ihn jetzt mithilfe von eval () als Schlüssel zurückholen. Wenn die Entschlüsselung abgeschlossen ist, ist der Handshake-Vorgang abgeschlossen, da beide Seiten bestätigen, dass sie dieselben Schlüssel verwenden. Zu entschlüsseln:

     en = eval(msg)
     decrypt = key.decrypt(en)
     # hashing sha1
     en_object = hashlib.sha1(decrypt) en_digest = en_object.hexdigest()
    

Ich habe den SHA-1 hier verwendet, damit er in der Ausgabe lesbar ist.

Kommunikationsprozess:

Für den Kommunikationsprozess müssen wir den Sitzungsschlüssel von beiden Seiten als Schlüssel für die IDEA-Verschlüsselung MODE_CTR verwenden. Beide Seiten verschlüsseln und entschlüsseln Nachrichten mit IDEA.MODE_CTR unter Verwendung des Sitzungsschlüssels.

  • (Verschlüsselung) Für die IDEA-Verschlüsselung benötigen wir einen 16bit großen Schlüssel und einen Zähler, der aufrufbar ist. Zähler ist in MODE_CTR obligatorisch. Der von uns verschlüsselte und gehashte Sitzungsschlüssel hat jetzt eine Größe von 40, was den Grenzwert der IDEA-Verschlüsselung überschreitet. Daher müssen wir die Größe des Sitzungsschlüssels reduzieren. Zur Reduzierung können wir den in Python eingebauten Funktionsstring [value: value] verwenden. Dabei kann der Wert je nach Wahl des Benutzers ein beliebiger Wert sein. In unserem Fall habe ich "key [: 16]" vorgenommen, wobei der Schlüssel aus 0 bis 16 Werten genommen wird. Diese Konvertierung kann auf viele Arten durchgeführt werden, z. B. Schlüssel [1:17] oder Schlüssel [16:]. Der nächste Teil ist das Erstellen einer neuen IDEA-Verschlüsselungsfunktion, indem IDEA.new () geschrieben wird, das 3 Argumente für die Verarbeitung benötigt. Das erste Argument ist KEY, das zweite Argument ist der Modus der IDEA-Verschlüsselung (in unserem Fall IDEA.MODE_CTR) und das dritte Argument ist der counter =, der eine aufrufbare Funktion ist. Der Zähler = enthält eine Stringgröße, die von der Funktion zurückgegeben wird. Um den Zähler zu definieren, müssen wir vernünftige Werte verwenden. In diesem Fall habe ich die Größe des Schlüssels verwendet, indem ich Lambda definiert habe. Anstatt Lambda zu verwenden, können wir Counter.Util verwenden, das einen Zufallswert für counter = generiert. Um Counter.Util verwenden zu können, müssen wir das Counter-Modul aus Crypto importieren. Daher lautet der Code:

      ideaEncrypt = IDEA.new(key, IDEA.MODE_CTR, counter=lambda : key)
    

Nachdem wir "ideaEncrypt" als IDEA-Verschlüsselungsvariable definiert haben, können wir die integrierte Verschlüsselungsfunktion verwenden, um jede Nachricht zu verschlüsseln.

eMsg = ideaEncrypt.encrypt(whole)
#converting the encrypted message to HEXADECIMAL to readable eMsg =         
eMsg.encode("hex").upper()

In diesem Codesegment ist "Ganz" die zu verschlüsselnde Nachricht und "eMsg" die verschlüsselte Nachricht. Nach dem Verschlüsseln der Nachricht habe ich sie in HEXADECIMAL konvertiert, um sie lesbar zu machen, und upper () ist die eingebaute Funktion, um die Zeichen in Großbuchstaben zu schreiben. Danach wird diese verschlüsselte Nachricht zur Entschlüsselung an die Gegenstation gesendet.

  • (Entschlüsselung)

Um die verschlüsselten Nachrichten zu entschlüsseln, müssen Sie eine weitere Verschlüsselungsvariable erstellen, indem Sie dieselben Argumente und denselben Schlüssel verwenden. Diesmal entschlüsselt die Variable jedoch die verschlüsselten Nachrichten. Der Code hierfür entspricht dem letzten Mal. Vor dem Entschlüsseln der Nachrichten müssen wir die Nachricht jedoch hexadezimal decodieren, da in unserem Verschlüsselungsteil die verschlüsselte Nachricht hexadezimal codiert wurde, um lesbar zu sein. Daher wird der gesamte Code sein:

decoded = newmess.decode("hex")
ideaDecrypt = IDEA.new(key, IDEA.MODE_CTR, counter=lambda: key) 
dMsg = ideaDecrypt.decrypt(decoded)

Diese Prozesse werden sowohl auf der Server- als auch auf der Clientseite zum Verschlüsseln und Entschlüsseln ausgeführt.

Sockets und Nachrichtenverschlüsselung / Entschlüsselung zwischen Client und Server Verwandte Beispiele