/* eine ENIGMA Chiffriermaschine in C programmiert.
   Urspruenglich kommt dieser Quellcode von ChatGPT, wurde
   jedoch wesentlich(ab dem Reflektor)  von Frank Gerlach korrigiert.

   ChatGPT alleine liefert Murks, der nicht funktionsfähig ist,
   jedenfalls nicht im Enigma-Reflektor-Stil.

   Es fehlt das Steckerbrett, was aber aus kryptologischer Sicht
   ohnehin nur falsche Sicherheit (großen Schlüsselraum)
   vorgaukelt.

   Dieses Program ist Freie Software und darf für beliebige
   Zwecke eingesetzt werden.

   Der Autor übernimmt keinerlei Gewährleistung für die
   Fehlerfreiheit des Programms. Diese muss im Zweifelsfall vom
   Nutzer selbst nachgeprüft werden. 
*/



#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>

/*Die Rotor-Verdrahtung kommt aus ChatGPT, diese
  werden schlüsselabhängig weiter permutiert
*/
char ROTOR1[] = "EKMFLGDQVZNTOWYHXUSPAIBRCJ";
char ROTOR2[] = "AJDKSIRUXBLHWTMCQGZNPYFVOE";
char ROTOR3[] = "BDFHJLCPRTXVZNYEIWGAKMUSQO";
char REFLECTOR[] = "YRUHQSLDPXNGOKMIEBFZCWVJAT";

//Rotoren umgedreht
char rotor1Reverse[26];
char rotor2Reverse[26];
char rotor3Reverse[26];

void calcReverseRotor(const char* rotor,char* reverseRotor)
{
   for(int i=0; i < 26; i++)
    reverseRotor[rotor[i]-'A'] = i+'A'; 
}

/*leite eine Rotor-Permutation von einem menschenlesbaren Schluessel ab */
void schluesselAbleitung(const char* schluessel, char* rotor)
{
   int ls = strlen(schluessel);
   for(int i=0; i < 100;i++)
   {
      char s = schluessel[i%ls];
      char c = rotor[i%26]; 
      rotor[i%26] = rotor[s%26]; 
      rotor[s%26] = c;
   }
}


// Function to encrypt a single character using the current rotor positions
char encryptCharacter(char c, int rotorPositions[3]) {
    if (!isalpha(c)) {
        return c;
    }

    // Convert character to uppercase
    c = toupper(c);

    // Apply rotor1
    c = ROTOR1[(c - 'A' + rotorPositions[0]) % 26];
    //printf("[%c]",c);
    // Apply rotor2
    c = ROTOR2[(c - 'A' + rotorPositions[1]) % 26];
    //printf("[%c]",c);
    // Apply rotor3
    c = ROTOR3[(c - 'A' + rotorPositions[2]) % 26];
    //printf("[%c]",c);
    // Apply reflector
    c = REFLECTOR[c - 'A'];
    //printf("[%c]",c);

    c = rotor3Reverse[c-'A'];
    c = c - rotorPositions[2];
    if( (c-'A') < 0) c += 26;
    c = rotor2Reverse[c-'A'];
    c = c - rotorPositions[1];
    if( (c-'A') < 0) c += 26;
    c = rotor1Reverse[c-'A'];
    c = c - rotorPositions[0];
    if( (c-'A') < 0) c += 26;
  
    
    // Increment rotor positions
    rotorPositions[0] = (rotorPositions[0] + 1) % 26;
    if (rotorPositions[0] == 0) {
        rotorPositions[1] = (rotorPositions[1] + 1) % 26;
        if (rotorPositions[1] == 0) {
            rotorPositions[2] = (rotorPositions[2] + 1) % 26;
        }
    }
    

    return c;
}

void rotorAbleitung(const char* schluessel, const char* schlAbleiter,char* rotor)
{
    char* schluesselAbgeleitet = malloc(strlen(schluessel)+strlen(schlAbleiter)+1);
    strcpy(schluesselAbgeleitet,schlAbleiter);
    strcat(schluesselAbgeleitet, schluessel);
    schluesselAbleitung(schluesselAbgeleitet,rotor);     
    free(schluesselAbgeleitet);
}


int main(int argc, char** argv) {

    char* nachrichtenPuffer = NULL;
    if(argc == 3)
    {
        //Jeder Rotor wird mit einem eigenen, abgeleiteten Schlüssel permutiert
        const char* schluessel = argv[1];

        rotorAbleitung(schluessel,"BROCKEN",ROTOR1);
        rotorAbleitung(schluessel,"FELDBERG",ROTOR2);
        rotorAbleitung(schluessel,"ZUGSPITZE",ROTOR3);

        const char* klartext = argv[2];
        nachrichtenPuffer = malloc(strlen(klartext)+1);
        strcpy(nachrichtenPuffer, klartext);
    }
    else {  printf("Benutzung: enigma Schluessel Klartext\n"); exit(-1);}


    //printf("%s\n",ROTOR1);
    //printf("%s\n",ROTOR2);
    //printf("%s\n",ROTOR3);

    int rotorPositions[3] = {0, 0, 0};

    calcReverseRotor(ROTOR1,rotor1Reverse);
    calcReverseRotor(ROTOR2,rotor2Reverse);
    calcReverseRotor(ROTOR3,rotor3Reverse);

    // Encrypt the message character by character
    for (int i = 0; nachrichtenPuffer[i]; i++) {
        nachrichtenPuffer[i] = encryptCharacter(nachrichtenPuffer[i], rotorPositions);
    }

    printf("%s\n", nachrichtenPuffer);


    return 0;
}