[REQ] Enigma

[reaper7]

Found this script may be useful.
http://www.math.utoledo.edu/~codenth...a/enigma.01.py

PHP Code:

""" enigma.py
"""

import operator
from string import ascii_uppercase as UPPER
from copy import deepcopy
from permutations import Permutation,cycleform,permform

def char2int(key):
    try:
        c = key.upper()
        return UPPER.index(c)
    except:
        return key

class Rotor(Permutation):

    def __init__(self,perm,ringsetting='A',key='A',notches=()):

        Permutation.__init__(self,perm)
        self.notches = notches
        self.setRing(ringsetting)
        self.setKey(key)

    def setRing(self,A):
        r = char2int(A)
        cycles = [[(x+r) % 26 for x in cycle] for cycle in self.C]
        perm = permform(cycles)
        self.P = perm
        self.C = cycleform(perm)

    def setKey(self,A):
        k = char2int(A)
        cycles = [[(x-k) % 26 for x in cycle] for cycle in self.C]
        perm = permform(cycles)
        self.P = perm
        self.C = cycleform(perm)
        self.key = UPPER[k]

    def step(self):
        cycles = [[(x-1) % 26 for x in cycle] for cycle in self.C]
        perm = permform(cycles)
        self.P = perm
        self.C = cycleform(perm)

        k = char2int(self.key)
        k = (k+1) % 26
        self.key = UPPER[k]

    def trigger(self):
        return self.key in self.notches

def rotor(strng):
    return Permutation(tuple(strng.lower()))

# The rotors
I     = Rotor("EKMFLGDQVZNTOWYHXUSPAIBRCJ",notches=("Q"))
II    = Rotor("AJDKSIRUXBLHWTMCQGZNPYFVOE",notches=("E"))
III   = Rotor("BDFHJLCPRTXVZNYEIWGAKMUSQO",notches=("V"))
IV    = Rotor("ESOVPZJAYQUIRHXLNFTGKDCMWB",notches=("J"))
V     = Rotor("VZBRGITYUPSDNHLXAWMJQO****",notches=("Z"))
VI    = Rotor("JPGVOUMFYQBENHZRDKASXLICTW",notches=("Z","M"))
VII   = Rotor("NZJHGRCXMYSWBOUFAIVLPEKQDT",notches=("Z","M"))
VIII  = Rotor("FKQHTLXOCBJSPDZRAMEWNIUYGV",notches=("Z","M"))

# Used only in Model M-4 with thinB and thinC reflectors
beta  = Rotor("LEYJVCNIXWPBQMDRTAKZGFUHOS")
gamma = Rotor("FSOKANUERHMBTIYCWLQPZXVGJD")

# The reflectors
B     = Rotor("YRUHQSLDPXNGOKMIEBFZCWVJAT")
C     = Rotor("FVPJIAOYEDRZXWGCTKUQSBNMHL")
# The reflectors used in Model M-4 with beta and gamma rotors.
thinB = Rotor("ENKQAUYWJICOPBLMDXZVFTHRGS")
thinC = Rotor("RDOBJNTKVEHMLFCWZAXGYIPSUQ")

# The cyclic permutation and its inverse
rho   = Permutation("BCDEFGHIJKLMNOPQRSTUVWXYZA")

identity =  Permutation("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

# The 'QWERTZU' in military and civilian types. We
# have the 'QWERTZU' act on the left so we use the
# inverse of the input permutation.
military = Permutation("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
civilian = Permutation("QWERTZUIOASDFGHJKPYXCVBNML")

# This class still needs to be checked to see if it
# performs correctly.
class Enigma(object):

    def __init__(self,
            rotorList = (I,II,III),
            reflector = B,
            ringSettings = (),
            stecker = identity,
            qwertzu = military):
        """ The rotor (wheel) list should be given from slowest to fastest:
            U, W_L, W_M, W_R. The ring settings default to 'AA...', the
            stecker and 'qwertzu' both default to the identity. The key
            settings are made after the machine is initialized.
        """
        self.qwertzu = qwertzu
        self.rotors = [deepcopy(R) for R in rotorList]
        self.rotors.insert(0,deepcopy(reflector))
        self.nR = len(self.rotors)

        self.__setRings(ringSettings)
        self.setStecker(stecker)

    def __repr__(self):
        return repr(self.permutation)

    def __str__(self):
        return str(self.permutation)

    def __call__(self,text):
        return "".join(map(self.encipher,text))

    def setStecker(self,stecker):
        try:
            self.SQ = stecker * self.qwertzu
        except:
            self.SQ = Permutation(stecker) * self.qwertzu

        self.setPermutation()

    def __setRings(self,ringSettings):
        # Convert ring setting letters to numbers.
        ringSettings = map(char2int,ringSettings)

        # All ring settings default to 'A'.
        nS = len(ringSettings)
        ringSettings = (0,)*(self.nR - nS) + tuple(ringSettings)
        for k,R in enumerate(self.rotors):
            R.setRing(ringSettings[k])

    def setKeys(self,keySettings):
        # Convert key setting letters to numbers.
        keySettings = map(char2int,keySettings)

        # All key settings default to 'A'.
        nK = len(keySettings)
        keySettings = (0,)*(self.nR - nK) + tuple(keySettings)
        for k,R in enumerate(self.rotors):
            R.setKey(keySettings[k])

        self.setPermutation()

    def setPermutation(self):
        self.permutation = (self.SQ >> reduce(operator.lshift,self.rotors))

    def step(self):
        if self.rotors[-2].trigger():
            motion = (1,1,1)
        elif self.rotors[-1].trigger():
            motion = (0,1,1)
        else:
            motion = (0,0,1)

        for i in range(3):
            if motion[i]:
                self.rotors[i-3].step()

        self.setPermutation()

    def encipher(self,c):
        self.step()
        return self.permutation.encipher(c) 


[MiTon]

Originally Posted by reaper7

Found this script may be useful.
http://www.math.utoledo.edu/~codentha/Cryptanalysis/python/enigma/enigma.01.py

...

Thx!

Will look at it!


EDIT:

great link!! thx

[StarTrekMike]

The use of a enigma machine to decode messages sounds pretty amazing to me.

it would also give us something to do in transit.


Mike

[TheDarkWraith]

My radio messages feature is already setup to have enigma messages

[stoianm]

Originally Posted by TheDarkWraith

My radio messages feature is already setup to have enigma messages

Can you make that the messages from BDU like ''convoy spoted'' that are displayed in messages box to be coded in the code that Miton will use if he will succed to put this machine in game?

[Stormfly]

we also need a codebook then, ithink it included the current used key for each day...? so you only need to code a "encoder enigma", which generate the encrypted message using the present key for each day...

using a enigma feature for that special "commanders or (captains) messages" would be realistic, as the commander had to decode the message finaly by himself...

[Magic1111]

Originally Posted by Stormfly

using a enigma feature for that special "commanders or (captains) messages" would be realistic, as the commander had to decode the message finaly by himself...

"Nun mal los, 2WO! Offiziersfunkspruch. Wieder irgendso eine Sonderveranstaltung. Aber nicht mit uns! Unser Schlitten ist werftreif. Na, wird's bald?" - "Kommandantenspruch. Dreifach verschlüsselt. War ja noch nie da." -DAS BOOT-

"Let's go, 2WO! officer radio-message. A special event. But not with us! Our sled is ready to throw. Well,'s soon?" - ". commander saying triple encrypted never was there.."

[MiTon]

Originally Posted by Stormfly

we also need a codebook then, ithink it included the current used key for each day...? so you only need to code a "encoder enigma", which generate the encrypted message using the present key for each day...

And what would you do with the encoded message? Decode? So if you don't wanna use an external app everytime you get a message, you'll need a decoder. If you put in the text manually or let it decode by a buttonpress doesn't matter to much.

using a enigma feature for that special "commanders or (captains) messages" would be realistic, as the commander had to decode the message finaly by himself...

As from my understanding the captains messages were coded with two different codes. First one part to tell that this is a captains message, and the message itself.
As I could read on this german u-boat site, there were at least three different codebooks.

• Kenngruppenheft - "the normal codebook" with the codes one month (most times). Codes were efective for 24h, changed to 8h later (from here).
• Kurzsignalheft - short message book, was used to shorten radiomessages and the transmissiontime to avoiding detection by the Huff-Duff Method
• Wetterkurzschlüssel - special codebook to shorten weatherreports (used when u-boat sends a weather report)

All were written with non waterproof ink, to be easy to destroy in case of emergency (capture or something like this)!
Also pretty bad when you have massive flooding


So if build from scratch we should see in which way we can categorize the messages. Rest should be peanuts (hopefully )
Codebooks would be a very cool feature, but not nessecarily required, as it should be possible to hide required codes "inside" the message. Right code could be dialed automaticly.
But I'd prefer codebooks!


From the first quick looks at the code of the python-enigma I posted above is only simply a encoder, but this one looks like it be easy to integrate.

Originally Posted by reaper7

Found this script may be useful.
http://www.math.utoledo.edu/~codentha/Cryptanalysis/python/enigma/enigma.01.py

Very good one indeed! Thx again reaper7!

Looks like a complete enigma implementation, but it uses core API functions, no longer existing in python, and is way more complex.

I don't have toons of time right now, but I'll try my best and dig in there!
First lesson for today and tomorrow: "How the enigma realy works!"


If anyone finds an other free implementation (maybe C#) or other usefull infos and stuff like codebooks ...


regards

MiTon

[Sepp von Ch.]

Originally Posted by TheDarkWraith

My radio messages feature is already setup to have enigma messages

Would be PLEASE PLEASE PLEASE TDW possible to make a separate little mod with your radio messages? Please!