Kryptographie - Enigma


zerix

Hausmeister
Moderator
@zerix: Bist du sicher, dass das richtig ist? Denn laut Aufgabe heisst es:


Aber durch dein rb() und rf() ist mir erst klar geworden, dass die Rotation auch in die andere Richtung gehen kann - vielleicht ist das ja in der Aufgabenstellung mit "jeweils in umgekehrter Richtung" gemeint. Dann hiesse das, dass die Walzen bei Eingabe eines einzigen Buchstabens in zwei verschiedene Richtungen drehen (können). In der Umsetzung erhöht das die Anzahl zu berücksichtigender Möglichkeiten; bisher hatten meine Walzen nur die Vorwärts-Richtung gekannt.
rb ist rückwärts rotieren. Das ist für Walze 1 und 2 gegeben, in welche Richtung Walze 3 rotiert ist gar nicht angegeben, d.h. sie könnte in die andere Richtung rotieren.
Nein, das "in umgekehrter Richtung" bedeutet was anderes.
Wenn man W verschlüsseln möchte, wird bei Walze 1 an Stelle 'W' geschaut (W1['W']). Beim Rückweg wird dann der Buchstabe der Umkehrrolle genommen, bspw. 'W' und es wird dann geschaut, wo steht das 'W' und dann wird mit den jeweiligen Index weitergemacht. Das wäre in Grundstellung das 'N'. Das heißt bei Walze 3 steht am Index 'N' das 'W'. W3['N'] = 'W'. Mit dem 'N' geht man dann zur Walze 2 und macht das dort mit den 'N'.


Viele Grüße
Sascha
 

StormChaser

Mitglied
Dann habe ich Aufgabe noch falscher verstanden. Bei mir geht ein Buchstabe durch 7 Chiffrierungen bis sein Chiffrat ausgegeben wird. Wenn schon das falsch ist, kann ich ja nie auf die Lösung kommen, ganz abgesehen von den Rotationen :)
 

zerix

Hausmeister
Moderator
Dann habe ich Aufgabe noch falscher verstanden. Bei mir geht ein Buchstabe durch 7 Chiffrierungen bis sein Chiffrat ausgegeben wird. Wenn schon das falsch ist, kann ich ja nie auf die Lösung kommen, ganz abgesehen von den Rotationen :)
Geht es ja mehr oder weniger auch.
Bsp:

Eingabe: 'W'
Walze1 ['W']: 'U'
Walze2 ['U']: 'P'
Walze3 ['P']: 'H'
Umkehr['H']: 'D'
Walze3 ['G'] : 'D'
Walze2 ['R']: 'G'
Walze1 ['I']: 'R'

Damit sollte 'W' zu 'I' verschlüsselt werden. Da Enigma mit der Verschlüsselungsmethode auch entschlüsselt, sollte 'I' zu 'W' werden.

Eingabe: 'I'
Walze1 ['I']: 'R'
Walze2 ['R']: 'G'
Walze3 ['G']: 'D'
Umkehr['D']: 'H'
Walze3 ['P'] : 'H'
Walze2 ['U']: 'P'
Walze1 ['W']: 'U'

Damit sollte das passen. Das macht auch so meine encrypt function e.

Viele Grüße
Sascha
 

zerix

Hausmeister
Moderator
Nach der Umkehrwalze schaust du halt, wie der Index zum Buchstaben ist. Also du nimmst das 'D' und läufst durch Walze3 und schaut, wo das 'D' steht. Der Schlüssel zu dem Wert ist dann der gesuchte Buchstabe. (Falls du eine Hashmap oder ein dict nutzt, abhängig von Sprache. )
 

StormChaser

Mitglied
Nach dem 'D', änderst du da schon die Rotierrichtung?

edit:
Ach, du suchst den KEY zu dem BUCHSTABEN!
Das eröffnet schon wieder völlig neue Möglichkeiten :)

edit2: Dann ist das jetzt aber das "jeweils in umgekehrter Richtung" . Macht dann auch Sinn.
 
Zuletzt bearbeitet:

zerix

Hausmeister
Moderator
Nach dem 'D', änderst du da schon die Rotierrichtung?

edit:
Ach, du suchst den KEY zu dem BUCHSTABEN!
Das eröffnet schon wieder völlig neue Möglichkeiten :)

edit2: Dann ist das jetzt aber das "jeweils in umgekehrter Richtung" . Macht dann auch Sinn.
Richtig, das heißt in umgekehrter Richtung. Da wird noch nichts rotiert.
 

StormChaser

Mitglied
Eingabe: 'W'
Walze1 ['W']: 'U'
Walze2 ['U']: 'P'
Walze3 ['P']: 'H'
Umkehr['H']: 'D'
Walze3 ['G'] : 'D'
Walze2 ['R']: 'G'
Walze1 ['I']: 'R'

Damit sollte 'W' zu 'I' verschlüsselt werden.
So, da bin ich inzwischen auch angekommen mit einem Unterschied, der darauf beruht, dass ich die erste Walze nach jeder Eingabe (vorwärts) rotieren lasse, so dass die Eingabe von 'W' zu U=>P => H =>D => G => R => 'W' wird, weil nach der Erzeugung von 'U' die 1. Walze rotiert.

Dies macht ein weiteres Definitionsproblem deutlich: Was gilt als 'Eingabe' ? Nur das, was von aussen kommt, oder auch bereits intern weitergereichte Buchstaben.
Bedeutend ist die Frage für den Hinweis im Eingangspost auf die 22. Rotation der 2. Walze: Zieht man auch die internen Weitergaben mit ein, so erfolgt die Rotation um den 11. einzugebenden Buchstaben herum, da bei jedem von aussen eingegebenen Buchstaben die Walzen 1, 2 und 3 je 2x besucht werden.
 

zerix

Hausmeister
Moderator
Eingabe ist nur die tatsächliche Eingabe und nicht die interne Verarbeitung.
Aber du kannst ja mal testen, ob für den verschlüsselten Buchstaben, der richtige Klartextbuchstabe herauskommt, wenn du diesen eingibst, bei gleicher Walzenstellung. Du solltest natürlich nicht das 'W' wählen, sondern einen beliebigen anderen.

Viele Grüße
Sascha
 

StormChaser

Mitglied
Gebe ich "WETTERBERICHT" ein, erhalte ich z. B. "IECHISQOFXXUT". Gebe ich das ein, gibt es alles Mögliche, nur keinen Wetterbericht :alien:
Ich baue dann mal um, so dass die Rotationen erst erfolgen, wenn eine Eingabe abgearbeitet ist.

edit:
so, jetzt geht es zumindest in beide Richtungen, und beide Rotierrichtungen.
Wenn die erste Walze nach jeder Eingabe rotiert,
und die 2. Walze nach mehr als 13 Eingaben,
und die 3. Walze nach mehr als 13 Eingaben,
und die 4. Walze nicht rotiert,
und ich gebe WETTERBERICHT ein,
dann erhalte ich
a) IFZHWEYKTJEXE
b) IGENLPAOOYABA
Beide lassen sich bei der entsprechenden Rotierrichtung wieder zu WETTERBERICHT dechiffrieren.

Kann das jemand bestätigen ?
 
Zuletzt bearbeitet:

zerix

Hausmeister
Moderator
Hi,

ich erhalte die gleiche Ausgabe.
Allerdings weiß ich nicht, warum du vorwärts rotieren lässt. Die Rotationsrichtung für Walze1 und Walze2 sind gegeben.

Viele Grüße
 

StormChaser

Mitglied
Hi,

ich erhalte die gleiche Ausgabe.
Allerdings weiß ich nicht, warum du vorwärts rotieren lässt. Die Rotationsrichtung für Walze1 und Walze2 sind gegeben.
Danke für die Bestätigung.

Zum Einen als Test, ob es auch in die andere Richtung funktioniert.
Zum Anderen weil für mich nicht klar ist, ob mein "vorwärts" bzw. "rückwärts" auch das gemeinte "vorwärts" bzw. "rückwärts" ist.
Allerdings ist aus der Aufgabe schon die Rotationsrichtung anzunehmen, insofern mache ich mir hier vielleicht mehr Mühe als nötig.
 

Technipion

Erfahrenes Mitglied
Wo wir schon munter am Raten sind, würde ich einfach mal noch meinen Code in den Pott werfen:
Python:
# tutorials.de: Kryptographie - Enigma

import itertools
import copy
import multiprocessing


def main():
    cyphertext = 'BGLRAOGHKRWRGSKCNSJAXXUUEXNSRXQUDXOSZHNIWLUVKXIPJSNJTM'

    R1 = ['B','D','F','H','J','L','C','P','R','T','X','V','Z','N','Y','E','I','W','G','A','K','M','U','S','Q','O']
    R2 = ['A','J','D','K','S','I','R','U','X','B','L','H','W','T','M','C','Q','G','Z','N','P','Y','F','V','O','E']
    R3 = ['E','K','M','F','L','G','D','Q','V','Z','N','T','O','W','Y','H','X','U','S','P','A','I','B','R','C','J']
    RR = ['Y','R','U','H','Q','S','L','D','P','X','N','G','O','K','M','I','E','B','F','Z','C','W','V','J','A','T']

    rolls = (EnigmaRoll(R1), EnigmaRoll(R2), EnigmaRoll(R3), EnigmaRoll(RR))

    run_test(rolls)

    target = 'WET'
    message = cyphertext[:len(target)]

    candidates = []
    test_sets = [(rot1,
                  copy.deepcopy(rolls),
                  message, target) for rot1 in range(26)]

    with multiprocessing.Pool() as p:
        candidates = p.map(filter_candidates, test_sets)

    candidates = list( filter(lambda x: not x is None, candidates) )
    candidates  = list( itertools.chain(*candidates) ) # flatten
    print(len(candidates), 'candidates found.')

    for c in candidates:
        rot1, rot2, rot3, dirleft = c
        for R in rolls: R.reset()
        rolls[0].rotate(rot1, dirleft)
        rolls[1].rotate(rot2, dirleft)
        rolls[2].rotate(rot3, dirleft)

        print(rot1, rot2, rot3, dirleft, encrypted(cyphertext, rolls, dirleft))

    return 0


def filter_candidates(args):
    rot1, rolls, msg, target = args

    results = []

    for rot2 in range(26):
        for rot3 in range(26):
            for dirleft in (True, False):
                for R in rolls: R.reset()
                rolls[0].rotate(rot1, dirleft)
                rolls[1].rotate(rot2, dirleft)
                rolls[2].rotate(rot3, dirleft)

                if encrypted(msg, rolls, dirleft) == target:
                    results.append( (rot1, rot2, rot3, dirleft) )

    if len(results) == 0:
        return None
    else:
        return results


def run_test(rolls):
    test_msgs = itertools.combinations('ABCDEFGHIJKLMNOPQRSTUVWXYZ', 3)

    for rot1 in range(26):
        for rot2 in range(26):
            for rot3 in range(26):
                for dirleft in (True, False):
                    for msg in test_msgs:
                        msg = ''.join(msg)

                        for R in rolls: R.reset()
                        rolls[0].rotate(rot1, dirleft)
                        rolls[1].rotate(rot2, dirleft)
                        rolls[2].rotate(rot3, dirleft)

                        msg_enc = encrypted(msg, rolls, dirleft)

                        for R in rolls: R.reset()
                        rolls[0].rotate(rot1, dirleft)
                        rolls[1].rotate(rot2, dirleft)
                        rolls[2].rotate(rot3, dirleft)

                        msg_dec = encrypted(msg_enc, rolls, dirleft)

                        if msg_dec != msg:
                            print('ERROR:', msg, '->', msg_enc, '->', msg_dec)
                            raise RuntimeError('run_test failed')

    for R in rolls: R.reset()
    print('run_test was successful')


def encrypted(msg, rolls, dirleft=False):
    R1, R2, R3, RR = rolls

    result = ''

    for i, m in enumerate(msg):
        ch = ord(m) - ord('A')

        ch = R1.transform_forward(ch)
        ch = R2.transform_forward(ch)
        ch = R3.transform_forward(ch)

        ch = RR.transform_forward(ch)

        ch = R3.transform_backward(ch)
        ch = R2.transform_backward(ch)
        ch = R1.transform_backward(ch)

        result += chr(ch + ord('A'))

        R1.rotate(1, dirleft)

    return result


class EnigmaRoll:
    def __init__(self, ground_state):
        channels = []
        for i, c in enumerate(ground_state):
            channels.append( (i, ord(c) - ord('A')) )

        self.channels = channels
        self.rotation = 0


    def transform_forward(self, ch):
        local_ch = ch + self.rotation
        local_ch %= len(self.channels)

        for source, dest in self.channels:
            if source == local_ch:
                local_result = dest
                break

        result = local_result - self.rotation
        if result > len(self.channels):
            result %= len(self.channels)
        while result < 0:
            result += len(self.channels)

        return result


    def transform_backward(self, ch):
        for i in range(len(self.channels)):
            if self.transform_forward(i) == ch:
                return i


    def rotate_left(self, steps=1):
        self.rotation += steps
        self.rotation %= len(self.channels)


    def rotate_right(self, steps=1):
        self.rotation -= steps
        while self.rotation < 0:
            self.rotation += len(self.channels)


    def rotate(self, steps=1, dirleft=False):
        if dirleft:
            self.rotate_left(steps)
        else:
            self.rotate_right(steps)


    def reset(self):
        self.rotation = 0


if __name__ == '__main__':
    main()

Aber wie gesagt, ich kriege auch nichts Vernünftiges heraus :cautious:
 

zerix

Hausmeister
Moderator
Hier mal meine aktuelle Version. Sie vereinfacht das bruteforcen etwas

Python:
import sys

ALPHABET = [chr(x) for x in range(0x41,0x41+26)]
X1= ('B','D','F','H','J','L','C','P','R','T','X','V','Z','N','Y','E','I','W','G','A','K','M','U','S','Q','O')
X2= ('A','J','D','K','S','I','R','U','X','B','L','H','W','T','M','C','Q','G','Z','N','P','Y','F','V','O','E')
X3= ('E','K','M','F','L','G','D','Q','V','Z','N','T','O','W','Y','H','X','U','S','P','A','I','B','R','C','J')
XU= ('Y','R','U','H','Q','S','L','D','P','X','N','G','O','K','M','I','E','B','F','Z','C','W','V','J','A','T')
E = 'BGLRAOGHKRWRGSKCNSJAXXUUEXNSRXQUDXOSZHNIWLUVKXIPJSNJTM'
to_dict = lambda x: {chr(k+0x41):v for k,v in enumerate(x)}
# key for value
kfv = lambda d,x : [y for y,z in d.items() if z==x][0]
# encryptbreak
e = lambda x, w1, w2, w3: kfv(w1,kfv(w2, kfv(w3,U[w3[w2[w1[x]]]])))
# predecessor
p = lambda x : ALPHABET[((ord(x)-0x41-1)+26)%26]
# successor
s = lambda x : ALPHABET[((ord(x)-0x41+1)+26)%26]
# rotate back
rb = lambda x : { p(k): p(v) for k,v in x.items() }
# rotate forward
rf = lambda x : { s(k): s(v) for k,v in x.items() }

ow1 = to_dict(X1)
ow2 = to_dict(X2)
ow3 = to_dict(X3)
ou = to_dict(XU)

W1 = to_dict(X1)
W2 = to_dict(X2)
W3 = to_dict(X3)
U = to_dict(XU)

def encrypt(text, a=1, b=21, c=21*26, fw=False):
    to_return = ''
    counter_0 = 0
    w1 = to_dict(X1)
    w2 = to_dict(X2)
    w3 = to_dict(X3)
    for i in text:
        to_return += e(i,w1,w2,w3)
        counter_0 += 1
        if counter_0 % a == 0:
            w1 = rb(w1)

        if (counter_0) % b == 0:
            w2 = rb(w2)

        if counter_0 % c == 0:
            w3 = rb(w3)
    return to_return

def check(w1, w2, w3):
    return e(E[0], w1, w2, w3)+e(E[1], w1, w2, w3)+e(E[2], w1, w2, w3)+e(E[3], w1, w2, w3)+e(E[4], w1, w2, w3)+e(E[5], w1, w2, w3) == 'WETTER'

def bruteforce(a, b, c, forward=False):
    """
    Rotiert W1(w1) nach jeder a. Eingabe
    Rotiert W2(w2) nach jeder b. Eingabe
    Rotiert W3(w3) nach jeder c. Eingabe

    und
    Rotiert W1(v1) nach jeder c. Eingabe
    Rotiert W2(v2) nach jeder b. Eingabe
    Rotiert W3(v3) nach jeder a. Eingabe

    Beendet sich wenn alle Walzen mindestens einmal bewegt wurden und wieder in Grundstellung stehen.
    """
    w1 = to_dict(X1)
    w2 = to_dict(X2)
    w3 = to_dict(X3)
    v1 = to_dict(X1)
    v2 = to_dict(X2)
    v3 = to_dict(X3)      
    counter_0 = 0
    w1_rotated = False
    w2_rotated = False
    w3_rotated = False
    while True:
        if check(w1, w2, w3) or check(v1,v2,v3):
            for l in E:
                D += e(l, w1, w2, w3)
            print(D)
            sys.exit()
        counter_0 += 1
        if counter_0 % a == 0:
            w1 = rb(w1)
            w1_rotated = True
            if forward:
                v3 = rf(v3)
            else:
                v3 = rb(v3)

        if (counter_0) % b == 0:
            w2 = rb(w2)
            w2_rotated = True
            v2 = rb(v2)

        if counter_0 % c == 0:
            if forward:
                w3 = rf(w3)
            else:
                w3 = rb(w3)
            w3_rotated = True
            v1 = rb(v1)


        if w1_rotated and w2_rotated and w3_rotated and w1 == ow1 and w2 == ow2 and w3 == ow3:
            print(counter_0)
            break


def bruteforce_4():
    """
    Rotiert w1 nach jeder i. Eingabe
    Rotiert v1 nach jeder j. Eingabe

    Rotiert w2 nach jeder 21. Eingabe
    Rotiert v2 nach jeder 21. Eingabe

    Rotiert w3 nach jeder j. Eingabe
    Rotiert v3 nach jeder i. Eingabe
    """
    for i in range(1,27):
        for j in range(1,27):
            print(i, j)
            bruteforce(i, 21, j)
            bruteforce(i, 21, j, True)

def bruteforce_5():
    """
    Rotiert w1 nach jeder i. Eingabe
    Rotiert v1 nach jeder j. Rotation von v2

    Rotiert w2 nach jeder 21. Eingabe
    Rotiert v2 nach jeder 21. Eingabe

    Rotiert w3 nach jeder j. Rotation von w2
    Rotiert v3 nach jeder i. Eingabe
    """
    for i in range(1,27):
        for j in range(1,27):
            print(i, j)
            bruteforce(i, 21, 21*j)
            bruteforce(i, 21, 21*j, True)

def start():
    g = globals()
    for k,v in g.items():
        if k.startswith('bruteforce_'):
            print(k)
            v()

print(encrypt('WETTERBERICHT'))
start()
 
Zuletzt bearbeitet:

ikosaeder

Teekannen-Agnostiker
Ich habe mich auch mal daran versucht.
Auf Basis von dem was die echte Enigma macht, bin ich von folgendem Ausgegangen.
Für die Nullstellung gilt:
Walze 1 rotiert bei jeder Eingabe
Walze 2 rotiert bei jeder 26 Eingabe (Walze 1 hat eine vollständige Umdrehung gemacht)
Walze 3 rotier bei jeder 26*26 Eingabe (Walze 2 hat eine vollständige Umdrehung gemacht)
Alle 3 Walzen können mit einem Offset versehen werden. D.h. die Walze wird bereit rotiert eingebaut.
Für den vorliegenden Fall scheint der Offset von Walze1 4 zu sein -> wenn sie noch 22 mal rotiert, dann rotiert Walze 2.
Entsprechendes habe ich in meiner Enigma gecodet. Die kann zwar Klartext vor und zurück übersetzen (mit verschiedenen Ausgangstellungen und verschiedenen Rotationsrichtungen.
Für den Teststring gibt es aber trotzdem kein Ergebnis.
Entweder stimmt die Annahme nicht oder die Offset sind noch nicht richtig.
Python:
import sys
def rotate(walzeIn,r=False):
    if(r):
        walzeIn.insert(25, walzeIn.pop(0))
    else:
        walzeIn.insert(0,walzeIn.pop())
    return walzeIn


def encrypt(plainText,X1E,X2E,X3E,XUE,offset1,offset2,offset3,r=False):
    count1=offset1
    count2=offset2
    count3=offset3
    for i in range(count1):
        if count1==0:
            break
        rotate(X1E,r)
    for i in range(count2):
        if count2==0:
            break
        rotate(X2E,r)
    for i in range(count3):
        if count3==0:
            break
        rotate(X3E, r)
    encryptedText=""
    for i in plainText:
        letter=i
        chiffre = ALPHABET.index(letter)
        letter = X1E[chiffre]
        chiffre = ALPHABET.index(letter)
        letter = X2E[chiffre]
        chiffre = ALPHABET.index(letter)
        letter = X3E[chiffre]
        chiffre = ALPHABET.index(letter)
        letter = XUE[chiffre]
        chiffre = ALPHABET.index(letter)
        letter = X3E[chiffre]
        chiffre = ALPHABET.index(letter)
        letter = X2E[chiffre]
        chiffre = ALPHABET.index(letter)
        letter = X1E[chiffre]
        rotate(X1E,r)
        count1 += 1
        if(count1==25):
             rotate(X2E,r)
             count2 += 1
             count1=0
        if(count2==25):
             rotate(X3E,r)
             count3 += 1
             count2 = 0
        if(count3==25):
             count3=0
        encryptedText+=letter
    return encryptedText

def decrypt(encryptedText,X1D,X2D,X3D,XUD,offset1,offset2,offset3,r=False):
    count1=offset1
    count2=offset2
    count3=offset3
    for i in range(count1):
        if count1==0:
            break
        rotate(X1D,r)
    for i in range(count2):
        if count2==0:
            break
        rotate(X2D,r)
    for i in range(count3):
        if count3==0:
            break
        rotate(X3D, r)
    plainText=""
    for i in encryptedText:
        letter=i
        chiffre = X1D.index(letter)
        letter = ALPHABET[chiffre]
        chiffre = X2D.index(letter)
        letter = ALPHABET[chiffre]
        chiffre = X3D.index(letter)
        letter = ALPHABET[chiffre]
        chiffre = XUD.index(letter)
        letter = ALPHABET[chiffre]
        chiffre = X3D.index(letter)
        letter = ALPHABET[chiffre]
        chiffre = X2D.index(letter)
        letter = ALPHABET[chiffre]
        chiffre = X1D.index(letter)
        letter = ALPHABET[chiffre]
        rotate(X1D,r)
        count1 += 1
        if (count1 == 25):
            rotate(X2D,r)
            count2 += 1
            count1 = 0
        if (count2 == 25):
            rotate(X3D,r)
            count3 += 1
            count2 = 0
        if (count3 == 25):
            count3 = 0
        plainText+=letter
    return plainText

if __name__ == '__main__':

    ALPHABET = [chr(x) for x in range(0x41, 0x41 + 26)]
    ####['0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5']
    X1 = ['B', 'D', 'F', 'H', 'J', 'L', 'C', 'P', 'R', 'T', 'X', 'V', 'Z', 'N', 'Y', 'E', 'I', 'W', 'G', 'A', 'K', 'M',
          'U', 'S', 'Q', 'O']
    ####['0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5']
    X2 = ['A', 'J', 'D', 'K', 'S', 'I', 'R', 'U', 'X', 'B', 'L', 'H', 'W', 'T', 'M', 'C', 'Q', 'G', 'Z', 'N', 'P', 'Y',
          'F', 'V', 'O', 'E']
    ####['0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5']
    X3 = ['E', 'K', 'M', 'F', 'L', 'G', 'D', 'Q', 'V', 'Z', 'N', 'T', 'O', 'W', 'Y', 'H', 'X', 'U', 'S', 'P', 'A', 'I',
          'B', 'R', 'C', 'J']
    ####['0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5','6','7','8','9','0','1','2','3','4','5']
    XU = (
    'Y', 'R', 'U', 'H', 'Q', 'S', 'L', 'D', 'P', 'X', 'N', 'G', 'O', 'K', 'M', 'I', 'E', 'B', 'F', 'Z', 'C', 'W', 'V',
    'J', 'A', 'T')
    # E = 'BGLRAOGHKRWRGSKCNSJAXXUUEXNSRXQUDXOSZHNIWLUVKXIPJSNJTM'
    kryptText = "BGLRAOGHKRWRGSKCNSJAXXUUEXNSRXQUDXOSZHNIWLUVKXIPJSNJTM"
    #kryptText = "RFVRQLTOEHZSFASDFASDFASDFSADFSADFSADFSDFSADFSADF"
    klarText = "WETTERBERICHT"
    # klarText="RFVRQLTOEHZSF"
    count1=0
    count2=0
    count3=0

    X1E=list(X1)
    X2E=list(X2)
    X3E=list(X3)
    XUE=list(XU)
    dekrypto=""
    krypto=""

    #kryptText=encrypt(klarText,X1E,X2E,X3E,XUE,count1,count2,count3,True)
    print kryptText
    #dekrypto=decrypt(kryptText,X1D,X2D,X3D,XUD,count1,count2,count3,False)
    #print dekrypto
    #print "orig", X1D
    #for i in range(26):
        #rotate(X1D,True)
        #print i,X1D

    for a in range(27):
        for j in range(27):
            for k in range(27):
                X1D = list(X1)
                X2D = list(X2)
                X3D = list(X3)
                XUD = list(XU)
                dekrypto = decrypt(kryptText,X1D,X2D,X3D,XUD,k,j,a,True)
                print k,j,a
                print dekrypto
                if ("WETTER" in dekrypto):
                    print dekrypto
                    print ('Walze 1: ' + str(k) + " Walze 2: " + str(j) + " Walze 3: " + str(a))
                    sys.exit(0)
 

StormChaser

Mitglied
Alle 3 Walzen können mit einem Offset versehen werden. D.h. die Walze wird bereit rotiert eingebaut.
Die 4. Walze ebenfalls. Sie rotiert zwar nicht, könnte aber trotzdem "verdreht" eingebaut sein.


Was mich in der Aufgabenstellung ausserdem stutzig gemacht hatte war in diesem Satz
Sie dürfen außerdem als bekannt voraussetzen, dass Walze ¨ 2 in der unten angegebenen Grundstellung zum ersten Mal unmittelbar vor der zweiundzwanzigsten Eingabe rotiert.
die hervorgehobene Formulierung.
Wenn dieses "vor" nun für alle Walzen gilt, und die 1. Walze unmittelbar vor der ersten Eingabe rotiert, dürften ganz andere Ergebnisse herauskommen.

Das erste 'B' im Chiffrat kann nur erzeugt werden, wenn die Rotation der ersten Walze einen bestimmten Wert hat, da bei Rotation 0 (Grundeinstellung) das 'B' nicht aus der Eingabe 'W' zu erzeugen ist. Die Walze muss also bereits so versetzt eingebaut sein.
Dann schliesst sich die Frage an, ob die Schritte für die weiteren Rotationen ab 0 oder ab dem Versatz gezaehlt werden.
Und falls unmittelbar vor der Eingabe rotiert wird, wäre der Versatz 1 weniger.
 

ikosaeder

Teekannen-Agnostiker
Also ich habe jetzt auch die 4 Walze rotiert (in der Ausgangsstellung) und trotzdem keinen Erfolg gehabt. Meine Enigma verschlüsselt und entschlüsselt und gibt die korrekte Ausgangsstellung der Walzen wieder.
Ich denke für die Lösung fehlt eine Information oder ein anderes Detail.
@javama Hast du noch mehr Infos? Woher kommt die Aufgabe?
 

StormChaser

Mitglied
Da ich schon so einiges erfolglos probiert hatte und bei neuen Versuchen inzwischen schon nicht mehr genau weiss, was ich hatte und was nicht, habe ich mal eine Aufstellung gemacht von dem, was ich für denkbar halte. Diese Aufstellung lässt sich dann übersichtlicher abarbeiten.

Ohne Einschraenkungen betraegt die Anzahl moeglicher Setups vor dem De-/Chiffrieren:
26 ^ 7 = 8.031.810.176
Durch die Einschraenkungen I. b) und I. c) reduziert sich das auf:
26 ^ 5 = 11.881.376‬ ( = 0,1479 % )

I. Vorbedingungen
a) Grundstellung (Versatz = 0 bzw keine Rotation) aller Walzen siehe Post
b) Walze 1 rotiert nach (oder vor) jeder Eingabe
c) Walze 2 rotiert unmittelbar vor 22. Eingabe
d) Walze 4 rotiert nicht
e) Chiffrat + Teil-Dechiffrat siehe Post

II. Moeglichkeiten (fuer Setups und Verarbeitung)
A.
[0] Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze
[1] Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben

B.
[0] bei versetzten Walzen beginnt Eingabezaehler bei 0
[1] bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze

C.
[0] Rotierrichtung aller Walzen vorwaerts
[1] Rotierrichtung aller Walzen rueckwaerts

D.
[0] Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
[1] Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens

E.
[0] Eingabezaehlererhoehung nur vor dem Passieren der Walze 4
[1] Eingabezaehlererhoehung auch nach dem Passieren der Walze 4


Aus A - E sich ergebende Kombinationsmoeglichkeiten:

1:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

2:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

3:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

4:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

5:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

6:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

7:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

8:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

9:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

10:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

11:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

12:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

13:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

14:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

15:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

16:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Rotationen der Vorgaenger-Walze ("Kilometerzaehler")
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

17:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

18:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

19:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

20:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

21:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

22:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

23:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

24:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei 0
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

25:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

26:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

27:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

28:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen vorwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

29:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

30:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren NACH Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4

31:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung nur vor dem Passieren der Walze 4

32:
- Rotationen erfolgen in Abhaengigkeit der Anzahl der Eingaben
- bei versetzten Walzen beginnt Eingabezaehler bei Versatz Modulo Rotierlimit der Walze
- Rotierrichtung aller Walzen rueckwaerts
- Eingabezaehler erhoehen und ggfs. Walze rotieren VOR Verarbeitung des von aussen kommenden Zeichens
- Eingabezaehlererhoehung auch nach dem Passieren der Walze 4
 

Neue Beiträge