First Commit

.env

@@ -0,0 +1,5 @@
+ALFABETO="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ROTOR_I="EKMFLGDQVZNTOWYHXUSPAIBRCJ"
+ROTOR_II="AJDKSIRUXBLHWTMCQGZNPYFVOE"
+ROTOR_III="BDFHJLCPRTXVZNYEIWGAKMUSQO"
+REFLECTOR="YRUHQSLDPXNGOKMIEBFZCWVJAT"

maquinav4.py

@@ -0,0 +1,148 @@
+import os 
+from dotenv import load_dotenv 
+
+load_dotenv()
+
+def menu():
+    opc = 0
+    print("===SELECTOR===")
+    print("1) Crypt Word")
+    print("2) Decrypt Word")
+    print("3) Exit")
+    opc = int(input("Select Option: "))
+    if opc == 1:
+        crypt_word()
+    elif opc == 2:
+        pass 
+    else:
+        os._exit(1)
+
+def load_rotors(rotor_opc):
+    alfabeto = os.getenv("ALFABETO")
+    rotor_I = os.getenv("ROTOR_I")
+    rotor_II = os.getenv("ROTOR_II")
+    rotor_III = os.getenv("ROTOR_III")
+    reflector = os.getenv("REFLECTOR")
+
+    if rotor_opc == 1: 
+        return rotor_I 
+    elif rotor_opc == 2:
+        return rotor_II 
+    elif rotor_opc == 3:
+        return rotor_III
+    elif rotor_opc == "alfabeto":
+        return alfabeto
+    elif rotor_opc == "reflector":
+        return reflector
+       
+def map_key(rotor_opc, char_key):
+    rotor = load_rotors(rotor_opc)
+    print(f"Rotor {rotor_opc} cargado...")
+    print(f"Buscando valor de {char_key} en rotor {rotor_opc}")
+    obj = char_key.upper()
+    for index, char_key_upper in enumerate(rotor): 
+        if char_key_upper == obj:
+            print(f"{char_key} tiene la posicion de {index}")
+            return index
+
+
+
+def map_char(rotor_opc, char):
+    rotor = load_rotors(rotor_opc)
+    print(f"Rotor {rotor_opc} cargado...")
+    print(f"Buscando valor de {char} en rotor {rotor_opc}")
+    obj = char.upper()
+    for index, char_upper in enumerate(rotor): 
+        if char_upper == obj:
+            char_pos = index
+            print(f"{char} tiene la posicion de {char_pos}")
+            return char_pos
+
+def find_char(rotor_opc, index):
+    rotor = load_rotors(rotor_opc)
+    print(f"Rotor {rotor_opc} cargado...")
+    print(f"Buscando el valor de la posicion {index} en rotor {rotor_opc}")
+    index_seguro = index % 26
+    value = rotor[index_seguro]
+    return value
+    
+def compare_value_notch(value_char, notch_value, key_pos):
+    if value_char != notch_value: 
+        return key_pos
+    else:
+        key_pos = (key_pos + 1) % 26
+        print(f"VALOR DEL KEY MODIFICADO A {key_pos}")
+        return key_pos 
+
+
+
+def main_cipher_logic(word, key):
+    palabra_cifrada = [0] * len(word)
+    print(f"Mapeando key {key} en alfabeto")
+    key_positions = [0] * len(key)
+    for i, char_key in enumerate(key):
+        char_key_pos = map_key("alfabeto", char_key)
+        key_positions[i] = char_key_pos
+    
+
+    for i, char in enumerate(word):
+        char_pos = map_char("alfabeto", char)
+        x = ((char_pos + key_positions[0]) % 26)
+        value_char = find_char(1, x) 
+        key_positions[0] = compare_value_notch(value_char, "Q", key_positions[0])
+        
+        x = ((map_char("alfabeto", value_char) + key_positions[1]) % 26)
+        value_char = find_char(2, x)
+        key_positions[1] = compare_value_notch(value_char, "E", key_positions[1])
+        
+        x = ((map_char("alfabeto", value_char) + key_positions[2]) % 26 )
+        value_char = find_char(3, x)
+        key_positions[2] = compare_value_notch(value_char, "V", key_positions[2])
+        
+        # buscamos en el referector
+        index = map_char("alfabeto", value_char)
+        char_from_reflector = find_char("reflector", index)
+
+        #index = map_char("alfabeto", value_char)
+        #print(index)
+        #x = find_char("reflector", index)
+
+        x = map_char(3, char_from_reflector)
+        key_positions[2] = compare_value_notch(value_char, "V", key_positions[2])
+        x = (((x) - key_positions[2]) % 26)
+
+        value_char = find_char("alfabeto", x)
+        x = map_char(2, value_char)
+        key_positions[1] = compare_value_notch(value_char, "E", key_positions[1])
+        x = (((x) - key_positions[1]) % 26)
+
+        value_char = find_char("alfabeto", x)
+        x = map_char(1, value_char)
+        key_positions[0] = compare_value_notch(value_char, "Q", key_positions[0])
+        final = (((x) - key_positions[0]) % 26)
+
+        char_cipher=find_char("alfabeto", final)
+        
+        print(f"Letra {char}\nCifrado {char_cipher}")
+
+        palabra_cifrada[i] = char_cipher
+
+    return "".join(palabra_cifrada)
+
+def crypt_word():
+    word=input("Word to crypt: ")
+    key=input("Key Word (the key length must be 3 letters): ")
+    if len(key) != 3:
+        print("THE KEY LENGHT MUST BE 3 LETTERS")
+        os._exit(1) 
+    crypted_word=main_cipher_logic(word, key)
+    print(f"Word in plain text: {word}")
+    print(f"Crypted word: {crypted_word}")
+
+
+
+
+## main 
+
+menu()
+