Verschlüsselungs-Prinzip mit C++

Dieses Thema im Forum "Sicherheit & Datenschutz" wurde erstellt von Flu, 24. Februar 2011 .

  1. 24. Februar 2011
    Zuletzt von einem Moderator bearbeitet: 14. April 2017
    Hi. Erstmal vorab: ich weiß nicht, ob das Thema zu Security oder Programmierung gehört, falls es hier falsch ist, dann bitte verschieben.
    So nun zu meiner Frage: Wir besprechen zur Zeit das Thema Verschlüsselung, jetzt wollt ich an Hand dieses Codes fragen ob ich das ganze richtig verstanden hab.


    Code:
    #include <stdio.h>
    #include <stdlib.h>
    
    /*In dieser Funktion soll die Eingabe eines Passwortes erfolgen,
    welches dann an die Verschlüsselungsfunktion weitergegeben und 
    verschlüsselt wird.*/
    int pw_eingabe(){
     char passwort[80]; /*char mit 80 Zeichen 
     für das Passwort, es 
     darf kürzer aber nicht 
     länger sein*/
     printf("\nPW eingeben bitte: ");
     gets(passwort); //liest die Eingabe der Tastatur
    
     printf("\nIhr PW lautet: %s", passwort);/*Gibt das PW testweise aus, 
     später natürlich nicht mehr*/
    
     return pw_verschluesseln(passwort); /*PW wird der Verschlüsselnfunktion
     übergeben.*/
    }
    
    /*Hier wird das PW verschlüsselt, indem die einegebenen Zahlen und Buchstaben
    laut dem ASCII-Code in Integer umgewandelt werden und gespeichert werden.*/
    int pw_verschluesseln(char pw[]){
     int ergebnis = 0; /*Hier wird das Integerergebnis 
     gespeichert*/
    
     int i; //Zählschleifenvariable
    
     for(i = 0; i <= strlen(pw); i++) //Zählschleife die das PW durchläuft
     
     ergebnis = ergebnis + (pw[i]*2+1); /*Die Verschlüsselungsfunktion lautet:
     n*2+1 ; wobei n = Integerwert der
     Ziffer an der Stelle i ist.*/
    
     printf("\nErgebnis: %i", ergebnis); //Ergebnis wird testweise ausgegeben
    
     return ergebnis; //Ergebnis wird zurückgegeben
    }
    
    //Regelt die Passworteingabe und Überprüfung
    main(){
     char passwort[80]; //Speichert ein bis zu 80 stelliges PW
     int versuch = 3; /*Anzahl der Versuche, um das richtige 
     PW zu finden.*/
     
     int verschl = pw_eingabe(); //speichert den Wert der Verschlüsselung 
    
     printf("\nSie haben drei Versuche!\n");
     //Die do-while Schleife regelt die PW Überprüfung und steuert die Versuche
     do{
     printf("\nBitte PW eingeben: ");
     gets(passwort);
     if(pw_verschluesseln(passwort) == verschl){ /*wenn das festgelegte PW den
     gleichen Wert besitzt, wie zu 
     testendes PW, dann ist die 
     Eingabe korrekt*/
     printf("\nPW ok!");
     break;
     }
     else{
     printf("\nFehlerhaftes PW! \n\a");
     versuch--;
     }
     } while(versuch > 0);
     getch();
    }
    
    oder: No File | www.xup.in

    Flu
     
  2. 24. Februar 2011
    AW: VerschlüsselungsPrinzip

    Naja, mit Verschlüssellung hat das weniger zu tun als mit Hashing: Du errechnest ja jeweils ein Hash vom Passwort und vergleichst die beiden Hashes. Das ist so durchaus üblich, wenn auch Deine Hashfunktion ziemlich unsicher ist*

    Kannst Du Deine Frage vielleicht auch etwas konkretisieren?


    * unsicher: Offensichtlich ist die Reihenfolge der Buchstaben egal. Wenn das ursprüngliche Passwort "123" ist, sollte auch "321" oder "213" etc. gehen.
     
  3. 24. Februar 2011
    AW: VerschlüsselungsPrinzip

    ok. über die reihenfolge hab ich gar nicht nachgedacht. mir is kla das die funktion sehr einfach ist. mir gings nur ums prinzip. wenn das ganze ne hashfunktion ist, dann hab ich das prinzip nun verstanden. wie sähe dann ne richtige verschlüsselung aus?
     
  4. 24. Februar 2011
    AW: Verschlüsselungs-Prinzip mit C++

    Na, eine Verschlüsselung muss ja in beide Richtungen funktionieren, beispiel:

    Du hast ein Wort: "hallo"
    und einen Schlüssel, sagen wir mal 1
    Dann verschlüsseln wir, in dem wir jeden Buchstaben um 1 (das ist der Schlüssel) im Alphabet verschieben:
    h -> i
    a -> b
    l -> m
    l -> m
    o -> p
    Somit ist unser verschlüsseltes Wort "ibmmp"

    Kennen wir den Schlüssel, können wir "ibmmp" wieder entschlüsseln, indem wir jeden Buchstaben wieder um 1 im Alphabet
    (in die andere Richtung!) verschieben:
    i - > h
    b -> a
    m -> l
    m -> l
    p -> o

    Du siehst, es geht in beide Richtungen! Kennen wir jetzt nicht den Schlüssel, oder haben den falschen, kommt aber nur Mist raus, das ist der Trick dabei.

    Es gibt viele verschiedene Verfahren, das hier ist so ziemlich das einfachste. Es ist auch nicht besonders sicher, aber darum solls hier mal noch nicht gehen.

    Du kannst ja mal probieren, das in C zu programmieren! Du musst aber beachten, dass wenn zu "z" um 1 verschiebst kommst
    Du wieder bei "a" an. Das kann man mit der modulo-operation machen. Kannst ja mal nachschlagen und googlen
     
  5. 24. Februar 2011
    AW: VerschlüsselungsPrinzip

    Für den Anfang könntest du dir mal RSA bei Wikipedia angucken. Ist sehr einfach zu verstehen. Es handelt sich zwar um eine asymmetrische Verschlüsslung (wenn dein Beispiel eine richtige Verschlüsselung wäre, wäre es ein symmetrisches Verfahren), aber das Prinzip ist ähnlich (man hat halt einen öffentlichen Schlüssel zum Verschlüsseln und einen privaten zum Entschlüsseln). Symmetrische Verschlüsselungsverfahren sind z.B. DES, Twofish, Serpent oder AES.

    Aus deinem Beispiel könntest du z.B. so eine "richtige" Verschlüsselung machen (nicht getestet und natürlich immer noch sehr unsicher):
    Code:
    /*key ist der Schlüssel mit dem das verschlüsselte PW enc_pw entschlüsselt werden soll.
    key muss hier min. so lang sein wie enc_pw!*/
    char[] pw_entschluesseln(char enc_pw[], char key[]){
     int len = strlen(key);
     char ergebnis[len];
     int i;
     
     for(i = 0; i <= len; i++){
     /*Umkehrfunktion der Verschlüsselungsfunktion*/
     
     ergebnis[i] = (enc_pw[i] - 1 - i) / 2;
     }
     return ergebnis;
    }
    
    char[] pw_verschluesseln(char pw[]){
     int len = strlen(pw);
     char ergebnis[len]; //Speichert das verschlüsselte PW
     int i; //Zählschleifenvariable
    
     for(i = 0; i <= len; i++){ //Zählschleife die das PW durchläuft
     
     /*Hier wird i als Schlüssel verwendet,
     d.h. der Schlüssel für z.B. ein 5-stelliges PW
     wäre immer 01234*/
     
     ergebnis[i] = i + pw[i]*2+1;
     }
     return ergebnis; //Ergebnis wird zurückgegeben
    }
     
  6. 25. Februar 2011
    AW: Verschlüsselungs-Prinzip mit C++

    Also ich behaupte mal eien richtige Verschlüsselung erhält man, wenn
    man zu einem Verschlüsselungsalgorithmus ein eindeutiger Entschlüsselungsalgorithmus exestiert.

    Nutzdaten -> Algorithmus (+ Passwort) -> Cryptdaten
    Cryptdaten -> Algorithmus (+ Passwort) -> Nutzdaten

    Bei deinem oberen Code wäre dies dann nicht der Fall, denn du du kannst deine Daten nicht eindeutig zurückberechnen.

    Ein gutes und oft genutztes Beispiel für eine Verschlüsselung ist die
    XOR-Verknüpfung (exklusiv oder), Beispiel:

    Nutzdaten: 0x45
    Passwort: 0x12
    0x45 XOR 0x12 = 0x57 (verschlüsselt)
    0x57 XOR 0x12 = 0x45 (entschlpsselt)

    Mfg Rushh0ur
     
  7. 25. Februar 2011
    AW: Verschlüsselungs-Prinzip mit C++

    Vielen Dank für die Vielen antworten. werde mir mal die hier vorgestellten verschlüsselungen im inet angucken
     
  8. Video Script

    Videos zum Themenbereich

    * gefundene Videos auf YouTube, anhand der Überschrift.