def find_rotor_start(rotor_choice, ciphertext, cribtext, ring_choice): from enigma.machine import EnigmaMachine alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" machine = EnigmaMachine.from_key_sheet( rotors=rotor_choice, reflector='B', ring_settings=ring_choice, plugboard_settings='AV BS CG DL FU HZ IN KM OW RX') # Do a search over all possible rotor starting positions for rotor1 in alphabet: # Search for rotor 1 start position for rotor2 in alphabet: # Search for rotor 2 start position for rotor3 in alphabet: # Search for rotor 3 start position # Generate a possible rotor start position start_pos = rotor1 + rotor2 + rotor3 # Set the starting position machine.set_display(start_pos) # Attempt to decrypt the plaintext plaintext = machine.process_text(ciphertext) print(plaintext) # Check if decrypted version is the same as the crib text if plaintext == cribtext: print("Valid settings found!") return rotor_choice, ring_choice, start_pos # If we didn't manage to successfully decrypt the message return rotor_choice, ring_choice, "Cannot find settings"
def run_enigma_task(num): print("Started worker #{}".format(num)) while not stop_event.is_set(): while data_queue.empty(): if stop_event.is_set(): return time.sleep(0.05) d = data_queue.get() machine = EnigmaMachine.from_key_sheet(rotors=d["rotor"], reflector=d["ref"], ring_settings=d["ring"], plugboard_settings=d["plug"]) print("Created enigma from settings: ") print(d) # <-- 17576 iterations --> for r in generate_rotor_positions(): machine.set_display(r) for cipher, char in zip(CIPHERTEXT, PLAINTEXT): output = machine.process_text(cipher) if output != char: break else: d["display"] = r solution_queue.put(d) stop_event.set() return
def saveBtn(): '''Get roters, rings and plugboard settings and pass to enigma machine, print all settings''' roter1 = ro1.get() roter2 = ro2.get() roter3 = ro3.get() global roters_package roters = roter1 + ' ' + roter2 + ' ' + roter3 ring_seting1 = roi1.get() ring_seting2 = roi2.get() ring_seting3 = roi3.get() global ring_settings ring_settings = [] ring_settings.clear() ring_settings.append(ring_seting1) ring_settings.append(ring_seting2) ring_settings.append(ring_seting3) plugboard_settings = plugb.get() global machine machine = EnigmaMachine.from_key_sheet( rotors=roters, reflector='B', ring_settings=ring_settings, plugboard_settings=plugboard_settings) machine.set_display('WXC') msg_key = machine.process_text('KCH') machine.set_display(msg_key) print( f"{bcolors['OKCYAN']}Roters: {roters} \t Ring Setting: {ring_settings} \t Plug Setting: {plugboard_settings}{bcolors['ENDC']}" )
def find_rotor_start( rotor_choice, ciphertext, cribtext ): from enigma.machine import EnigmaMachine alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" machine = EnigmaMachine.from_key_sheet( rotors=rotor_choice, reflector='B', ring_settings='1 1 1', # no ring setting plugboard_settings='AV BS CG DL FU HZ IN KM OW RX') # plugboard known # do an exhaust search over all possible rotor starting positions for i in range(len(alphabet)): # search for rotor 1 start position for j in range(len(alphabet)): # search for rotor 2 start position for k in range(len(alphabet)): # search for rotor 3 start position # generate a possible rotor start position start_pos = alphabet[i] + alphabet[j] + alphabet[k] # set machine initial starting position and attempt decrypt machine.set_display(start_pos) plaintext = machine.process_text(ciphertext) # check if decrypt is the same as the crib text if (plaintext == cribtext): # print( start_pos, plaintext, cribtext ) return( rotor_choice, start_pos ) return( rotor_choice, "null" )
def __init__(self): pygame.init() self.font = pygame.font.SysFont('Arial', 25) pygame.display.set_caption("Enigma") self.screen = pygame.display.set_mode((0, 0), pygame.RESIZABLE) self.r1Count = self.r2Count = self.r3Count = 1 #Adding hooks pygame.draw.lines(self.screen, yellow, False, [(620, 260), (650, 260)], 5) pygame.draw.lines(self.screen, yellow, False, [(310, 260), (340, 260)], 5) #border lines pygame.draw.lines(self.screen, white, False, [(0, 500), (1600, 500)], 5) pygame.draw.lines(self.screen, white, False, [(750, 0), (750, 1500)], 5) #Initalizing enigma self.machine = EnigmaMachine.from_key_sheet( rotors='II IV V', reflector='B', ring_settings=[1, 20, 11], plugboard_settings='AV BS CG DL FU HZ IN KM OW RX') self.f = open("output.txt", "a") self.x = 850 self.y = 100 self.count = 0 #Output screen pygame.draw.rect(self.screen, white, (850, 100, 600, 300)) #Reset button pygame.draw.rect(self.screen, white, (440, 400, 70, 40)) self.reset = self.screen.blit(self.font.render("RESET", True, black), (440, 400))
def find_rotor_start( rotor_choice, ciphertext, cribtext ): from enigma.machine import EnigmaMachine alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" machine = EnigmaMachine.from_key_sheet( rotors=rotor_choice, reflector='B', ring_settings='21 15 16', plugboard_settings='KL IT PQ MY XC NF VZ JB SH OG') # Search over all possible rotor starting positions for i in range(len(alphabet)): # search for rotor 1 start position for j in range(len(alphabet)): # search for rotor 2 start position for k in range(len(alphabet)): # search for rotor 3 start position # Generate a possible rotor start position start_pos = alphabet[i] + alphabet[j] + alphabet[k] # Set machine initial starting position and attempt to decrypt machine.set_display(start_pos) plaintext = machine.process_text(ciphertext) #print("Plain: " + plaintext + ", Crib: " + cribtext) # Check if decrypted text is the same as the crib text if (plaintext == cribtext): return( rotor_choice, start_pos ) return( rotor_choice, "null" )
def enigma_thang(rGuessIn, reflect_In, pairG_In, rSettings): #we are given these settings initkey = 'GQT' messagekey = 'UKJ' ciphertext = 'GCXSSBPPIUDNWXJZGIICUEFYGISQOCGLLGMMKYHJ' rguess = rGuessIn pairguess = pairG_In #initiate machine with known quantities and guesses machine = EnigmaMachine.from_key_sheet( rotors="{} {} {}".format(rguess[0], rguess[1], rguess[2]), reflector=reflect_In, ring_settings=rSettings, plugboard_settings='BF CM DR HQ JK LU OY PW ST {}'.format(pairguess), ) #encrypt the message key so we can use decrypted key as display for next round machine.set_display(initkey) msg_key = machine.process_text(messagekey) #finally decrypt with all settings set up machine.set_display(msg_key) plaintext = machine.process_text(ciphertext) #check if we are close to correct so we don't wait 10 minutes to figure out code is wrong if "ELADE" in plaintext: print(plaintext, rGuessIn, reflect_In, pairG_In, rSettings) print("THIS ONE!!!!!!!!!!!!!!!!!!!!")
def __init__(self, codebuch_path, day=datetime.now().day): """Set up an operator with a copy of this month's codebuch.""" # Get today's rotor settings. with open(codebuch_path) as f: self.machine = EnigmaMachine.from_key_file(f, day=day) # Generate operator grundstellung. self.grundstellung = random_letters(3)
def encryptResult(): message = request.form['message'] reflector = request.form['reflector'].upper() rotor1 = int(request.form['rotor1']) rotor2 = int(request.form['rotor2']) rotor3 = int(request.form['rotor3']) ringSetting1 = int(request.form['ringSetting1']) ringSetting2 = int(request.form['ringSetting2']) ringSetting3 = int(request.form['ringSetting3']) startingPosition1 = request.form['startingPosition1'] startingPosition2 = request.form['startingPosition2'] startingPosition3 = request.form['startingPosition3'] messageKey = request.form['messageKey1'] + request.form[ 'messageKey2'] + request.form['messageKey3'] setDisplay = startingPosition1 + startingPosition2 + startingPosition3 machine = EnigmaMachine.from_key_sheet( rotors=getRotor(rotor1, rotor2, rotor3), reflector=request.form['reflector'].upper(), ring_settings=[ringSetting1, ringSetting2, ringSetting3]) # set machine initial starting position of rotors machine.set_display(setDisplay) #encrypt the key enc_key = machine.process_text(messageKey) # use message key machine.set_display(messageKey) cipherText = machine.process_text(message) html = "<!DOCTYPE html>\n" html += "<html lang='en'>\n" html += "<head>\n" html += "<meta charset='UTF-8'>\n" html += "<title>Encrypted</title>\n" html += "</head>\n" html += "<body style='background-color:powderblue;'>\n" html += "<div>\n" html += "<p style='font-family: Courier;'>Cipher Text: " + cipherText + "</p>" html += "</div>\n" html += "<div>\n" html += "<p style='font-family: Courier;'>Message Key: " + enc_key + "</p>" html += "</div>\n" html += "<div>\n" html += "<form method='POST' action='encryptSimulator'>\n" html += "<input style='width:150px; height:150px; font-size:100px;' type='submit' value='Encrypt'/>\n" html += "</form>\n" html += "<br/>\n" html += "<form method='POST' action='decryptSimulator'>\n" html += "<input style='width:150px; height:150px; font-size:100px;' type='submit' value='Decrypt'/>\n" html += "</form>\n" html += "</div>\n" html += "</body>" html += "</html>" return html
def testAllVars(r1_0, r1_1, r2_0, r2_1, r3_0, r3_1): rs = ' '.join([r1_0, r2_0, r3_0]) machine = EnigmaMachine.from_key_sheet(rotors='III II IV', reflector='B', ring_settings=rs, plugboard_settings='CT EW JL QX') machine.set_display(''.join([r1_1, r2_1, r3_1])) c = machine.process_text('JGYJZ NOXZX QZRUQ KNTDN UJWIA', replace_char=None) return c
def testRot1(var1, var2): rs = var1 + ' A A' machine = EnigmaMachine.from_key_sheet(rotors='III II IV', reflector='B', ring_settings=rs, plugboard_settings='CT EW JL QX') machine.set_display(var2 + 'EP') c = machine.process_text('JGYJZ NOXZX QZRUQ KNTDN UJWIA', replace_char=None) return c
def configure_enigma_machine(rotors_pos, rotor_start_conf): machine = EnigmaMachine.from_key_sheet( rotors = rotors_pos, reflector='B', ring_settings=[0, 0, 0], plugboard_settings='') machine.set_display( rotor_start_conf ) return machine
def testVarsSb(r1_0, r1_1, r2_0, r2_1, r3_0, r3_1, pb, cip=None): if cip is None: cip = 'JGYJZ NOXZX QZRUQ KNTDN UJWIA' rs = ' '.join([r1_0, r2_0, r3_0]) machine = EnigmaMachine.from_key_sheet(rotors='III II IV', reflector='B', ring_settings=rs, plugboard_settings=pb) machine.set_display(''.join([r1_1, r2_1, r3_1])) c = machine.process_text(cip, replace_char=None) return c
def get_encrypted_text(text: str, rotor_settings: str, plug_settings: str) -> str: """Gives encrypted text based on the param settings""" machine = EnigmaMachine.from_key_sheet( rotors="I II III", reflector="B", ring_settings=[1, 20, 11], plugboard_settings=plug_settings, ) machine.set_display(rotor_settings) return machine.process_text(text)
def get_setting(): test = "" ring_setting = [1, 1, 1] ciphertext = 'IPUXZGICZWASMJFGLFVIHCAYEG' plaintext = "HOWDYAGGIESTHEWEATHERISFINE" while 'HOWDYAGGIES' not in test: ring_setting = next_position(ring_setting) machine = EnigmaMachine.from_key_sheet( rotors='I II III', reflector='B', ring_settings=ring_setting, plugboard_settings='AV BS CG DL FU HZ IN KM OW RX') test = machine.process_text(ciphertext) return ring_setting
def brute_ring_settings(ciphertext): for a in range(1, 26): for b in range(1, 26): for c in range(1, 26): machine = EnigmaMachine.from_key_sheet( rotors='I II III', reflector='B', ring_settings=[a, b, c], plugboard_settings='AV BS CG DL FU HZ IN KM OW RX') plaintext = machine.process_text(ciphertext) if plaintext.startswith('HOWDY'): print('[+] Ring settings: {}, {}, {}'.format(a, b, c)) return a, b, c return -1, -1, -1
def find_rotor_start(ciphertext, a, rotor): from enigma.machine import EnigmaMachine alphabets = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" machine = EnigmaMachine.from_key_sheet( rotors=['Gamma', 'II', 'IV', rotor], reflector='C', ring_settings=[3, 5, a, 20], plugboard_settings='fv cd hu ik es op yl wq jm') for rotor3 in alphabets: start_pos = 'F' + 'J' + rotor3 + 'O' machine.set_display(start_pos) plaintext = machine.process_text(ciphertext) print(plaintext)
def test(li, deb=False): rs = ' '.join([str(i) for i in li]) #print rs try: machine = EnigmaMachine.from_key_sheet( rotors='III II IV', reflector='B', ring_settings=rs, plugboard_settings='DE AH CO GZ LQ NY PS TW IJ KM') machine.set_display('EFM') c = machine.process_text('XTSYN WAEUG EZALY NRQIM', replace_char=None) if deb: print c if 'HELLO' in c: print i, j, k except Exception as e: pass
def __init__(self, **kwargs): super().__init__(**kwargs) # NOTE This is essentially a singleton # All global variables go here. self.machine = EnigmaMachine.from_key_sheet( rotors="I II III", reflector="B", ring_settings=[1, 20, 11], plugboard_settings="", ) # Begin instantiation. Change onload self.machine.set_display("AAA") self.game_id = None self.APP_DIR = os.path.dirname(os.path.abspath(__file__)) self.keys = [ "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", ]
def find_rotor_start(rotor_choice, ring_choice, ciphertext, cribtext): alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' machine = EnigmaMachine.from_key_sheet(rotors=rotor_choice, reflector='B', ring_settings=ring_choice, plugboard_settings='BU GE VL') for rotor1 in alphabet: for rotor2 in alphabet: for rotor3 in alphabet: start_pos = rotor1 + rotor2 + rotor3 machine.set_display(start_pos) plaintext = machine.process_text(ciphertext) # print(plaintext) if cribtext in plaintext: print('Valid settings found!') logging.info('Valid settings found!') logging.info(plaintext) return rotor_choice, ring_choice, start_pos return rotor_choice, ring_choice, "Cannot find settings"
def on_config_change(): """ After you change the JSON data w/ JSONStore, call this function This should only be called for rotor or plug changes """ store = JsonStore(DATA_DIR) game_id = str(App.get_running_app().game_id) plugs = store.get(game_id)["current_state"]["plugs"] plug_settings = " ".join(x for x in plugs) App.get_running_app().machine = EnigmaMachine.from_key_sheet( rotors="I II III", reflector="B", ring_settings=[1, 20, 11], plugboard_settings=plug_settings, ) rotors = "" for x in store.get(game_id)["current_state"]["rotors"]: if x is None: continue rotors += x App.get_running_app().machine.set_display(rotors)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Connect the socket to the port where the server is listening server_address = (TCP_IP, TCP_PORT) print('connecting to {} port {}'.format(*server_address)) sock.connect(server_address) #messages that are to be sent queue = deque([ "She made the room dark and slept; she awoke and made the room light; she ate and exchanged ideas with her friends, and listened to music and attended lectures; she make the room dark and slept. Above her, beneath her, and around her, the Machine hummed eternally; she did not notice the noise, for she had been born with it in her ears. The earth, carrying her, hummed as it sped through silence, turning her now to the invisible sun, now to the invisible stars. She awoke and made the room light. The Secret word is electroboom." ]) #setup machine according to specs from a daily key sheet: #medium-hard, army level, only initial three rotors machine = EnigmaMachine.from_key_sheet(rotors='II I III', reflector='B', plugboard_settings='KE JD MN LS OW') while 1: #set machine to todays setting machine.set_display('ABC') #write info to log f.write(str(datetime.datetime.now()) + "\n") f.write(str(machine.get_display()) + "\n") fx.write("Rotor position: " + str(machine.get_display()) + "\n") #pick a message and encrypt it MESSAGE = queue.popleft() EM = machine.process_text(MESSAGE)
#X is not in use, to make your life easier ALPHABET = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'Y', 'Z' ] #there are more reflectors, but this will be bad enough for you to deal with. LIST_OF_REFLECTORS = ['B', 'C'] message = stdin.read().rstrip("\n") for i in list(permutations(LIST_OF_REFLECTORS)): reflector = i[0] for j in list(permutations(LIST_OF_ROTORS)): rotor = " ".join(j) for k in list(permutations(RING_SETTINGS)): ring_settings = " ".join(k) print("{} {} {}".format(reflector, rotor, ring_settings)) #This is one way to create an enigma machine, there are others ;) machine = EnigmaMachine.from_key_sheet( rotors=rotor, reflector=reflector, ring_settings=ring_settings, plugboard_settings='QZ WG EC RV TB YN UM IK OL PA') decrypted_message = machine.process_text(message) decrypted_message = decrypted_message.split("X") decrypted_message = " ".join(decrypted_message) print(decrypted_message)
'AJDKSIRUXBLHWTMCQGZNPYFVOE', ring_setting=5, stepping='E') r3 = Rotor('my rotor3', 'BDFHJLCPRTXVZNYEIWGAKMUSQO', ring_setting=15, stepping='V') #Reflector reflector = Rotor('my reflector', 'FVPJIAOYEDRZXWGCTKUQSBNMHL') #Plugboard pb = Plugboard.from_key_sheet('PO ML IU KJ NH YT GB VF RE DC') #Machine machine_encrypt = EnigmaMachine([r1, r2, r3], reflector, pb) machine_decrypt = EnigmaMachine([r1, r2, r3], reflector, pb) def encrypter(): global message global ciphertext_encrypt # Set the initial position of the Enigma rotors machine_encrypt.set_display('AFP') print("AFP") # Encrypt the text 'BFR' and sotre it as msg_key msg_key = machine_encrypt.process_text('OMH') print(msg_key)
message = stdin.read().rstrip("\n") for i in list(permutations(LIST_OF_REFLECTORS)): reflector = i[0] for j in list(permutations(LIST_OF_ROTORS)): rotor = " ".join(j) for k in list(permutations(RING_SETTINGS)): ring_settings = " ".join(k) for combo in combinations(ALPHABET, 2): # 2 for pairs, 3 for triplets, etc for l in list(permutations(combo)): #print combo try: #This is one way to create an enigma machine, there are others ;) machine = EnigmaMachine.from_key_sheet( rotors="III I II", reflector="B", ring_settings="B D J", plugboard_settings='LO KI JU HY GT FR DE SW QA {}'. format("".join(l))) decrypted_message = machine.process_text(message) decrypted_message = decrypted_message.split("X") decrypted_message = " ".join(decrypted_message) print("{} {} {} LO KI JU HY GT FR DE SW QA {}".format( reflector, rotor, ring_settings, "".join(l))) #print("{} {} {}".format(reflector, rotor, ring_settings)) print(decrypted_message) except: pass
from enigma.machine import EnigmaMachine machine = EnigmaMachine.from_key_sheet( rotors = 'II IV V', reflector = 'B', ring_settings = [1, 20, 11], plugboard_settings = 'AV BS CG DL FU HZ IN KM OW RX') machine.set_display('WXC') msg_key = machine.process_text('KCH') machine.set_display(msg_key) chiphertext = 'NIBLFMYMLLUFWCASCSSNVHAZ' plaintext = machine.process_text(chiphertext) print plaintext
#!/usr/bin/env python import copy from enigma.machine import EnigmaMachine from sys import stdin, stderr #print("Starting up machine...") #D = int(input("What is the day for this message? :")) with open('Schlusselblatt', 'r') as f: # machine = EnigmaMachine.from_key_file(f, day=D) machine = EnigmaMachine.from_key_file(f, day=20) machine1 = copy.deepcopy(machine) #pick a message and encrypt it #MESSAGE = input("What is the message? :") MESSAGE = stdin.read().rstrip("\n") EM = machine.process_text(MESSAGE) print("Output message = ", EM, "\n") #decrypt message, just to double check #we are using a copy of the machine, with the original configurations, to check the message to ensure it is functioning. ED = machine1.process_text(EM) print("Input message = ", ED, "\n") print('Completed')
# # Reflector names | Enigma Models # ------------------------------------ # B, C | All Wehrmacht models # B-Thin, C-Thin | Kriegsmarine M4 (with Beta & Gamma rotors) # # Ring settings # 3 numbers between [0;25] # # Plugboard settings # Pairs of letters between A-Z up to 10 pairs # Ref:https://py-enigma.readthedocs.io/en/latest/reference.html#rotor-table-label machine = EnigmaMachine.from_key_sheet(rotors='I II III', reflector='B', ring_settings=[0, 0, 0], plugboard_settings='') # set machine initial starting position machine.set_display('AAA') # get machine initial starting position position = machine.get_display() # cipher/decrypt the message key msg_key = machine.process_text( 'AAA', replace_char='X' ) # replace_char serve para substituir os caracteres especiais por X print(msg_key) ciphertext = 'NIBLFMYMLLUFWCASCSSNVHAZ' plaintext = machine.process_text(ciphertext)
reflectors = ['B-Thin', 'C-Thin'] rotor_combs = [] for num_1 in num_rotors: for num_2 in num_rotors: for num_3 in num_rotors: for sym in sym_rotors: rotor_combs.append(' '.join([sym, num_1, num_2, num_3])) # Given settings ring_setting = ' '.join([chr(ord('a') + i - 1) for i in [4, 9, 3, 20]]) plugboard_setting = 'fv cd hu ik es op yl wq jm' start_positions = ''.join([chr(ord('a') + i - 1) for i in [2, 5, 14, 5]]) for rotor_comb in rotor_combs: for reflector in reflectors: # Create an enigma machine object from py-enigma machine = EnigmaMachine.from_key_sheet( rotors=rotor_comb, reflector=reflector, ring_settings=ring_setting, plugboard_settings=plugboard_setting) machine.set_display(start_positions) decipheredtext = machine.process_text(ciphertext) # Look for flag format: if (decipheredtext[:6] == "CSICTF"): print(decipheredtext)
RZNSZNCTWMEHMTSXRYMANXPMCURNGDERSIPVLLOUPYXECS LGBYFDXIEPLBHIRJTOYMCYCADOFBHNTODPTCWPMKJXKVSWH TINWJKPHLXDSPRMYGIEDVJWKTDCOGTTLGTHZFWBEXZLECRTI HANJQBDFCLJYRHLLHUJZLFMFLQTHJHZDAKDHBOAVBANINGRK BDNEOTULNIDOZWLRCENSRHROXCYFPSFQMONHBQAEELLOH GUEYKNARFYJJOURVGONUMGZNGYOTSZLIODFTGIHVPULLLH RYCFLORWZK""".replace('\n', '').replace('\r', '').replace(' ', '') ansData = [] for i in keyData: ansData.append(int(i, 2) ^ int("11111111", 2)) ansData[0] = ansData[0] + 1 ansData[1] = ansData[1] + 1 ansData[3] = ansData[3] + 1 myString = "" for i in ansData: myString += chr(i) machine = EnigmaMachine.from_key_sheet( rotors=myString[0:7], reflector=myString[8], ring_settings=[int(myString[10], 10), int(myString[11:14], 10), int(myString[14:17], 10)], plugboard_settings=myString[18:47]) machine.set_display(myString[48:]) plaintext = machine.process_text(message).replace('X', ' ')
async def enigma_act(): estat_id, command, letter = context2.update.callback_query.data.split()[1:] estat = enigmas.get(estat_id) if estat is None: await EditMessageReplyMarkup(chat_id=context2.update.callback_query.message.chat.chat_id, message_id=context2.update.callback_query.message.message_id).send() AnswerCallbackQuery(context2.update.callback_query.query_id, MSG.expired).webhook() return AnswerCallbackQuery(context2.update.callback_query.query_id).webhook() if command == 'set': estat.input = '' m = MSG.setup.format(setting=MSG.setup_display, display=' '.join(estat.display), reflector=estat.reflector, rotors=' '.join(estat.rotors_list), rings=' '.join(estat.rings_list), plugboard=' '.join(estat.plugboard) if len( estat.plugboard) else MSG.plugboard_empty, idisplay=' '.join(estat.display)) kb = enigma_kb(estat_id, 'enigma-display') await EditMessageText(chat_id=context2.update.callback_query.message.chat.chat_id, message_id=context2.update.callback_query.message.message_id, text=m, reply_markup=kb).send() return machine = EnigmaMachine.from_key_sheet( rotors=estat.rotors_list, reflector=estat.reflector, ring_settings=' '.join(estat.rings_list), plugboard_settings=' '.join(estat.plugboard)) machine.set_display(''.join(estat.display)) if command == 'bksp': if not len(estat.input): return estat.input = estat.input[:-1] else: estat.input += letter inp = ''.join([l if (n + 1) % 5 else l + ' ' for n, l in enumerate(estat.input)]) out = ''.join([l if (n + 1) % 5 else l + ' ' for n, l in enumerate(machine.process_text(estat.input))]) display = list(machine.get_display()) if len(display) < 4 and estat.rotors == 4: display.insert(0, estat.display[0]) display = ' '.join(display) m = MSG.enigma.format(display=display, input=inp, output=out, reflector=estat.reflector, rotors=' '.join(estat.rotors_list), rings=' '.join(estat.rings_list), plugboard=' '.join(estat.plugboard) if len(estat.plugboard) else MSG.plugboard_empty, idisplay=' '.join(estat.display)) await EditMessageText(chat_id=context2.update.callback_query.message.chat.chat_id, message_id=context2.update.callback_query.message.message_id, text=m, reply_markup=enigma_kb(estat_id)).send()
from enigma.machine import EnigmaMachine machine = EnigmaMachine.from_key_sheet( rotors='II V I', reflector='B', ring_settings='07 19 02', plugboard_settings='HR NC IU DM TW GV FB ZL EQ OX') init_rot_pos = 'EHC' machine.set_display(init_rot_pos) enc_key = machine.process_text('CTF') print("Initial Rotor Positions: %s" % init_rot_pos) print("Three letter message key: %s" % enc_key) secret_key = 'CTF' machine.set_display(secret_key) print("Secret Key: %s" % secret_key) #user_input = input("Please enter string to be encoded: ") #user_input ='AGLARRUZRQGCLHVATCAKXHBLIPFWMRCGHNCYCVUNCSJWAPSNUKBRODCFVBYHKAQ' user_input = 'Riddle me this what is always on its way here but never arrives' enc = machine.process_text(user_input) print("Original Message: %s" % user_input) print("Encoded text: %s" % enc)
#!/bin/env python3 from string import ascii_uppercase as UC from random import SystemRandom from enigma.machine import EnigmaMachine from secretstuff import FLAG, PLUGBOARD_SETTINGS assert FLAG.isupper() # Without pbcft{...} random = SystemRandom() for _ in range(50): ROTORS = [random.choice(("I","II","III","IV","V","VI","VII","VIII")) for _ in range(3)] REFLECTOR = random.choice(("B", "C", "B-Thin", "C-Thin")) RING_SETTINGS = [random.randrange(26) for _ in range(3)] machine = EnigmaMachine.from_key_sheet( rotors=ROTORS, reflector=REFLECTOR, ring_settings=RING_SETTINGS, plugboard_settings=PLUGBOARD_SETTINGS) machine.set_display(''.join(random.sample(UC, 3))) ciphertext = machine.process_text(FLAG) print(ciphertext)