perl_o_crypt_beta_0_6_pwgen.pl

#!/usr/bin/perl                    -w                                                          -l
use hash_table

print "Welcome to Perl-O-Crypt. \nThis program is for encrypting messages.";#Begrüßung
print "It also offers the generation of passwords.";

print "You have these options: \n\tencrypt message => v\n\tdecrypt message => e \n\tgenerate password => any input";#Abfrage Richtung
$direction = <STDIN>;
chomp $direction;

#Ausgabe bei Verschlüsselung
if($direction eq "v"){
    #Abfrage, wie die zu verschlüsselnde Nachricht eingegeben werden soll.
    print "Do you want to enter the text manually or as a file?";
    print "\t m => manual input \n\t any input => input via file";
    $manual = <STDIN>;
    chomp $manual;

    if ($manual eq "m") {
        $locktext = <STDIN>;
        chomp $locktext;
        open(MIP,">lock.txt");
        print MIP $locktext;
        close(MIP);
    }
    else{
        print "\nPlease copy the file that is to be encoded into the program folder.";
        print "Please name it >>lock.txt<<";
    }
    print "Please copy the key into the program folder.";
    print "Please name it >>key.txt<<\n Afterwards press Enter.";
    $return_check = <STDIN>;
}
#Ausgabe bei Entschlüsselung
elsif($direction eq "e"){
    print "\nPlease copy the encrypted file into the program folder.";
    print "Please name it >>unlock.txt<<";
    print "Please copy the key into the program folder.";
    print "Please name it >>key.txt<<\n Afterwards press Enter.";
    $return_check = <STDIN>;
}
#Auslesen und Auswerten des Schlüssels
#====================================

    #auslesen der  key.txt-Datei
    open(KEY,"<key.txt");
    $key = <KEY>;
    close(KEY);

    #Auslesen des securitylevels (Verschlüsselungszahl)
    $security_level= substr($key,0,1);
    #Hashvariable zur Zuordnung der Bit-Zahlen zu den entsprechenden Schlüsseln
    %security_levels = ('1' => '128', '2' => '256', '3' => '512', '4' => '1024', '5' => '2048', '6' => '4096', '7' => '8192', '8' => '16384');
    $security_level_value = $security_levels{$security_level}; #VS-Zahl in $security_level_value gespeichert
    print "svl: $security_level_value";

    #Auslesen der Rotationsvariablen über substr. (Rot. V sind die ersten zwei Ziffern des Key's)
    $rot = substr($key,1,2);
    $rest= substr($key,3,35);
    print $rest;

     #Schleife zur Bestimmung der Insert-Blocks   :
     #Der Insert-Block wird als Element in einem Array ($lock_block[x]) gespeichert.
     #Dafür wird ein Substring aus dem Rest des Schlüssels mit einer Länge von 5 Zeichen genommen. Startpunkt beginnt bei 0 und wird pro Durchlauf um 5 erhöht.

    #Definition Parameter für folgende Schleife
    $start_count_lb =0;
    @lock_block = ('0','1');
    do{
       $lock_block[$count_lb] = substr($rest,$start_count_lb,5);
       $start_count_lb = $start_count_lb+5;
       print $lock_block[$count_lb];
       $count_lb = $count_lb+1;
}until($count_lb == 7);


#VERSCHLÜSSELUNG
#=================================

if($direction eq "v"){ #Wenn direction = v...

    #Öffnen der Textdatei und Speicherung in der Variablen @locktext
    open(MSG, "<lock.txt");
    @locktext = <MSG>;
    close(MSG);

    #Speicherung des Textes in einem Array, sodass jedes Zeichen = $lock_text_array[x]
    $lock_text_string = join("",@locktext);
    $lock_text_string =~s/\n/]/g;
    $length_of_text = length($lock_text_string);
    @lock_text_array =split(//,$lock_text_string);

    $count_lta = 0;

    do{
        #Abfrage der Zeichnenummer aus der Subroutine Hashtable und generierung der Rot-Zeichen-Nummer.
        #In $lock_string wird das aktuelle Zeichen aus $lock_text_array[$count_lta] gespeichert.
        #In $rot_lock[$count_lta] wird aus der Subroutine, einer Hashfunktion die Zeichennummer abgefragt, dafür wird $lock_string an die Subroutine übergeben.
        $lock_string = $lock_text_array[$count_lta];
        $rot_lock[$count_lta]=&rotation_lock($lock_string);

        #Anschließend wird die rotierte Lock-Zahl generiert.
        #Sollte diese größer 70 seinm greift der unten stehende Algoritmus, der bewirkt, dass ab 71 wieder mit 1 angefangen wird.
        if ($rot_lock[$count_lta] +$rot <=70) {
            $rot_lock[$count_lta] = $rot_lock[$count_lta]+ $rot;
        }
        else{
            $rot_lock[$count_lta] = ($rot_lock[$count_lta]+ $rot)-71;
        }
         print $rot_lock[$count_lta];

        #Generierung einer Binärzahl aus der Rot-Zahl
        #Die Zahl zwei wird hoch $index genommen.
        #ist das Ergebnis kleiner als die Dezimalzahl, so ist diese Stelle der Binärzahl mit 1 besetzt. Ist es größer mit 0.
        #Auf diese weise werden durch verkleinerung von $index um 1 und vergrößerung von $postion um 1 alle 7 Stellen der Binärzahl (2^6,2^5...2^0) durchlaufen
        $figure = $rot_lock[$count_lta];
        @binary_figure = ('0','0','0','0','0','0','0',);
        $index = 6;
        $position = 0;
        do{
            $check = 2**$index;
            if ($check <= $figure) {
                $binary_figure[$position] = 1;
                $figure = $figure - $check;
            }
            else{
                $binary_figure[$position] = 0;
            }
            $position = $position +1;
            $index = $index-1;

        }until($position == 7);

        print @binary_figure;

        $waste_position = 0;
        @crypt = ('1','0');

        #Generierung von zufälligen 1en und 0en über die rand-Funktion. (Zahlen zwischen 0 und 2 werden abebrochen)
        #Speicherung jeder einzelnen Ziffer im Element $crypt[$waste_position]
        #Vergrößerung von $waste_position
        do{
            $rand_waste = rand(2);
            $crypt[$waste_position]= int($rand_waste);
            $waste_position = $waste_position +1;
        }until($waste_position == $security_level_value);
        $lock_count = 0;

        #Einsetzung der einzlenen Ziffern gemäß den im key definierten Postionen.
        #$lock_count dient als Schalter zum zählen der Einsetzungen
        do{
            $crypting_postion = $lock_block[$lock_count];
            $crypt[$crypting_postion] = $binary_figure[$lock_count];
            $lock_count = $lock_count+1;
        }until($lock_count == 7);

        #Speicherung in einer String-Variablen und anschließende Einsetzung der String als Element eines Arrays, indem der Gesamttext steht
        $crypted = join("",@crypt);
        #print $crypted;
        $crypted_message[$count_lta]= $crypted;

        $count_lta = $count_lta+1;
    }until($count_lta == $length_of_text);

    #Speicherung in einer Datei mit dem Namen locked.txt
    open(CRYPTTEXT,">locked.txt");
    print CRYPTTEXT @crypted_message;
    close CRYPTTEXT;
}

#ENTSCHLÜSSELUNG
#=============================

elsif($direction eq "e"){

    #Öffnen der Datei "unlock.txt" und Speicherung in einer Array-Variablen (@unlock)
    open(DECRYPT,"<unlock.txt");
    @unlock = <DECRYPT>;
    close(DECRYPT);

    #Umschreiben der Array-Variablen in eine String-Variable
    $crypted_text = join("",@unlock);

    #Bestimmung der Länge des Verschlüsselten Textes und der Anzahl der Zeichen, indem die Gesamtlänge durch das S-Level geteilt wird.
    $crypto_length = length($crypted_text)-1;
    $end = $crypto_length/$security_level_value;
    $end = int($end);

    #Auslesen der einzelnen Verschlüsselungsblöcke
    #Die Blöcke werden als Elemente von @crypt_blocks gespeichert. Dafür wird zuerst vom Start ein Substring mit Schrittweite entpsprechend der Blocklänge gebildet.
    #Anschließend Bestimmung der Restlänge und entfernung des vordersten Blocks.
    #Erhöhung des Schalters $cb_count um 1, wiederholung des Vorgangs, bis alle Blöcke eingelesen sind.
    do{
        $crypt_blocks[$cb_count] = substr($crypted_text,0,$security_level_value);
        $text_length = length($crypted_text);
        $substring_parameter = $text_length - $security_level_value;
        $crypted_text = substr($crypted_text,$security_level_value,$substring_parameter);
        $cb_count = $cb_count +1;

    }until($cb_count == $end);

    #Generierung der Binärzahlen
    #Aus dem Block wird die Binärzahl ausgelesen. Dazu wird aus dem Block für jedes $lock_block ein Substring von 1 gezogen umd die entsprechende Stelle der Binärzahl zu erhalten.
    do{
        #Definition Schalter
        $binary_position = 0;
        $lb_count = 0;
        do{

            $binary[$binary_position] = substr($crypt_blocks[$cb_number],$lock_block[$lb_count],1);
            $binary_position = $binary_position +1;
            $lb_count = $lb_count +1;
        }until($lb_count == 7);

    #Speicherung der Binärzahl als String
    $complete_binary = join("",@binary);

    #Generierung der Dezimalzahl aus der Binärzahl
    #Festlegung Parameter/Schalter
    $bv_index = 6;
    $bva_index = 0;
    $decimal = 0;
    do{
        #Das Binärzahlarray wird komplett Zifferweise durchlaufen.
        #Ist eine Ziffer eine 1, so wird die entsprechende 2er-Potenz gebildet und zur bisherigen Summe addiert.
        #Ist eine Ziffer eine 0, so wird $add = 0, es wird also nichts dazu addiert.
        #print $binary[7];
        if ($binary[$bva_index] == 1) {
            $add = 2**$bv_index;
        }
        else{
            $add = 0;
        }
        $decimal = $decimal+$add;

        #Addition bzw. Subtraktion der Schalter
        $bv_index = $bv_index -1;
        $bva_index = $bva_index +1;
    }until($bv_index < 0);

    #Entschlüsselung der Rotation:
    #Wenn die generierte Dezimalzahl abzüglich der Rotationszahl <0 ist, so greift der if-Teil:
    #Das negative Ergebnis wird mit 71, dadurch beginnt man nach 0 wieder bei 70.
    #Wenn die generierte Dezimalzahl abzüglich der Rotationszahl = 0 ist, wird einfach nur die Differenz gebildet.
    if ($decimal-$rot < 0) {
        #print $decimal;
        #print $rot;
        $antirot = $decimal - $rot +71;
    }
    else{
        $antirot = $decimal - $rot;
    }
    #Ausgabe des urspünglichen Zeichens:
    #Mit Hilfe der Subroutine "unlock" wird aus einer Hashfunktio das entsprechende Zeichen ausgelsen, und in $decrypted_text[$cb_number] gespeichert.
    $decrypted_text[$cb_number] = &unlock($antirot);
    print $decrypted_text[$cb_number];
    print $cb_number;

    #Addition von $cb_number mit 1 und Wiederholung des Verfahrens mit dem nächsten Block.
    $cb_number = $cb_number +1;

    }until($cb_number == $end);
    $decrypted_message = join('',@decrypted_text);
    $decrypted_message =~s/]/\n/g;

    #Ausgabe der entschlüsselten Nachricht auf Bildschirm
    print "Die entschlüsselte Nachricht lautet:";
    print  $decrypted_message;
    print "Moechten Sie diese Nachricht speichern? (y/n)";
    $save_msg = <STDIN>;
    chomp $save_msg;

    if ($save_msg eq "y") {
        #Abfrage des Dateinamens
        print "Unter welchem Dateinamen soll das entschluesselte Ergebnis gespeichert werden?";
        $file_name = <STDIN>;
        chomp $file_name;

        #Speicherung in der Datei
        open(UNLOCKED,">$file_name.txt");
        print UNLOCKED $decrypted_message;
        close(UNLOCKED);
        print "Nachricht als >>$file_name.txt<< gespeichert";
    }

}


#PASSWORTGENERATOR
#=======================
else{
    #Abfrage der Passwortlänge
    print "How many characters should the password have?";
    $pw_length = <STDIN>;
    chomp $pw_length;

    #Generierung des Passwortes:
    #Eine Zufallszahl wird gebildet (zwischen 0 und 71)
    #Aus der Unlock-Subroutine wird das entsprechende Zeichen entnommen
    #Wird in Array gepseichert
    do{
        $random = rand(71);
        $random = int($random);
        $key_sign[$ks_count] = &unlock($random);
        $ks_count = $ks_count +1;
    }until($ks_count == $pw_length);

    #Ausgabe des Passwortes in der Datei Passwort.txt
    open(PW,">password.txt");
    print PW @key_sign;
    close(PW);
}

print "Any input to leave the program";
$exit_programm = <STDIN>;

exit;