Vigene`re Chiffre entschlüsseln

[uek67]

Hallo, ich brauch mal eure Hilfe,

ich versuche mir eben zusamen mit ein paar Krypto begeisterten Python beizubringen. Hierzu haben wir versucht die Vigene`re Chiffre zu implementieren und eine Funktion verschluessen definiert:

Code: Alles auswählen

[b][i] def verschluessle(self, klartext_p, schluessel_p):
        liste_text_verschluesselt = []
        buchstabe_A_in_ASCII = ord("A") #65
        # Methoden aufrufen 
        klartext_bereinigt   = self.bereinige_klartext(
                               klartext_p=klartext_p )
        
        schluessel           = self.verlaengere_schluessel(
                                         schluessel_p,
                                         len(klartext_bereinigt))
        
       
        for durchlauf_zaehler, buchstabe_aktuell \
                       in enumerate(klartext_p):
            
            klartext_index  = ord(buchstabe_aktuell)  \
                              - buchstabe_A_in_ASCII
            
            
            schluessel_index = ord(schluessel[durchlauf_zaehler]) \
                               - buchstabe_A_in_ASCII
            
            buchstabe_verschluesselt = self.verschluesselungstabelle \
                                      [schluessel_index][klartext_index]
            liste_text_verschluesselt.append(buchstabe_verschluesselt)
        text_verschluesselt_string = "" .join(liste_text_verschluesselt)
        # fasst die Chiffratbuchstaben zu einer Zeichenkette zusammen   
            
            
        return text_verschluesselt_string
    
# verschluesselung beendet[/i][/b]

Das funktioniert auch soweit. Nun wollten wir eine Entschlüsselungsdfunktion programmieren und kamen schonmal bis hier hin :

Code: Alles auswählen

[b][i] def bereinige_klartext(self, klartext_p):
        klartext_grossbuchstaben      = klartext_p.upper()
        import re
        klartext_bereinigt            = re.sub(pattern ="[^A-Z]",
        string                        = klartext_grossbuchstaben,
        repl                          = "")
        print("Klartext nicht bereinigt:\n ", klartext_p)
        print("Klartext bereinigt:\n", klartext_bereinigt)
        return klartext_bereinigt
    
    def verlaengere_schluessel(self, schluessel_p, laenge_klartext_p):
        
        schluessel_laenge          = len(schluessel_p)
        schluessel_grossbuchstaben = schluessel_p.upper()
        schluessel_liste           = []
        for i in range(0, laenge_klartext_p, 1):
            schluessel_index       = i % schluessel_laenge
            schluessel_buchstabe   = schluessel_grossbuchstaben[schluessel_index]
            schluessel_liste.append(schluessel_buchstabe)
        
        verlaengerter_schluessel   = "".join(schluessel_liste)
        print("\nKernschlüssel:\n", schluessel_p)
        print("\nVerlängerter Schlüssel:\n", verlaengerter_schluessel)
        
        return verlaengerter_schluessel
            [/i][/b]

Frage: Soweit ich es verstanden habe, muss die Funktion verschluessele umgekehrt werden?
Allerdings haben wir keine Ahnung wie wir das schrieben müssen. Kann uns hier jemand helfen? ist für einen guten Zweck.

DANKE

Uli

[__blackjack__]

@uek67: Importe gehören an den Anfang des Moduls nicht in irgendwelche Methoden oder Funktionen versteckt.

Die Zeilenfortsetzungen mit \ sind an echt ungünstigen weil eher ungewöhnlichen Stellen gesetzt. Am besten kommt man ohne dieses syntaktische Mittel aus. Der Compiler ”weiss” beispielsweise das ein Ausdruck noch nicht zuende sein kann, solange es noch geöffnete Klammern gibt, die noch nicht wieder geschlossen wurden.

Das komische Ausrichten an ``=``-Zeichen macht die Situation nicht besser. Solche Mätzchen die nur unnötig Arbeit machen, Änderungen an Zeilen nach sich ziehen können die sich inhaltlich gar nicht ändern, sondern nur aus ”kosmetischen” Gründen angepasst werden müssen, und auch noch Umbrüche mit \ zur Folge haben können, sollte man lassen.

In `bereinige_klartext()` ist das extrem schlimm. Da sieht das so aus als werden nach dem Import von `re` drei lokale Namen definiert, aber das ist eigentlich nur ein Name und die beiden anderen sind Schlüsselwortargumente.

Wobei man das auch eher nicht mit Schlüsselwortargumenten aufrufen würde. Habe ich glaube ich noch nie vorher gesehen. Und natürlich selbst auch nicht gemacht.

Grunddatentypen haben nichts in Namen verloren. Den Typen ändert man gar nicht so selten mal während der Entwicklung und dann hat man entweder falsche, irreführende Namen im Quelltext oder man muss durch den ganzen Quelltext gehen und die betroffenen Namen ersetzen. Oft ist so ein Name auch unnötig einschränkend, wenn beispielsweise gar nicht wirklich eine Liste gebraucht wird, sondern es auch jedes iterierbare Objekt tun würde.

Man muss nicht jedes kleine Zwischenergebnis an einen Namen binden.

Einige von den ”Methoden” sind gar keine, sondern nur Funktionen die in eine Klasse gesteckt wurden. Klassen sind kein Selbstzweck. Man muss einen guten Grund haben da Funktionen rein zu stecken.

`verlaengere_schluessel()` ist recht umständlich. Das könnte man mit ein bisschen Rechnen und multiplizieren der Zeichenkette und gegebenenfalls „Slicing“ einfacher machen. Oder aber überhaupt nicht, sondern einfach mit `itertools.cycle()` einen Iterator erstellen der beliebig lange Werte liefert.

Wie weit ihr jetzt mit der Entschlüsselungsfunktion seid, zeigt der Beitrag gar nicht. Da stehen dann ja nur die beiden Funktionen die nicht in die Klasse gehören, die vom Verschlüsseln schon verwendet werden.

Ver- und Entschlüsseln sind bei solchen Verfahren die gleiche Funktion, nur das die Abbildung ”umgedreht” ist, die bei euch anscheinend den Zustand des Objekts ausmacht, auf dem die Verschlüsselungsmethode definiert ist.

Die `print()`-Ausgaben sollte da noch raus oder zumindest in Logging-Ausgaben umgewandelt werden die man abschalten, oder im Fall von Ausgaben zur Fehlersuche: einschalten kann.

[uek67]

Vielen herzlichen Dank für sorry nichts ich bin kein Stück schlauer

[sparrow]

@uek67: Ich überlese mal deine extreme Unhöflichkeit und frage, was du an diesem offensichtlich sehr zeitaufwändigem Post von __blackjack__ nicht verstehst. Du schreibst, ihr wollt Python lernen und bekommst eine ausführliche Kritik zu deinem Code. Wo genau steckst du fest, deinen Code entsprechend der vielen Tipps anzupassen?