Wie man einen Text in C verschlüsselt?

Question

Ich arbeite an einem Problem und ich bin ein bisschen fest, also dachte ich, um deine Hilfe zu bitten. Ich möchte ein Programm mit den folgenden Fähigkeiten machen. Der Benutzer gibt einen vierstelligen Schlüssel und einen Text.

Dann wird der Text in Chiffre mit der folgenden Methode konvertiert werden. Nehmen wir an, dass die Texteingabe "ABC" war und der Schlüssel 123 war. Dann wird mithilfe der ASCII-Tabelle "ABC" in "BDF" konvertiert. Der Text wird in der ASCII-Tabelle um K Positionen nach vorne verschoben, wobei K die entsprechende Ziffer des Schlüssels ist. Betrachte den Text als unendlich. Meine erste Aktion bestand darin, den Schlüssel in ein Array umzuwandeln.

//scanning the cypher key 
scanf("%d", &cypherkey); 

//converting the cypher key into an array using a practical mathematic method for extracting its digit 
int keyarray[4]; 
keyarray[0]= cypherkey/1000; 
keyarray[1]= (cypherkey-keyarray[0]*1000)/100; 
keyarray[2]= ((cypherkey-keyarray[0]*1000)- keyarray[1]*100)/10; 
keyarray[3]= ((cypherkey-keyarray[0]*1000)- keyarray[1]*100)-keyarray[2]*10; 

So, jetzt habe ich den Schlüssel in einem Array. Ich finde jedoch keine gute Möglichkeit, den Text zu lesen und ihn dann zu verschlüsseln. Ich kann ein Array nicht verwenden, weil wir die Länge des Textes nicht kennen.

Ich würde jede Hilfe zu schätzen wissen!

Answer 1

Ich habe eine Aufnahme gemacht und der Eingabetext ist in der Anwendung fest codiert. Das folgende Beispiel ist kein Produktionscode, sondern nur für Bildungszwecke gedacht.

Auf meinem Ansatz gibt es zwei Herausforderungen:

• die Funktion Schreiben, die zählt, wie viele Stellen gibt es in einer Reihe sind:

• Implementierung der Funktion, die eine bestimmte Stelle einer Zahl abruft;

.

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

int count_digits(int number) // // http://stackoverflow.com/questions/1489830/efficient-way-to-determine-number-of-digits-in-an-integer 
{ 
    int digits = 0; 
    if (number < 0) 
    digits = 1; 

    while (number) 
    { 
     number /= 10; 
     digits++; 
    } 

    return digits; 
} 

char get_digit(int number, int index) // starts at index 0 
{ 
    if (number == 0) 
     return (char)0; 

    int n_digits = count_digits(number); 
    if (index > n_digits) 
     return (char)-1; 

    char digit = -1; 
    int i; 
     for (i = 0; i < (n_digits-index); i++) 
    { 
     digit = number % 10; 
     number /= 10; 
    } 

    return digit; 
} 

int main() 
{ 
    printf("* Type the encoding key (numbers only): "); 
    int key = 0; 
    scanf("%d", &key); 

    int key_digits = count_digits(key); 
    //printf("* The key has %d digits.\n", key_digits); 

    char input_msg[] = "ABCABC"; // This is the input text 
    int input_sz = strlen(input_msg); 
    //printf("* Input message [%s] has %d characters.\n", input_msg, input_sz); 

    int i, d = 0; 
    for (i = 0; i < input_sz; i++) 
    {  
     if (d >= key_digits) 
      d = 0; 

     input_msg[i] += get_digit(key, d);  
     d++; 
    } 

    printf("* Encoded text is: %s\n", input_msg); 

    return 0; 
} 

Ausgänge der folgenden ...

Für Eingabetext ABC:

$ ./cypher 
* Type the encoding key (numbers only): 123 
* Encoded text is: BDF 

$ ./cypher 
* Type the encoding key (numbers only): 234 
* Encoded text is: CEG 

Für Eingabetext ABCABC:

$ ./cypher 
* Type the encoding key (numbers only): 123 
* Encoded text is: BDFBDF 

Answer 2

Die einfachste Antwort, die alle Leistungsbedenken ignoriert, ist, nur ein Zeichen zu einem Zeitpunkt zu behandeln. im Grunde

,

1. lesen ein Zeichen aus Ihrer Eingabe.
2. es verwandelt, basierend auf dem Algorithmus & Ihre aktuelle ‚Taste Ziffer‘
3. Voraus, um Ihre Position in Ihrem Tastenfeld, Looping um dann notwendig, wenn
4. Wiederholung bis zum Ende des Eingangs

Realwelt-Implementierungen würde wahrscheinlich die Eingabe in einen Puffer lesen, den gesamten Puffer bearbeiten und aus Leistungsgründen wiederholen.

Answer 3

Ich glaube, es ist ein einfacher Weg, dies zu tun . Der Algorithmus, den Sie beschreiben, ist als generalisierte Caesar-Chiffre bekannt. Die Kongruenzbeziehung, die den Text verschlüsselt, ist C = rP + s (mod 26), wobei P der Klartext ist, r ein Multiplikator ist und s die Verschiebung ist.In der von Ihnen beschriebenen Situation haben Sie einen Multiplikator von 2 und eine Verschiebung von 1. Wenn Sie vermeiden möchten, eine Tabelle zu verwenden, können Sie einfach den Unicode für jeden Buchstaben in Ihrem Klartext erhalten und einen konsistenten Offset vom Unicode subtrahieren Sie müssen immer mit einer Zahl unter 26 enden. Um den Chiffretext zu entschlüsseln, müssen Sie den Chiffretext mit dem Modularen Inverse von r multiplizieren, den Offset, den Sie angewendet haben, addieren und dann zurück in ein Zeichen aus der numerischen Unicode-Darstellung konvertieren.

Kurz gesagt, müssen Sie den Unicode für ein Zeichen, subtrahieren einige Offset, multiplizieren mit 2, addieren Sie 2 und nehmen Sie den Mod dieser Nummer Mod 26, um etwas zu verschlüsseln.

Um den Prozess umzukehren, multiplizieren Sie den Chiffretext, minus 1, mit dem Modular Inverse, fügen Sie den Offset hinzu und konvertieren Sie ihn zurück in ein Zeichen.