Kryptographie mit Python - Kurzanleitung
Kryptographie ist die Kunst der Kommunikation zwischen zwei Benutzern über codierte Nachrichten. Die Wissenschaft der Kryptographie entstand mit dem Grundmotiv, die vertraulichen Nachrichten, die von einer Partei an eine andere übertragen wurden, zu schützen.
Kryptographie ist definiert als die Kunst und Wissenschaft, die Botschaft zu verbergen, um Privatsphäre und Geheimhaltung einzuführen, wie sie in der Informationssicherheit anerkannt sind.
Terminologien der Kryptographie
Die in der Kryptographie häufig verwendeten Begriffe werden hier erklärt -
Klartext
Die Nur-Text-Nachricht ist der Text, der lesbar ist und von allen Benutzern verstanden werden kann. Der Klartext ist die Nachricht, die einer Kryptographie unterzogen wird.
Geheimtext
Chiffretext ist die Nachricht, die nach dem Anwenden der Kryptographie auf Klartext erhalten wird.
Verschlüsselung
Das Konvertieren von Klartext in Chiffretext wird als Verschlüsselung bezeichnet. Es wird auch als Codierung bezeichnet.
Entschlüsselung
Das Konvertieren von Chiffretext in Klartext wird als Entschlüsselung bezeichnet. Es wird auch als Decodierung bezeichnet.
Das folgende Diagramm zeigt den gesamten Prozess der Kryptographie -
Merkmale der modernen Kryptographie
Die grundlegenden Merkmale der modernen Kryptographie sind wie folgt:
Es arbeitet mit Bitsequenzen.
Es verwendet mathematische Algorithmen zum Sichern der Informationen.
Es erfordert Parteien, die an einem sicheren Kommunikationskanal interessiert sind, um Privatsphäre zu erreichen.
Bei der Verschlüsselung mit doppelter Stärke, auch als Mehrfachverschlüsselung bezeichnet, wird ein bereits verschlüsselter Text ein- oder mehrmals entweder mit demselben oder einem anderen Algorithmus / Muster verschlüsselt.
Die anderen Namen für Verschlüsselung mit doppelter Stärke umfassen Kaskadenverschlüsselung oder Kaskadenverschlüsselung.
Stufen der Verschlüsselung mit doppelter Stärke
Die Verschlüsselung mit doppelter Stärke umfasst verschiedene Verschlüsselungsstufen, die hier unter - erläutert werden.
Erste Verschlüsselungsschicht
Der Chiffretext wird aus der ursprünglich lesbaren Nachricht unter Verwendung von Hash-Algorithmen und symmetrischen Schlüsseln generiert. Spätere symmetrische Schlüssel werden mit Hilfe von asymmetrischen Schlüsseln verschlüsselt. Die beste Illustration für dieses Muster ist die Kombination des Hash-Digests des Chiffretextes zu einer Kapsel. Der Empfänger berechnet zuerst den Digest und entschlüsselt später den Text, um sicherzustellen, dass der Text dazwischen nicht manipuliert wird.
Zweite Verschlüsselungsschicht
Bei der zweiten Verschlüsselungsebene wird eine weitere Ebene hinzugefügt, um Text mit demselben oder einem anderen Algorithmus zu verschlüsseln. Normalerweise wird dafür ein symmetrisches Kennwort mit einer Länge von 32 Bit verwendet.
Dritte Verschlüsselungsschicht
Dabei wird die verschlüsselte Kapsel über eine SSL / TLS-Verbindung an den Kommunikationspartner übertragen.
Das folgende Diagramm zeigt den doppelten Verschlüsselungsprozess bildlich -
Hybrid-Kryptographie
Bei der hybriden Kryptographie werden mehrere Chiffren unterschiedlichen Typs zusammen verwendet, indem die Vorteile der einzelnen Chiffren berücksichtigt werden. Es gibt einen gängigen Ansatz, der normalerweise verfolgt wird, um einen zufälligen geheimen Schlüssel für eine symmetrische Verschlüsselung zu generieren und diesen Schlüssel dann über eine Kryptographie mit asymmetrischem Schlüssel zu verschlüsseln.
Aufgrund dieses Musters wird die ursprüngliche Nachricht selbst mit der symmetrischen Verschlüsselung und anschließend mit dem geheimen Schlüssel verschlüsselt. Der Empfänger entschlüsselt die Nachricht nach dem Empfang der Nachricht zuerst mit einem geheimen Schlüssel, wobei er seinen eigenen privaten Schlüssel verwendet, und verwendet dann den angegebenen Schlüssel, um die Nachricht zu entschlüsseln.
Python ist eine Open-Source-Skriptsprache, die auf hoher Ebene interpretiert, interaktiv und objektorientiert ist. Es ist so konzipiert, dass es gut lesbar ist. Die Syntax der Python-Sprache ist leicht zu verstehen und verwendet häufig englische Schlüsselwörter.
Funktionen der Python-Sprache
Python bietet die folgenden Hauptfunktionen:
Interpretiert
Python wird zur Laufzeit mit dem Interpreter verarbeitet. Vor der Ausführung muss kein Programm kompiliert werden. Es ist ähnlich wie PERL und PHP.
Objektorientierter
Python folgt objektorientierten Stil- und Designmustern. Es enthält eine Klassendefinition mit verschiedenen Merkmalen wie Kapselung und Polymorphismus.
Wichtige Punkte der Python-Sprache
Die wichtigsten Punkte der Programmiersprache Python sind:
Es umfasst funktionale und strukturierte Programmierung und Methoden sowie objektorientierte Programmiermethoden.
Es kann als Skriptsprache oder als Programmiersprache verwendet werden.
Es enthält eine automatische Speicherbereinigung.
Es enthält dynamische Datentypen auf hoher Ebene und unterstützt verschiedene dynamische Typprüfungen.
Python enthält eine Funktion zur Integration in C, C ++ und Sprachen wie Java.
Der Download-Link für die Python-Sprache lautet wie folgt: www.python.org/downloads Er enthält Pakete für verschiedene Betriebssysteme wie Windows-, MacOS- und Linux-Distributionen.
Python-Strings
Die grundlegende Deklaration von Zeichenfolgen ist unten dargestellt -
str = 'Hello World!'
Python-Listen
Die Python-Listen können als zusammengesetzte Datentypen deklariert, durch Kommas getrennt und in eckige Klammern ([]) eingeschlossen werden.
list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
Python-Tupel
Ein Tupel ist ein dynamischer Python-Datentyp, der aus einer Anzahl von durch Kommas getrennten Werten besteht. Tupel sind in Klammern eingeschlossen.
tinytuple = (123, 'john')
Python-Wörterbuch
Python-Wörterbuch ist eine Art Hash-Tabelle. Ein Wörterbuchschlüssel kann fast jeder Datentyp von Python sein, bei dem es sich normalerweise um Zahlen oder Zeichenfolgen handelt.
tinydict = {'name': 'omkar','code':6734, 'dept': 'sales'}
Kryptographie-Pakete
Python enthält ein Paket namens Kryptographie, das kryptografische Rezepte und Grundelemente enthält. Es unterstützt Python 2.7, Python 3.4+ und PyPy 5.3+. Die grundlegende Installation des Kryptografiepakets erfolgt über den folgenden Befehl:
pip install cryptography
Es gibt verschiedene Pakete mit Rezepten auf hoher Ebene und Schnittstellen auf niedriger Ebene zu gängigen kryptografischen Algorithmen wie z symmetric ciphers, message digests und key derivation functions.
In diesem Tutorial werden wir verschiedene Python-Pakete zur Implementierung kryptografischer Algorithmen verwenden.
Das vorherige Kapitel gab Ihnen einen Überblick über die Installation von Python auf Ihrem lokalen Computer. In diesem Kapitel erfahren Sie mehr über die umgekehrte Verschlüsselung und ihre Codierung.
Algorithmus der umgekehrten Verschlüsselung
Der Algorithmus der umgekehrten Verschlüsselung enthält die folgenden Merkmale:
Reverse Cipher verwendet ein Muster zum Umkehren der einfachen Textzeichenfolge, um sie als Chiffretext zu konvertieren.
Der Prozess der Ver- und Entschlüsselung ist der gleiche.
Um den Chiffretext zu entschlüsseln, muss der Benutzer den Chiffretext lediglich umkehren, um den Klartext zu erhalten.
Nachteil
Der Hauptnachteil der umgekehrten Chiffre ist, dass sie sehr schwach ist. Ein Hacker kann den Chiffretext leicht brechen, um die ursprüngliche Nachricht zu erhalten. Daher wird die umgekehrte Verschlüsselung nicht als gute Option zur Aufrechterhaltung eines sicheren Kommunikationskanals angesehen.
Beispiel
Betrachten Sie ein Beispiel, in dem die Anweisung This is program to explain reverse cipherist mit Reverse-Cipher-Algorithmus zu implementieren. Der folgende Python-Code verwendet den Algorithmus, um die Ausgabe zu erhalten.
message = 'This is program to explain reverse cipher.'
translated = '' #cipher text is stored in this variable
i = len(message) - 1
while i >= 0:
translated = translated + message[i]
i = i - 1
print(“The cipher text is : “, translated)
Ausgabe
Sie können den umgekehrten Text sehen, das ist die Ausgabe, wie im folgenden Bild gezeigt -
Erläuterung
In der Variablennachricht wird einfacher Text gespeichert, und in der übersetzten Variablen wird der erstellte Chiffretext gespeichert.
Die Länge des Klartextes wird mit berechnet for Schleife und mit Hilfe von index number. Die Zeichen werden in einer Chiffretextvariablen gespeicherttranslated welches in der letzten Zeile gedruckt wird.
Im letzten Kapitel haben wir uns mit der umgekehrten Verschlüsselung befasst. In diesem Kapitel wird die Caesar-Chiffre ausführlich behandelt.
Algorithmus der Caesar-Chiffre
Der Algorithmus der Caesar-Chiffre enthält die folgenden Merkmale:
Die Caesar-Verschlüsselungstechnik ist die einfache Methode der Verschlüsselungstechnik.
Es ist eine einfache Art der Substitutionsverschlüsselung.
Jeder Klartextbuchstabe wird durch einen Buchstaben mit einer festen Anzahl von Positionen mit Alphabet ersetzt.
Das folgende Diagramm zeigt die Funktionsweise der Implementierung des Caesar-Verschlüsselungsalgorithmus -
Die Programmimplementierung des Caesar-Verschlüsselungsalgorithmus ist wie folgt:
def encrypt(text,s):
result = ""
# transverse the plain text
for i in range(len(text)):
char = text[i]
# Encrypt uppercase characters in plain text
if (char.isupper()):
result += chr((ord(char) + s-65) % 26 + 65)
# Encrypt lowercase characters in plain text
else:
result += chr((ord(char) + s - 97) % 26 + 97)
return result
#check the above function
text = "CEASER CIPHER DEMO"
s = 4
print "Plain Text : " + text
print "Shift pattern : " + str(s)
print "Cipher: " + encrypt(text,s)
Ausgabe
Sie können die Caesar-Chiffre sehen, das ist die Ausgabe, wie im folgenden Bild gezeigt -
Erläuterung
Das Klartextzeichen wird einzeln durchlaufen.
Transformieren Sie für jedes Zeichen im angegebenen Klartext das angegebene Zeichen gemäß der Regel in Abhängigkeit von der Ver- und Entschlüsselung des Texts.
Nachdem die Schritte ausgeführt wurden, wird eine neue Zeichenfolge generiert, die als Chiffretext bezeichnet wird.
Hacking des Caesar Cipher Algorithmus
Der Chiffretext kann mit verschiedenen Möglichkeiten gehackt werden. Eine solche Möglichkeit istBrute Force Technique,Dabei wird jeder mögliche Entschlüsselungsschlüssel ausprobiert. Diese Technik erfordert nicht viel Aufwand und ist für einen Hacker relativ einfach.
Die Programmimplementierung zum Hacken des Caesar-Verschlüsselungsalgorithmus lautet wie folgt:
message = 'GIEWIVrGMTLIVrHIQS' #encrypted message
LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for key in range(len(LETTERS)):
translated = ''
for symbol in message:
if symbol in LETTERS:
num = LETTERS.find(symbol)
num = num - key
if num < 0:
num = num + len(LETTERS)
translated = translated + LETTERS[num]
else:
translated = translated + symbol
print('Hacking key #%s: %s' % (key, translated))
Betrachten Sie den im vorherigen Beispiel verschlüsselten Chiffretext. Dann ist die Ausgabe mit möglichen Hacking-Methoden mit dem Schlüssel und unter Verwendung der Brute-Force-Angriffstechnik wie folgt:
Bis jetzt haben Sie etwas über Reverse Cipher- und Caesar Cipher-Algorithmen gelernt. Lassen Sie uns nun den ROT13-Algorithmus und seine Implementierung diskutieren.
Erklärung des ROT13-Algorithmus
Die ROT13-Chiffre bezieht sich auf die abgekürzte Form Rotate by 13 places. Es ist ein Sonderfall von Caesar Cipher, bei dem die Verschiebung immer 13 beträgt. Jeder Buchstabe wird um 13 Stellen verschoben, um die Nachricht zu verschlüsseln oder zu entschlüsseln.
Beispiel
Das folgende Diagramm erläutert den Prozess des ROT13-Algorithmus bildlich -
Programmcode
Die Programmimplementierung des ROT13-Algorithmus ist wie folgt:
from string import maketrans
rot13trans = maketrans('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm')
# Function to translate plain text
def rot13(text):
return text.translate(rot13trans)
def main():
txt = "ROT13 Algorithm"
print rot13(txt)
if __name__ == "__main__":
main()
Sie können die ROT13-Ausgabe wie im folgenden Bild sehen -
Nachteil
Der ROT13-Algorithmus verwendet 13 Schichten. Daher ist es sehr einfach, die Zeichen in umgekehrter Weise zu verschieben, um den Chiffretext zu entschlüsseln.
Analyse des ROT13-Algorithmus
Der ROT13-Verschlüsselungsalgorithmus wird als Sonderfall der Caesar-Verschlüsselung betrachtet. Es ist kein sehr sicherer Algorithmus und kann leicht durch Frequenzanalyse oder durch Ausprobieren möglicher 25 Tasten gebrochen werden, während ROT13 durch Verschieben von 13 Stellen gebrochen werden kann. Daher beinhaltet es keine praktische Verwendung.
Transposition Cipher ist ein kryptografischer Algorithmus, bei dem die Reihenfolge der Alphabete im Klartext neu angeordnet wird, um einen Chiffretext zu bilden. In diesem Prozess sind die eigentlichen Klartextalphabete nicht enthalten.
Beispiel
Ein einfaches Beispiel für eine Transpositionsverschlüsselung ist columnar transposition cipherDabei wird jedes Zeichen im Klartext horizontal mit der angegebenen Alphabetbreite geschrieben. Die Chiffre ist vertikal geschrieben, wodurch ein völlig anderer Chiffretext entsteht.
Betrachten Sie den Klartext hello worldund lassen Sie uns die einfache säulenförmige Transpositionstechnik wie unten gezeigt anwenden
Die Klartextzeichen werden horizontal platziert und der Chiffretext wird im vertikalen Format als erstellt : holewdlo lr. Jetzt muss der Empfänger dieselbe Tabelle verwenden, um den Chiffretext in Klartext zu entschlüsseln.
Code
Der folgende Programmcode demonstriert die grundlegende Implementierung der säulenförmigen Transpositionstechnik -
def split_len(seq, length):
return [seq[i:i + length] for i in range(0, len(seq), length)]
def encode(key, plaintext):
order = {
int(val): num for num, val in enumerate(key)
}
ciphertext = ''
for index in sorted(order.keys()):
for part in split_len(plaintext, len(key)):
try:ciphertext += part[order[index]]
except IndexError:
continue
return ciphertext
print(encode('3214', 'HELLO'))
Erläuterung
Verwendung der Funktion split_len(), Wir können die Klartextzeichen teilen, die im Spalten- oder Zeilenformat platziert werden können.
encode Die Methode hilft beim Erstellen von Chiffretext mit einem Schlüssel, der die Anzahl der Spalten angibt, und druckt den Chiffretext, indem Zeichen durch jede Spalte gelesen werden.
Ausgabe
Der Programmcode für die grundlegende Implementierung der Säulentranspositionstechnik liefert die folgende Ausgabe:
Note- Kryptoanalytiker beobachteten eine signifikante Verbesserung der Kryptosicherheit, wenn die Transpositionstechnik durchgeführt wird. Sie stellten auch fest, dass das erneute Verschlüsseln des Chiffretextes unter Verwendung derselben Transpositionschiffre eine bessere Sicherheit schafft.
Im vorherigen Kapitel haben wir etwas über Transposition Cipher gelernt. Lassen Sie uns in diesem Kapitel die Verschlüsselung diskutieren.
Pyperclip
Die Hauptverwendung von pyperclipDas Plugin in der Programmiersprache Python dient zum Ausführen eines plattformübergreifenden Moduls zum Kopieren und Einfügen von Text in die Zwischenablage. Sie können Python installierenpyperclip Modul mit dem Befehl wie gezeigt
pip install pyperclip
Wenn die Anforderung bereits im System vorhanden ist, sehen Sie die folgende Ausgabe:
Code
Der Python-Code zum Verschlüsseln der Transpositionsverschlüsselung, bei dem Pyperclip das Hauptmodul ist, lautet wie folgt:
import pyperclip
def main():
myMessage = 'Transposition Cipher'
myKey = 10
ciphertext = encryptMessage(myKey, myMessage)
print("Cipher Text is")
print(ciphertext + '|')
pyperclip.copy(ciphertext)
def encryptMessage(key, message):
ciphertext = [''] * key
for col in range(key):
position = col
while position < len(message):
ciphertext[col] += message[position]
position += key
return ''.join(ciphertext) #Cipher text
if __name__ == '__main__':
main()
Ausgabe
Der Programmcode zum Verschlüsseln der Transpositionsverschlüsselung, in dem pyperclip ist das Hauptmodul gibt die folgende Ausgabe -
Erläuterung
Die Funktion main() ruft die encryptMessage() Dies beinhaltet die Prozedur zum Teilen der Zeichen mit len Funktion und Iteration in einem Spaltenformat.
Die Hauptfunktion wird am Ende initialisiert, um die entsprechende Ausgabe zu erhalten.
In diesem Kapitel erfahren Sie, wie Sie die Transpositionsverschlüsselung entschlüsseln.
Code
Beachten Sie den folgenden Code, um das Entschlüsseln einer Transpositionsverschlüsselung besser zu verstehen. Der Chiffretext für die NachrichtTransposition Cipher mit Schlüssel als 6 wird abgerufen als Toners raiCntisippoh.
import math, pyperclip
def main():
myMessage= 'Toners raiCntisippoh'
myKey = 6
plaintext = decryptMessage(myKey, myMessage)
print("The plain text is")
print('Transposition Cipher')
def decryptMessage(key, message):
numOfColumns = math.ceil(len(message) / key)
numOfRows = key
numOfShadedBoxes = (numOfColumns * numOfRows) - len(message)
plaintext = float('') * numOfColumns
col = 0
row = 0
for symbol in message:
plaintext[col] += symbol
col += 1
if (col == numOfColumns) or (col == numOfColumns - 1 and row >= numOfRows - numOfShadedBoxes):
col = 0 row += 1 return ''.join(plaintext)
if __name__ == '__main__':
main()
Erläuterung
Der Chiffretext und der erwähnte Schlüssel sind die beiden Werte, die als Eingabeparameter zum Dekodieren oder Entschlüsseln des Chiffretextes in umgekehrter Technik verwendet werden, indem Zeichen in einem Spaltenformat platziert und horizontal gelesen werden.
Sie können Buchstaben in einem Spaltenformat platzieren und später mit dem folgenden Code kombinieren oder verketten:
for symbol in message:
plaintext[col] += symbol
col += 1
if (col == numOfColumns) or (col == numOfColumns - 1 and row >= numOfRows - numOfShadedBoxes):
col = 0
row += 1
return ''.join(plaintext)
Ausgabe
Der Programmcode zum Entschlüsseln der Transpositionsverschlüsselung gibt die folgende Ausgabe aus:
In Python ist es möglich, Dateien vor der Übertragung an einen Kommunikationskanal zu verschlüsseln und zu entschlüsseln. Dazu müssen Sie das Plugin verwendenPyCrypto. Sie können dieses Plugin mit dem unten angegebenen Befehl installieren.
pip install pycrypto
Code
Der Programmcode zum Verschlüsseln der Datei mit dem Passwortschutz ist unten aufgeführt -
# =================Other Configuration================
# Usages :
usage = "usage: %prog [options] "
# Version
Version="%prog 0.0.1"
# ====================================================
# Import Modules
import optparse, sys,os
from toolkit import processor as ps
def main():
parser = optparse.OptionParser(usage = usage,version = Version)
parser.add_option(
'-i','--input',type = 'string',dest = 'inputfile',
help = "File Input Path For Encryption", default = None)
parser.add_option(
'-o','--output',type = "string",dest = 'outputfile',
help = "File Output Path For Saving Encrypter Cipher",default = ".")
parser.add_option(
'-p','--password',type = "string",dest = 'password',
help = "Provide Password For Encrypting File",default = None)
parser.add_option(
'-p','--password',type = "string",dest = 'password',
help = "Provide Password For Encrypting File",default = None)
(options, args)= parser.parse_args()
# Input Conditions Checkings
if not options.inputfile or not os.path.isfile(options.inputfile):
print " [Error] Please Specify Input File Path"
exit(0)
if not options.outputfile or not os.path.isdir(options.outputfile):
print " [Error] Please Specify Output Path"
exit(0)
if not options.password:
print " [Error] No Password Input"
exit(0)
inputfile = options.inputfile
outputfile = os.path.join(
options.outputfile,os.path.basename(options.inputfile).split('.')[0]+'.ssb')
password = options.password
base = os.path.basename(inputfile).split('.')[1]
work = "E"
ps.FileCipher(inputfile,outputfile,password,work)
return
if __name__ == '__main__':
main()
Mit dem folgenden Befehl können Sie den Verschlüsselungsprozess zusammen mit dem Kennwort ausführen:
python pyfilecipher-encrypt.py -i file_path_for_encryption -o output_path -p password
Ausgabe
Sie können die folgende Ausgabe beobachten, wenn Sie den oben angegebenen Code ausführen -
Erläuterung
Die Passwörter werden mithilfe des MD5-Hash-Algorithmus generiert und die Werte werden in einfach sicheren Sicherungsdateien im Windows-System gespeichert, einschließlich der unten angezeigten Werte.
Lassen Sie uns in diesem Kapitel die Entschlüsselung von Dateien in der Kryptographie mit Python diskutieren. Beachten Sie, dass wir für den Entschlüsselungsprozess das gleiche Verfahren anwenden, aber anstatt den Ausgabepfad anzugeben, konzentrieren wir uns auf den Eingabepfad oder die erforderliche Datei, die verschlüsselt ist.
Code
Das Folgende ist ein Beispielcode zum Entschlüsseln von Dateien in der Kryptographie mit Python -
#!/usr/bin/python
# ---------------- READ ME ---------------------------------------------
# This Script is Created Only For Practise And Educational Purpose Only
# This Script Is Created For http://bitforestinfo.blogspot.in
# This Script is Written By
#
#
##################################################
######## Please Don't Remove Author Name #########
############### Thanks ###########################
##################################################
#
#
# =================Other Configuration================
# Usages :
usage = "usage: %prog [options] "
# Version
Version="%prog 0.0.1"
# ====================================================
# Import Modules
import optparse, sys,os
from toolkit import processor as ps
def main():
parser = optparse.OptionParser(usage = usage,version = Version)
parser.add_option(
'-i','--input',type = 'string',dest = 'inputfile',
help = "File Input Path For Encryption", default = None)
parser.add_option(
'-o','--output',type = "string",dest = 'outputfile',
help = "File Output Path For Saving Encrypter Cipher",default = ".")
parser.add_option(
'-p','--password',type = "string",dest = 'password',
help = "Provide Password For Encrypting File",default = None)
(options, args) = parser.parse_args()
# Input Conditions Checkings
if not options.inputfile or not os.path.isfile(options.inputfile):
print " [Error] Please Specify Input File Path"
exit(0)
if not options.outputfile or not os.path.isdir(options.outputfile):
print " [Error] Please Specify Output Path"
exit(0)
if not options.password:
print " [Error] No
exit(0)
inputfile = options.inputfile
outputfile = options.outputfile
password = options.password
work = "D"
ps.FileCipher(inputfile,outputfile,password,work)
return
if __name__ == '__main__':
main()
Sie können den folgenden Befehl verwenden, um den obigen Code auszuführen:
python pyfilecipher-decrypt.py -i encrypted_file_path -p password
Ausgabe
Sie können den folgenden Code beobachten, wenn Sie den oben gezeigten Befehl ausführen:
Note - Die Ausgabe gibt die Hash-Werte vor und nach der Entschlüsselung an. Dabei wird darauf hingewiesen, dass dieselbe Datei verschlüsselt ist und der Vorgang erfolgreich war.
Die Base64-Codierung konvertiert die Binärdaten in ein Textformat, das über den Kommunikationskanal geleitet wird, wo ein Benutzer sicher mit Text umgehen kann. Base64 wird auch als bezeichnetPrivacy enhanced Electronic mail (PEM) und wird hauptsächlich bei der E-Mail-Verschlüsselung verwendet.
Python enthält ein Modul namens BASE64 welches zwei Hauptfunktionen enthält, wie unten angegeben -
base64.decode(input, output) - Es decodiert den angegebenen Eingabewertparameter und speichert die decodierte Ausgabe als Objekt.
Base64.encode(input, output) - Es codiert den angegebenen Eingabewertparameter und speichert die decodierte Ausgabe als Objekt.
Programm zur Codierung
Sie können den folgenden Code verwenden, um die Base64-Codierung durchzuführen:
import base64
encoded_data = base64.b64encode("Encode this text")
print("Encoded text with base 64 is")
print(encoded_data)
Ausgabe
Der Code für die Base64-Codierung gibt Ihnen die folgende Ausgabe:
Programm zur Dekodierung
Sie können den folgenden Code verwenden, um die base64-Decodierung durchzuführen:
import base64
decoded_data = base64.b64decode("RW5jb2RlIHRoaXMgdGV4dA==")
print("decoded text is ")
print(decoded_data)
Ausgabe
Der Code für die Base64-Decodierung gibt Ihnen die folgende Ausgabe:
Unterschied zwischen ASCII und base64
Sie können die folgenden Unterschiede feststellen, wenn Sie mit ASCII und base64 zum Codieren von Daten arbeiten:
Wenn Sie Text in ASCII codieren, beginnen Sie mit einer Textzeichenfolge und konvertieren sie in eine Folge von Bytes.
Wenn Sie Daten in Base64 codieren, beginnen Sie mit einer Folge von Bytes und konvertieren sie in eine Textzeichenfolge.
Nachteil
Der Base64-Algorithmus wird normalerweise zum Speichern von Passwörtern in der Datenbank verwendet. Der Hauptnachteil besteht darin, dass jedes decodierte Wort einfach über jedes Online-Tool codiert werden kann und Eindringlinge die Informationen leicht abrufen können.
Lassen Sie uns in diesem Kapitel den XOR-Prozess zusammen mit seiner Codierung in Python verstehen.
Algorithmus
Der XOR-Algorithmus für die Ver- und Entschlüsselung konvertiert den Klartext in das Format ASCII-Bytes und konvertiert ihn mithilfe der XOR-Prozedur in ein bestimmtes Byte. Es bietet seinen Benutzern die folgenden Vorteile:
- Schnelle Berechnung
- Auf der linken und rechten Seite ist kein Unterschied erkennbar
- Einfach zu verstehen und zu analysieren
Code
Sie können den folgenden Code verwenden, um den XOR-Prozess auszuführen:
def xor_crypt_string(data, key = 'awesomepassword', encode = False, decode = False):
from itertools import izip, cycle
import base64
if decode:
data = base64.decodestring(data)
xored = ''.join(chr(ord(x) ^ ord(y)) for (x,y) in izip(data, cycle(key)))
if encode:
return base64.encodestring(xored).strip()
return xored
secret_data = "XOR procedure"
print("The cipher text is")
print xor_crypt_string(secret_data, encode = True)
print("The plain text fetched")
print xor_crypt_string(xor_crypt_string(secret_data, encode = True), decode = True)
Ausgabe
Der Code für den XOR-Prozess gibt Ihnen die folgende Ausgabe:
Erläuterung
Die Funktion xor_crypt_string() Enthält einen Parameter zur Angabe des Codierungs- und Decodierungsmodus sowie den Zeichenfolgenwert.
Die Grundfunktionen werden mit base64-Modulen übernommen, die der XOR-Prozedur / Operation zum Ver- oder Entschlüsseln des Klartextes / Chiffretextes folgen.
Note - Die XOR-Verschlüsselung wird zum Verschlüsseln von Daten verwendet und ist mit der Brute-Force-Methode schwer zu knacken, dh indem zufällige Verschlüsselungsschlüssel generiert werden, die mit dem richtigen Chiffretext übereinstimmen.
Bei Verwendung der Caesar-Verschlüsselungstechnik werden beim Ver- und Entschlüsseln von Symbolen die Werte mit einem einfachen grundlegenden Verfahren zum Addieren oder Subtrahieren in Zahlen umgewandelt.
Wenn die Multiplikation zur Konvertierung in Chiffretext verwendet wird, wird sie als a bezeichnet wrap-aroundSituation. Betrachten Sie die Buchstaben und die zugehörigen Zahlen, die wie unten gezeigt verwendet werden sollen -
Die Zahlen werden für das Multiplikationsverfahren verwendet und der zugehörige Schlüssel ist 7. Die Grundformel, die in einem solchen Szenario zum Erzeugen einer multiplikativen Chiffre verwendet werden muss, lautet wie folgt:
(Alphabet Number * key)mod(total number of alphabets)
Die durch die Ausgabe abgerufene Nummer wird in der oben genannten Tabelle abgebildet und der entsprechende Buchstabe als verschlüsselter Buchstabe verwendet.
Die grundlegende Modulationsfunktion einer multiplikativen Chiffre in Python lautet wie folgt:
def unshift(key, ch):
offset = ord(ch) - ASC_A
return chr(((key[0] * (offset + key[1])) % WIDTH) + ASC_A)
Note- Der Vorteil einer multiplikativen Verschlüsselung besteht darin, dass sie mit sehr großen Schlüsseln wie 8.953.851 arbeiten kann. Es würde ziemlich lange dauern, bis ein Computer die Mehrheit von neun Millionen Schlüsseln brutal durchbrennt.
Affine Cipher ist die Kombination aus Multiplicative Cipher und Caesar Cipher-Algorithmus. Die grundlegende Implementierung der affinen Verschlüsselung ist in der folgenden Abbildung dargestellt.
In diesem Kapitel implementieren wir die affine Verschlüsselung, indem wir die entsprechende Klasse erstellen, die zwei Grundfunktionen für die Ver- und Entschlüsselung enthält.
Code
Sie können den folgenden Code verwenden, um eine affine Verschlüsselung zu implementieren:
class Affine(object):
DIE = 128
KEY = (7, 3, 55)
def __init__(self):
pass
def encryptChar(self, char):
K1, K2, kI = self.KEY
return chr((K1 * ord(char) + K2) % self.DIE)
def encrypt(self, string):
return "".join(map(self.encryptChar, string))
def decryptChar(self, char):
K1, K2, KI = self.KEY
return chr(KI * (ord(char) - K2) % self.DIE)
def decrypt(self, string):
return "".join(map(self.decryptChar, string))
affine = Affine()
print affine.encrypt('Affine Cipher')
print affine.decrypt('*18?FMT')
Ausgabe
Sie können die folgende Ausgabe beobachten, wenn Sie eine affine Verschlüsselung implementieren:
Die Ausgabe zeigt die verschlüsselte Nachricht für die Nur-Text-Nachricht an Affine Cipher und entschlüsselte Nachricht für die als Eingabe gesendete Nachricht abcdefg.
In diesem Kapitel erfahren Sie mehr über die monoalphabetische Verschlüsselung und deren Hacking mit Python.
Monoalphabetische Chiffre
Eine monoalphabetische Verschlüsselung verwendet eine feste Ersetzung zum Verschlüsseln der gesamten Nachricht. Eine monoalphabetische Verschlüsselung unter Verwendung eines Python-Wörterbuchs mit JSON-Objekten wird hier gezeigt -
monoalpha_cipher = {
'a': 'm',
'b': 'n',
'c': 'b',
'd': 'v',
'e': 'c',
'f': 'x',
'g': 'z',
'h': 'a',
'i': 's',
'j': 'd',
'k': 'f',
'l': 'g',
'm': 'h',
'n': 'j',
'o': 'k',
'p': 'l',
'q': 'p',
'r': 'o',
's': 'i',
't': 'u',
'u': 'y',
'v': 't',
'w': 'r',
'x': 'e',
'y': 'w',
'z': 'q',
' ': ' ',
}
Mit Hilfe dieses Wörterbuchs können wir die Buchstaben mit den zugehörigen Buchstaben als Werte im JSON-Objekt verschlüsseln. Das folgende Programm erstellt ein monoalphabetisches Programm als Klassendarstellung, das alle Funktionen der Ver- und Entschlüsselung enthält.
from string import letters, digits
from random import shuffle
def random_monoalpha_cipher(pool = None):
if pool is None:
pool = letters + digits
original_pool = list(pool)
shuffled_pool = list(pool)
shuffle(shuffled_pool)
return dict(zip(original_pool, shuffled_pool))
def inverse_monoalpha_cipher(monoalpha_cipher):
inverse_monoalpha = {}
for key, value in monoalpha_cipher.iteritems():
inverse_monoalpha[value] = key
return inverse_monoalpha
def encrypt_with_monoalpha(message, monoalpha_cipher):
encrypted_message = []
for letter in message:
encrypted_message.append(monoalpha_cipher.get(letter, letter))
return ''.join(encrypted_message)
def decrypt_with_monoalpha(encrypted_message, monoalpha_cipher):
return encrypt_with_monoalpha(
encrypted_message,
inverse_monoalpha_cipher(monoalpha_cipher)
)
Diese Datei wird später aufgerufen, um den Verschlüsselungs- und Entschlüsselungsprozess der monoalphabetischen Verschlüsselung zu implementieren, der wie folgt erwähnt wird:
import monoalphabeticCipher as mc
cipher = mc.random_monoalpha_cipher()
print(cipher)
encrypted = mc.encrypt_with_monoalpha('Hello all you hackers out there!', cipher)
decrypted = mc.decrypt_with_monoalpha('sXGGt SGG Nt0 HSrLXFC t0U UHXFX!', cipher)
print(encrypted)
print(decrypted)
Ausgabe
Sie können die folgende Ausgabe beobachten, wenn Sie den oben angegebenen Code implementieren:
Auf diese Weise können Sie eine monoalphabetische Chiffre mit einem bestimmten Schlüsselwertpaar hacken, wodurch der Chiffretext in tatsächlichen Klartext umgewandelt wird.
Die einfache Ersetzungsverschlüsselung ist die am häufigsten verwendete Verschlüsselung und enthält einen Algorithmus zum Ersetzen jedes einfachen Textzeichens durch jedes Verschlüsselungstextzeichen. In diesem Prozess werden Alphabete im Vergleich zum Caesar-Verschlüsselungsalgorithmus durcheinander gebracht.
Beispiel
Schlüssel für eine einfache Substitutions-Chiffre bestehen normalerweise aus 26 Buchstaben. Ein Beispielschlüssel ist -
plain alphabet : abcdefghijklmnopqrstuvwxyz
cipher alphabet: phqgiumeaylnofdxjkrcvstzwb
Eine beispielhafte Verschlüsselung mit dem obigen Schlüssel ist−
plaintext : defend the east wall of the castle
ciphertext: giuifg cei iprc tpnn du cei qprcni
Der folgende Code zeigt ein Programm zum Implementieren einer einfachen Substitutionsverschlüsselung -
import random, sys
LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def main():
message = ''
if len(sys.argv) > 1:
with open(sys.argv[1], 'r') as f:
message = f.read()
else:
message = raw_input("Enter your message: ")
mode = raw_input("E for Encrypt, D for Decrypt: ")
key = ''
while checkKey(key) is False:
key = raw_input("Enter 26 ALPHA key (leave blank for random key): ")
if key == '':
key = getRandomKey()
if checkKey(key) is False:
print('There is an error in the key or symbol set.')
translated = translateMessage(message, key, mode)
print('Using key: %s' % (key))
if len(sys.argv) > 1:
fileOut = 'enc.' + sys.argv[1]
with open(fileOut, 'w') as f:
f.write(translated)
print('Success! File written to: %s' % (fileOut))
else: print('Result: ' + translated)
# Store the key into list, sort it, convert back, compare to alphabet.
def checkKey(key):
keyString = ''.join(sorted(list(key)))
return keyString == LETTERS
def translateMessage(message, key, mode):
translated = ''
charsA = LETTERS
charsB = key
# If decrypt mode is detected, swap A and B
if mode == 'D':
charsA, charsB = charsB, charsA
for symbol in message:
if symbol.upper() in charsA:
symIndex = charsA.find(symbol.upper())
if symbol.isupper():
translated += charsB[symIndex].upper()
else:
translated += charsB[symIndex].lower()
else:
translated += symbol
return translated
def getRandomKey():
randomList = list(LETTERS)
random.shuffle(randomList)
return ''.join(randomList)
if __name__ == '__main__':
main()
Ausgabe
Sie können die folgende Ausgabe beobachten, wenn Sie den oben angegebenen Code implementieren:
In diesem Kapitel konzentrieren wir uns auf das Testen der Substitutionsverschlüsselung mit verschiedenen Methoden, mit deren Hilfe zufällige Zeichenfolgen wie unten angegeben generiert werden können.
import random, string, substitution
def main():
for i in range(1000):
key = substitution.getRandomKey()
message = random_string()
print('Test %s: String: "%s.."' % (i + 1, message[:50]))
print("Key: " + key)
encrypted = substitution.translateMessage(message, key, 'E')
decrypted = substitution.translateMessage(encrypted, key, 'D')
if decrypted != message:
print('ERROR: Decrypted: "%s" Key: %s' % (decrypted, key))
sys.exit()
print('Substutition test passed!')
def random_string(size = 5000, chars = string.ascii_letters + string.digits):
return ''.join(random.choice(chars) for _ in range(size))
if __name__ == '__main__':
main()
Ausgabe
Sie können die Ausgabe als zufällig generierte Zeichenfolgen betrachten, die beim Generieren zufälliger Klartextnachrichten hilfreich sind, wie unten gezeigt -
Nachdem der Test erfolgreich abgeschlossen wurde, können wir die Ausgabenachricht beobachten Substitution test passed!.
Auf diese Weise können Sie eine Substitutions-Chiffre systematisch hacken.
In diesem Kapitel erfahren Sie mehr über die einfache Implementierung der Substitutionsverschlüsselung, bei der die verschlüsselte und entschlüsselte Nachricht gemäß der in der einfachen Substitutionsverschlüsselungstechnik verwendeten Logik angezeigt wird. Dies kann als alternativer Ansatz für die Codierung angesehen werden.
Code
Sie können den folgenden Code verwenden, um die Entschlüsselung mit einer einfachen Substitutionsverschlüsselung durchzuführen:
import random
chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + \
'abcdefghijklmnopqrstuvwxyz' + \
'0123456789' + \
':.;,?!@#$%&()+=-*/_<> []{}`~^"\'\\'
def generate_key():
"""Generate an key for our cipher"""
shuffled = sorted(chars, key=lambda k: random.random())
return dict(zip(chars, shuffled))
def encrypt(key, plaintext):
"""Encrypt the string and return the ciphertext"""
return ''.join(key[l] for l in plaintext)
def decrypt(key, ciphertext):
"""Decrypt the string and return the plaintext"""
flipped = {v: k for k, v in key.items()}
return ''.join(flipped[l] for l in ciphertext)
def show_result(plaintext):
"""Generate a resulting cipher with elements shown"""
key = generate_key()
encrypted = encrypt(key, plaintext)
decrypted = decrypt(key, encrypted)
print 'Key: %s' % key
print 'Plaintext: %s' % plaintext
print 'Encrypted: %s' % encrypted
print 'Decrypted: %s' % decrypted
show_result('Hello World. This is demo of substitution cipher')
Ausgabe
Der obige Code gibt Ihnen die Ausgabe wie hier gezeigt -
In diesem Kapitel erfahren Sie mehr über verschiedene Kryptografiemodule in Python.
Kryptografiemodul
Es enthält alle Rezepte und Grundelemente und bietet eine allgemeine Codierungsschnittstelle in Python. Sie können das Kryptografiemodul mit dem folgenden Befehl installieren:
pip install cryptography
Code
Sie können den folgenden Code verwenden, um das Kryptografiemodul zu implementieren:
from cryptography.fernet import Fernet
key = Fernet.generate_key()
cipher_suite = Fernet(key)
cipher_text = cipher_suite.encrypt("This example is used to demonstrate cryptography module")
plain_text = cipher_suite.decrypt(cipher_text)
Ausgabe
Der oben angegebene Code erzeugt die folgende Ausgabe:
Der hier angegebene Code wird verwendet, um das Kennwort zu überprüfen und seinen Hash zu erstellen. Es enthält auch eine Logik zum Überprüfen des Kennworts zu Authentifizierungszwecken.
import uuid
import hashlib
def hash_password(password):
# uuid is used to generate a random number of the specified password
salt = uuid.uuid4().hex
return hashlib.sha256(salt.encode() + password.encode()).hexdigest() + ':' + salt
def check_password(hashed_password, user_password):
password, salt = hashed_password.split(':')
return password == hashlib.sha256(salt.encode() + user_password.encode()).hexdigest()
new_pass = input('Please enter a password: ')
hashed_password = hash_password(new_pass)
print('The string to store in the db is: ' + hashed_password)
old_pass = input('Now please enter the password again to check: ')
if check_password(hashed_password, old_pass):
print('You entered the right password')
else:
print('Passwords do not match')
Ausgabe
Scenario 1 - Wenn Sie ein korrektes Passwort eingegeben haben, finden Sie folgende Ausgabe:
Scenario 2 - Wenn wir ein falsches Passwort eingeben, finden Sie folgende Ausgabe:
Erläuterung
HashlibPaket wird zum Speichern von Passwörtern in einer Datenbank verwendet. In diesem Programmsalt wird verwendet, die der Kennwortzeichenfolge eine zufällige Sequenz hinzufügt, bevor die Hash-Funktion implementiert wird.
Vignere Cipher enthält einen Twist mit Caesar Cipher-Algorithmus, der zum Ver- und Entschlüsseln verwendet wird. Vignere Cipher funktioniert ähnlich wie der Caesar Cipher-Algorithmus mit nur einem Hauptunterschied: Caesar Cipher enthält einen Algorithmus für die Verschiebung um ein Zeichen, während Vignere Cipher einen Schlüssel mit mehreren Alphabetenverschiebungen enthält.
Mathematische Gleichung
Für die Verschlüsselung lautet die mathematische Gleichung wie folgt:
$$ E_ {k} \ left (M {_ {i {}}} \ right) = \ left (M_ {i} + K_ {i} \ right) \; \; \; mod \; \; 26 $$
Für die Entschlüsselung lautet die mathematische Gleichung wie folgt:
$$ D_ {k} \ left (C {_ {i {}}} \ right) = \ left (C_ {i} -K_ {i} \ right) \; \; \; mod \; \; 26 $$
Die Vignere-Chiffre verwendet mehr als einen Satz von Substitutionen und wird daher auch als bezeichnet polyalphabetic cipher. Vignere Cipher verwendet einen Buchstabenschlüssel anstelle einer numerischen Schlüsseldarstellung: Buchstabe A wird für Schlüssel 0, Buchstabe B für Schlüssel 1 usw. verwendet. Die Nummern der Buchstaben vor und nach dem Verschlüsselungsprozess werden unten angezeigt -
Die mögliche Kombination der Anzahl möglicher Schlüssel basierend auf der Vignere-Schlüssellänge wird wie folgt angegeben, was das Ergebnis der Sicherheit des Vignere-Verschlüsselungsalgorithmus ergibt -
Vignere Tableau
Das für die Vignere-Chiffre verwendete Tableau ist wie folgt:
Lassen Sie uns in diesem Kapitel verstehen, wie die Vignere-Verschlüsselung implementiert wird. Betrachten Sie den TextThis is basic implementation of Vignere Cipher ist zu codieren und der verwendete Schlüssel ist PIZZA.
Code
Mit dem folgenden Code können Sie eine Vignere-Verschlüsselung in Python implementieren:
import pyperclip
LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def main():
myMessage = "This is basic implementation of Vignere Cipher"
myKey = 'PIZZA'
myMode = 'encrypt'
if myMode == 'encrypt':
translated = encryptMessage(myKey, myMessage)
elif myMode == 'decrypt':
translated = decryptMessage(myKey, myMessage)
print('%sed message:' % (myMode.title()))
print(translated)
print()
def encryptMessage(key, message):
return translateMessage(key, message, 'encrypt')
def decryptMessage(key, message):
return translateMessage(key, message, 'decrypt')
def translateMessage(key, message, mode):
translated = [] # stores the encrypted/decrypted message string
keyIndex = 0
key = key.upper()
for symbol in message:
num = LETTERS.find(symbol.upper())
if num != -1:
if mode == 'encrypt':
num += LETTERS.find(key[keyIndex])
elif mode == 'decrypt':
num -= LETTERS.find(key[keyIndex])
num %= len(LETTERS)
if symbol.isupper():
translated.append(LETTERS[num])
elif symbol.islower():
translated.append(LETTERS[num].lower())
keyIndex += 1
if keyIndex == len(key):
keyIndex = 0
else:
translated.append(symbol)
return ''.join(translated)
if __name__ == '__main__':
main()
Ausgabe
Sie können die folgende Ausgabe beobachten, wenn Sie den oben angegebenen Code implementieren:
Die möglichen Kombinationen des Hackens der Vignere-Chiffre sind nahezu unmöglich. Daher wird es als sicherer Verschlüsselungsmodus angesehen.
Die einmalige Pad-Verschlüsselung ist eine Art von Vignere-Verschlüsselung, die die folgenden Funktionen enthält:
Es ist eine unzerbrechliche Chiffre.
Der Schlüssel entspricht genau der Länge der verschlüsselten Nachricht.
Der Schlüssel besteht aus zufälligen Symbolen.
Wie der Name schon sagt, wird der Schlüssel nur einmal verwendet und nie wieder für die Verschlüsselung einer anderen Nachricht.
Aus diesem Grund ist eine verschlüsselte Nachricht für einen Kryptoanalytiker anfällig für Angriffe. Der für eine einmalige Pad-Verschlüsselung verwendete Schlüssel wird aufgerufenpad, wie es auf Papierblöcken gedruckt ist.
Warum ist es unzerbrechlich?
Der Schlüssel ist aufgrund der folgenden Merkmale unzerbrechlich:
Der Schlüssel ist so lang wie die angegebene Nachricht.
Der Schlüssel ist wirklich zufällig und speziell automatisch generiert.
Schlüssel und Klartext berechnet als Modulo 26.10.2.
Jeder Schlüssel sollte einmal verwendet und sowohl vom Sender als auch vom Empfänger zerstört werden.
Es sollten zwei Kopien des Schlüssels vorhanden sein: eine mit dem Absender und eine mit dem Empfänger.
Verschlüsselung
Um einen Brief zu verschlüsseln, muss ein Benutzer einen Schlüssel unter den Klartext schreiben. Der Klartextbuchstabe befindet sich oben und der Schlüsselbuchstabe links. Der zwischen zwei Buchstaben erzielte Querschnitt ist der Klartext. Es wird im folgenden Beispiel beschrieben -
Entschlüsselung
Um einen Buchstaben zu entschlüsseln, nimmt der Benutzer den Schlüsselbuchstaben links und findet in dieser Zeile einen Chiffretextbuchstaben. Der Klartextbuchstabe befindet sich oben in der Spalte, in der der Benutzer den Chiffretextbuchstaben finden kann.
Python enthält ein hackiges Implementierungsmodul für one-time-padVerschlüsselungsimplementierung. Der Paketname heißt One-Time-Pad und enthält ein Befehlszeilenverschlüsselungstool, das einen Verschlüsselungsmechanismus verwendet, der dem One-Time-Pad-Verschlüsselungsalgorithmus ähnelt.
Installation
Mit dem folgenden Befehl können Sie dieses Modul installieren:
pip install onetimepad
Wenn Sie es über die Befehlszeile verwenden möchten, führen Sie den folgenden Befehl aus:
onetimepad
Code
Der folgende Code hilft beim Generieren einer einmaligen Pad-Verschlüsselung:
import onetimepad
cipher = onetimepad.encrypt('One Time Cipher', 'random')
print("Cipher text is ")
print(cipher)
print("Plain text is ")
msg = onetimepad.decrypt(cipher, 'random')
print(msg)
Ausgabe
Sie können die folgende Ausgabe beobachten, wenn Sie den oben angegebenen Code ausführen:
Note - Die verschlüsselte Nachricht ist sehr leicht zu knacken, wenn die Länge des Schlüssels geringer ist als die Länge der Nachricht (einfacher Text).
In jedem Fall ist der Schlüssel nicht unbedingt zufällig, was die einmalige Pad-Verschlüsselung zu einem wertvollen Werkzeug macht.
Lassen Sie uns in diesem Kapitel die symmetrische und asymmetrische Kryptographie im Detail diskutieren.
Symmetrische Kryptographie
Bei diesem Typ verwendet der Ver- und Entschlüsselungsprozess denselben Schlüssel. Es wird auch als bezeichnetsecret key cryptography. Die Hauptmerkmale der symmetrischen Kryptographie sind wie folgt:
- Es ist einfacher und schneller.
- Die beiden Parteien tauschen den Schlüssel auf sichere Weise aus.
Nachteil
Der Hauptnachteil der symmetrischen Kryptographie besteht darin, dass die Nachricht leicht geändert werden kann, wenn der Schlüssel an den Eindringling weitergegeben wird, und dies wird als Risikofaktor angesehen.
Datenverschlüsselungsstandard (DES)
Der beliebteste Algorithmus für symmetrische Schlüssel ist der Data Encryption Standard (DES). Python enthält ein Paket, das die Logik des DES-Algorithmus enthält.
Installation
Der Befehl zur Installation des DES-Pakets pyDES in Python ist -
pip install pyDES
Die einfache Programmimplementierung des DES-Algorithmus ist wie folgt:
import pyDes
data = "DES Algorithm Implementation"
k = pyDes.des("DESCRYPT", pyDes.CBC, "\0\0\0\0\0\0\0\0", pad=None, padmode=pyDes.PAD_PKCS5)
d = k.encrypt(data)
print "Encrypted: %r" % d
print "Decrypted: %r" % k.decrypt(d)
assert k.decrypt(d) == data
Es ruft die Variable auf padmode Hiermit werden alle Pakete gemäß der DES-Algorithmus-Implementierung abgerufen und die Ver- und Entschlüsselung auf eine bestimmte Weise verfolgt.
Ausgabe
Sie können die folgende Ausgabe als Ergebnis des oben angegebenen Codes sehen -
Asymmetrische Kryptographie
Es wird auch als bezeichnet public key cryptography.Es funktioniert umgekehrt wie die symmetrische Kryptographie. Dies bedeutet, dass zwei Schlüssel erforderlich sind: einer für die Verschlüsselung und einer für die Entschlüsselung. Der öffentliche Schlüssel wird zum Verschlüsseln und der private Schlüssel zum Entschlüsseln verwendet.
Nachteil
- Aufgrund seiner Schlüssellänge trägt es zu einer geringeren Verschlüsselungsgeschwindigkeit bei.
- Schlüsselverwaltung ist entscheidend.
Der folgende Programmcode in Python veranschaulicht die Funktionsweise der asymmetrischen Kryptographie unter Verwendung des RSA-Algorithmus und deren Implementierung:
from Crypto import Random
from Crypto.PublicKey import RSA
import base64
def generate_keys():
# key length must be a multiple of 256 and >= 1024
modulus_length = 256*4
privatekey = RSA.generate(modulus_length, Random.new().read)
publickey = privatekey.publickey()
return privatekey, publickey
def encrypt_message(a_message , publickey):
encrypted_msg = publickey.encrypt(a_message, 32)[0]
encoded_encrypted_msg = base64.b64encode(encrypted_msg)
return encoded_encrypted_msg
def decrypt_message(encoded_encrypted_msg, privatekey):
decoded_encrypted_msg = base64.b64decode(encoded_encrypted_msg)
decoded_decrypted_msg = privatekey.decrypt(decoded_encrypted_msg)
return decoded_decrypted_msg
a_message = "This is the illustration of RSA algorithm of asymmetric cryptography"
privatekey , publickey = generate_keys()
encrypted_msg = encrypt_message(a_message , publickey)
decrypted_msg = decrypt_message(encrypted_msg, privatekey)
print "%s - (%d)" % (privatekey.exportKey() , len(privatekey.exportKey()))
print "%s - (%d)" % (publickey.exportKey() , len(publickey.exportKey()))
print " Original content: %s - (%d)" % (a_message, len(a_message))
print "Encrypted message: %s - (%d)" % (encrypted_msg, len(encrypted_msg))
print "Decrypted message: %s - (%d)" % (decrypted_msg, len(decrypted_msg))
Ausgabe
Sie können die folgende Ausgabe finden, wenn Sie den oben angegebenen Code ausführen -
Der RSA-Algorithmus ist eine Verschlüsselungstechnik mit öffentlichem Schlüssel und wird als die sicherste Art der Verschlüsselung angesehen. Es wurde 1978 von Rivest, Shamir und Adleman erfunden und daher NameRSA Algorithmus.
Algorithmus
Der RSA-Algorithmus enthält die folgenden Funktionen:
Der RSA-Algorithmus ist eine beliebte Exponentiation in einem endlichen Feld über ganze Zahlen einschließlich Primzahlen.
Die bei diesem Verfahren verwendeten ganzen Zahlen sind ausreichend groß, was eine Lösung schwierig macht.
In diesem Algorithmus gibt es zwei Schlüsselsätze: den privaten Schlüssel und den öffentlichen Schlüssel.
Sie müssen die folgenden Schritte ausführen, um am RSA-Algorithmus zu arbeiten:
Schritt 1: Generieren Sie den RSA-Modul
Das anfängliche Verfahren beginnt mit der Auswahl von zwei Primzahlen, nämlich p und q, und der anschließenden Berechnung ihres Produkts N, wie gezeigt -
N=p*q
Hier sei N die angegebene große Zahl.
Schritt 2: Abgeleitete Nummer (e)
Betrachten Sie die Zahl e als abgeleitete Zahl, die größer als 1 und kleiner als (p-1) und (q-1) sein sollte. Die Hauptbedingung ist, dass es außer 1 keinen gemeinsamen Faktor von (p-1) und (q-1) geben sollte
Schritt 3: Öffentlicher Schlüssel
Das angegebene Zahlenpaar n und e bildet den öffentlichen RSA-Schlüssel und wird veröffentlicht.
Schritt 4: Privater Schlüssel
Privat Schlüssel dwird aus den Zahlen p, q und e berechnet. Die mathematische Beziehung zwischen den Zahlen ist wie folgt:
ed = 1 mod (p-1) (q-1)
Die obige Formel ist die Grundformel für den erweiterten euklidischen Algorithmus, der p und q als Eingabeparameter verwendet.
Verschlüsselungsformel
Stellen Sie sich einen Absender vor, der die Nur-Text-Nachricht an jemanden sendet, dessen öffentlicher Schlüssel lautet (n,e). Verwenden Sie die folgende Syntax, um die Nur-Text-Nachricht im angegebenen Szenario zu verschlüsseln:
C = Pe mod n
Entschlüsselungsformel
Der Entschlüsselungsprozess ist sehr einfach und umfasst Analysen zur Berechnung in einem systematischen Ansatz. Empfänger berücksichtigen C hat den privaten Schlüssel dwird der Ergebnismodul berechnet als -
Plaintext = Cd mod n
In diesem Kapitel konzentrieren wir uns auf die schrittweise Implementierung des RSA-Algorithmus mit Python.
RSA-Schlüssel generieren
Die folgenden Schritte sind beim Generieren von RSA-Schlüsseln erforderlich:
Erstellen Sie nämlich zwei große Primzahlen p und q. Das Produkt dieser Nummern wird aufgerufenn, wo n= p*q
Generieren Sie eine Zufallszahl, die mit relativ relativ prim ist (p-1) und (q-1). Lassen Sie die Nummer heißen als e.
Berechnen Sie die modulare Inverse von e. Die berechnete Inverse wird als bezeichnetd.
Algorithmen zum Generieren von RSA-Schlüsseln
Wir benötigen zwei primäre Algorithmen zum Generieren von RSA-Schlüsseln mit Python - Cryptomath module und Rabin Miller module.
Kryptomath-Modul
Der Quellcode des Cryptomath-Moduls, der der gesamten grundlegenden Implementierung des RSA-Algorithmus folgt, lautet wie folgt:
def gcd(a, b):
while a != 0:
a, b = b % a, a
return b
def findModInverse(a, m):
if gcd(a, m) != 1:
return None
u1, u2, u3 = 1, 0, a
v1, v2, v3 = 0, 1, m
while v3 != 0:
q = u3 // v3
v1, v2, v3, u1, u2, u3 = (u1 - q * v1), (u2 - q * v2), (u3 - q * v3), v1, v2, v3
return u1 % m
RabinMiller-Modul
Der Quellcode des RabinMiller-Moduls, der der gesamten grundlegenden Implementierung des RSA-Algorithmus folgt, lautet wie folgt:
import random
def rabinMiller(num):
s = num - 1
t = 0
while s % 2 == 0:
s = s // 2
t += 1
for trials in range(5):
a = random.randrange(2, num - 1)
v = pow(a, s, num)
if v != 1:
i = 0
while v != (num - 1):
if i == t - 1:
return False
else:
i = i + 1
v = (v ** 2) % num
return True
def isPrime(num):
if (num 7< 2):
return False
lowPrimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,
67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241,
251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,317, 331, 337, 347, 349,
353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449,
457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569,
571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661,
673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787,
797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907,
911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
if num in lowPrimes:
return True
for prime in lowPrimes:
if (num % prime == 0):
return False
return rabinMiller(num)
def generateLargePrime(keysize = 1024):
while True:
num = random.randrange(2**(keysize-1), 2**(keysize))
if isPrime(num):
return num
Der vollständige Code zum Generieren von RSA-Schlüsseln lautet wie folgt:
import random, sys, os, rabinMiller, cryptomath
def main():
makeKeyFiles('RSA_demo', 1024)
def generateKey(keySize):
# Step 1: Create two prime numbers, p and q. Calculate n = p * q.
print('Generating p prime...')
p = rabinMiller.generateLargePrime(keySize)
print('Generating q prime...')
q = rabinMiller.generateLargePrime(keySize)
n = p * q
# Step 2: Create a number e that is relatively prime to (p-1)*(q-1).
print('Generating e that is relatively prime to (p-1)*(q-1)...')
while True:
e = random.randrange(2 ** (keySize - 1), 2 ** (keySize))
if cryptomath.gcd(e, (p - 1) * (q - 1)) == 1:
break
# Step 3: Calculate d, the mod inverse of e.
print('Calculating d that is mod inverse of e...')
d = cryptomath.findModInverse(e, (p - 1) * (q - 1))
publicKey = (n, e)
privateKey = (n, d)
print('Public key:', publicKey)
print('Private key:', privateKey)
return (publicKey, privateKey)
def makeKeyFiles(name, keySize):
# Creates two files 'x_pubkey.txt' and 'x_privkey.txt'
(where x is the value in name) with the the n,e and d,e integers written in them,
# delimited by a comma.
if os.path.exists('%s_pubkey.txt' % (name)) or os.path.exists('%s_privkey.txt' % (name)):
sys.exit('WARNING: The file %s_pubkey.txt or %s_privkey.txt already exists! Use a different name or delete these files and re-run this program.' % (name, name))
publicKey, privateKey = generateKey(keySize)
print()
print('The public key is a %s and a %s digit number.' % (len(str(publicKey[0])), len(str(publicKey[1]))))
print('Writing public key to file %s_pubkey.txt...' % (name))
fo = open('%s_pubkey.txt' % (name), 'w')
fo.write('%s,%s,%s' % (keySize, publicKey[0], publicKey[1]))
fo.close()
print()
print('The private key is a %s and a %s digit number.' % (len(str(publicKey[0])), len(str(publicKey[1]))))
print('Writing private key to file %s_privkey.txt...' % (name))
fo = open('%s_privkey.txt' % (name), 'w')
fo.write('%s,%s,%s' % (keySize, privateKey[0], privateKey[1]))
fo.close()
# If makeRsaKeys.py is run (instead of imported as a module) call
# the main() function.
if __name__ == '__main__':
main()
Ausgabe
Der öffentliche und der private Schlüssel werden generiert und in den jeweiligen Dateien gespeichert, wie in der folgenden Ausgabe gezeigt.
In diesem Kapitel konzentrieren wir uns auf die unterschiedliche Implementierung der RSA-Verschlüsselung und die damit verbundenen Funktionen. Sie können diese Python-Datei zum Implementieren der Implementierung des RSA-Verschlüsselungsalgorithmus referenzieren oder einschließen.
Die für den Verschlüsselungsalgorithmus enthaltenen Module lauten wie folgt:
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA512, SHA384, SHA256, SHA, MD5
from Crypto import Random
from base64 import b64encode, b64decode
hash = "SHA-256"
Wir haben den Hash-Wert aus Sicherheitsgründen als SHA-256 initialisiert. Wir werden eine Funktion verwenden, um neue Schlüssel oder ein Paar von öffentlichen und privaten Schlüsseln unter Verwendung des folgenden Codes zu generieren.
def newkeys(keysize):
random_generator = Random.new().read
key = RSA.generate(keysize, random_generator)
private, public = key, key.publickey()
return public, private
def importKey(externKey):
return RSA.importKey(externKey)
Für die Verschlüsselung wird die folgende Funktion verwendet, die dem RSA-Algorithmus folgt:
def encrypt(message, pub_key):
cipher = PKCS1_OAEP.new(pub_key)
return cipher.encrypt(message)
Zwei Parameter sind obligatorisch: message und pub_keyDies bezieht sich auf den öffentlichen Schlüssel. Ein öffentlicher Schlüssel wird zur Verschlüsselung und ein privater Schlüssel zur Entschlüsselung verwendet.
Das vollständige Programm für die Verschlüsselung ist unten aufgeführt -
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA512, SHA384, SHA256, SHA, MD5
from Crypto import Random
from base64 import b64encode, b64decode
hash = "SHA-256"
def newkeys(keysize):
random_generator = Random.new().read
key = RSA.generate(keysize, random_generator)
private, public = key, key.publickey()
return public, private
def importKey(externKey):
return RSA.importKey(externKey)
def getpublickey(priv_key):
return priv_key.publickey()
def encrypt(message, pub_key):
cipher = PKCS1_OAEP.new(pub_key)
return cipher.encrypt(message)
Dieses Kapitel ist eine Fortsetzung des vorherigen Kapitels, in dem wir die schrittweise Implementierung der Verschlüsselung mithilfe des RSA-Algorithmus verfolgt und ausführlich besprochen haben.
Die Funktion zum Entschlüsseln von Chiffretext lautet wie folgt:
def decrypt(ciphertext, priv_key):
cipher = PKCS1_OAEP.new(priv_key)
return cipher.decrypt(ciphertext)
Für die Kryptographie mit öffentlichem Schlüssel oder die Kryptographie mit asymmetrischem Schlüssel ist es wichtig, zwei wichtige Merkmale beizubehalten, nämlich Authentication und Authorization.
Genehmigung
Mit der Autorisierung wird bestätigt, dass nur der Absender die Nachricht gesendet hat. Der folgende Code erklärt dies -
def sign(message, priv_key, hashAlg="SHA-256"):
global hash
hash = hashAlg
signer = PKCS1_v1_5.new(priv_key)
if (hash == "SHA-512"):
digest = SHA512.new()
elif (hash == "SHA-384"):
digest = SHA384.new()
elif (hash == "SHA-256"):
digest = SHA256.new()
elif (hash == "SHA-1"):
digest = SHA.new()
else:
digest = MD5.new()
digest.update(message)
return signer.sign(digest)
Authentifizierung
Die Authentifizierung ist durch eine Überprüfungsmethode möglich, die wie folgt erläutert wird:
def verify(message, signature, pub_key):
signer = PKCS1_v1_5.new(pub_key)
if (hash == "SHA-512"):
digest = SHA512.new()
elif (hash == "SHA-384"):
digest = SHA384.new()
elif (hash == "SHA-256"):
digest = SHA256.new()
elif (hash == "SHA-1"):
digest = SHA.new()
else:
digest = MD5.new()
digest.update(message)
return signer.verify(digest, signature)
Die digitale Signatur wird zusammen mit den Angaben von Absender und Empfänger überprüft. Dies erhöht das Sicherheitsalter aus Sicherheitsgründen.
RSA-Verschlüsselung
Sie können den folgenden Code für die Entschlüsselung der RSA-Verschlüsselung verwenden:
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA512, SHA384, SHA256, SHA, MD5
from Crypto import Random
from base64 import b64encode, b64decode
hash = "SHA-256"
def newkeys(keysize):
random_generator = Random.new().read
key = RSA.generate(keysize, random_generator)
private, public = key, key.publickey()
return public, private
def importKey(externKey):
return RSA.importKey(externKey)
def getpublickey(priv_key):
return priv_key.publickey()
def encrypt(message, pub_key):
cipher = PKCS1_OAEP.new(pub_key)
return cipher.encrypt(message)
def decrypt(ciphertext, priv_key):
cipher = PKCS1_OAEP.new(priv_key)
return cipher.decrypt(ciphertext)
def sign(message, priv_key, hashAlg = "SHA-256"):
global hash
hash = hashAlg
signer = PKCS1_v1_5.new(priv_key)
if (hash == "SHA-512"):
digest = SHA512.new()
elif (hash == "SHA-384"):
digest = SHA384.new()
elif (hash == "SHA-256"):
digest = SHA256.new()
elif (hash == "SHA-1"):
digest = SHA.new()
else:
digest = MD5.new()
digest.update(message)
return signer.sign(digest)
def verify(message, signature, pub_key):
signer = PKCS1_v1_5.new(pub_key)
if (hash == "SHA-512"):
digest = SHA512.new()
elif (hash == "SHA-384"):
digest = SHA384.new()
elif (hash == "SHA-256"):
digest = SHA256.new()
elif (hash == "SHA-1"):
digest = SHA.new()
else:
digest = MD5.new()
digest.update(message)
return signer.verify(digest, signature)
Das Hacken der RSA-Verschlüsselung ist mit kleinen Primzahlen möglich, wird jedoch als unmöglich angesehen, wenn sie mit großen Zahlen verwendet wird. Die Gründe, die angeben, warum es schwierig ist, die RSA-Verschlüsselung zu hacken, sind folgende:
Brute-Force-Angriffe würden nicht funktionieren, da zu viele mögliche Schlüssel zum Durcharbeiten vorhanden sind. Auch das kostet viel Zeit.
Der Wörterbuchangriff funktioniert im RSA-Algorithmus nicht, da die Schlüssel numerisch sind und keine Zeichen enthalten.
Die Frequenzanalyse der Zeichen ist sehr schwierig zu verfolgen, da ein einzelner verschlüsselter Block verschiedene Zeichen darstellt.
Es gibt keine spezifischen mathematischen Tricks, um die RSA-Verschlüsselung zu hacken.
Die RSA-Entschlüsselungsgleichung lautet -
M = C^d mod n
Mit Hilfe kleiner Primzahlen können wir versuchen, die RSA-Verschlüsselung zu hacken, und der Beispielcode dafür wird unten erwähnt -
def p_and_q(n):
data = []
for i in range(2, n):
if n % i == 0:
data.append(i)
return tuple(data)
def euler(p, q):
return (p - 1) * (q - 1)
def private_index(e, euler_v):
for i in range(2, euler_v):
if i * e % euler_v == 1:
return i
def decipher(d, n, c):
return c ** d % n
def main():
e = int(input("input e: "))
n = int(input("input n: "))
c = int(input("input c: "))
# t = 123
# private key = (103, 143)
p_and_q_v = p_and_q(n)
# print("[p_and_q]: ", p_and_q_v)
euler_v = euler(p_and_q_v[0], p_and_q_v[1])
# print("[euler]: ", euler_v)
d = private_index(e, euler_v)
plain = decipher(d, n, c)
print("plain: ", plain)
if __name__ == "__main__":
main()
Ausgabe
Der obige Code erzeugt die folgende Ausgabe -