Vigenere Verschlüsselung funktioniert nicht richtig

[Lazybone]

Hallo

ich habe mich mal an eine Vigenere Verschlüsselung gemacht. Hier erstmal die beiden Methoden zum Ver bzw Entschlüsseln

    public static String code(String NText, String code) {
        
        StringBuilder ctext = new StringBuilder();
        for(int i = 0, a = 0; i < NText.length(); i++) {
            char key = code.toUpperCase().charAt(a%code.length());
            char aCh = NText.toUpperCase().charAt(i);
            char nCh = ' ';
            if(aCh >= 65 && aCh <= 90) {
                nCh = (char)(aCh - 65 + key);
                if((int)nCh > 90){
                    nCh -= 26;
                }
                if(NText.charAt(i) >= 97){
                    nCh += 32;
                }
                ctext.append(nCh);
                a++;
            }else{
                ctext.append(aCh);
            }
            
        }
        return ctext.toString();
    }
    
    public static String decode(String NText, String code) {
        StringBuilder ctext = new StringBuilder();
        StringBuilder btext = new StringBuilder();
        for(int i = 0, a = 0, b = 0; i < NText.length(); i++) {
            
            char key = code.toUpperCase().charAt(a%code.length());
            char aCh = NText.charAt(i);
            char nCh = ' ';
            if(aCh >= 65 && aCh <= 90) {
                aCh = NText.toUpperCase().charAt(i);
                nCh = (char)(aCh + 65 - key);
                if((int)nCh < 65){
                    nCh += 26;
                }
                if(NText.charAt(i) >= 97){
                    nCh += 32;
                }
                ctext.append(nCh);
                a++;
            }else if(aCh >= 97 && aCh <= 122){
                aCh = NText.toUpperCase().charAt(i);
                nCh = (char)(aCh + 97 - key);
                if((int)nCh < 97){
                    nCh += 26;
                }
                ctext.append(nCh);
                a++;
            }else{
                ctext.append(NText.charAt(i));
            }
        }
        return ctext.toString();
    }

Die Verschlüsselung funktioniert einwandfrei. Bei der Entschlüsselung gibt es allerdings noch probleme undzwar funktioniert die am Anfang sehr gut nur nach ner Zeit macht Sie nurnoch unsinn. Ich habe es mal mit den folgenden Text probiert.

CrypTool ist ein Programm, mit dessen Hilfe Sie kryptografische Verfahren anwenden und 
analysieren können. So können Sie neue Dokumente erstellen und bestehende Dokumente 
öffnen und weiter bearbeiten. 
Ein Dokument kann mittels verschiedener Verschlüsselungsverfahren ver- und entschlüsselt 
werden. Es stehen sowohl klassische (zum Beispiel das Caesar-Verschlüsselungsverfahren) 
als auch moderne Verschlüsselungsverfahren (beispielsweise das RSA- und das DES-Verfahren 
sowie auf elliptischen Kurven basierende Verfahren) zur Verfügung. Eine Übersicht über alle 
Verschlüsselungsverfahren in CrypTool findet man auf der Hilfeseite zum Menü 
Ver-/Entschlüsseln.

Außerdem kann CrypTool von einem Dokument Hashwerte berechnen (siehe Menü Hashwerte). 
Für die klassischen Verschlüsselungsverfahren stehen automatische Analysen zur Verfügung, 
die Sie in die Lage versetzen, mit Kenntnis des verschlüsselten Dokuments und eventuell 
weiterer Informationen (unverschlüsseltes Dokument oder Sprache des Dokuments) den 
Schlüssel zu ermitteln. Für weitere Informationen zur automatischen Analyse gehen Sie zur 
Hilfe für das Menü Analyse und wählen dort das zu analysierende Verschlüsselungsverfahren.

Zur Unterstützung der eigenen Analyse von Dokumenten kann CrypTool von einem Dokument 
das Histogramm anzeigen und die Entropie und Autokorrelation berechnen.
Ferner gibt es in CrypTool die Möglichkeit, Dateien zu packen oder entpacken (ZIP).

VvqiMsge bwl xbr Hkhkjtfq, ebm hwllif Abpxx Lmw dkchmhkjtymkvai Nxkjsakif tgawgwif ngh 
sgtpqlbijxg oöfgxr. Kh dörfxg Wax gimx Wscnfifmx ijlmidexr mgw fwlmizxghw Whomfxrlx 
öyjfxg yfw piamxv txtvtxbxwg. 
Xmf Whomfxrl dtrf fbxlxew nxkwuabivxgij Oxvkvapüklxpmgzwnxkjsakif oxv- mgw ifmlgzeülwwem 
awkwif. Xl wlxaif lhagae odtlwalvlw (snq Txbwhbxp vtl Gsxlej-Oxvkvapüklxpmgzwnxkjsakif) 
tew snvl ehwijgx Zwklgzeülwwenryloijytljxg (fwbltaxewoxbww wtw JLT- yfw wek WXW-Nxkjsakif 
lhaax tyx xepaimmkvaif Dnvnxg fslbijxghw Oxvxtavwg) syj Oxvxüznry. Xbrw Üuxvkbvll üuxv seei 
Nxkwuaeüwkxeyfzlzwkyezkxr ag VvqiMsge ymfwxx etg emy wij Abpxxliamx dmf Fifü 
Oxv-/Wgmwuaeüwkxer.

Snßxvvxf osgg GjriXghe zgg xmfxf Hgdnqwgm Lslaawkmi txkiuagif (lbizx Fifü Atwzpxvlx). 
Yüv vbx odtlwalvlwg Oijlvldüllidngkkoxvxtavwg lxwaxr snmsetmmkvai Sgtpqlxr rnk Zwkyükmgz, 
hax Lmw bg hax Eeyx oijlxxrxg, qam Difgmral wik oxvkvapüklxplxg Hgdnqwgmw mgw inxgxmxep 
oxbxwkxv Agysjftxahgif (ngzwklgzeülwwemik Whomfxrl hwij Livsvai vxl Hgdnqwgmw) vxg 
Wuaeüwkxe dm xkqammidg. Yüv oxbxwkx Mfyhvetmmggxr rnk emmhqsmbwuaxr Sgtpqlx kwaxr Kbx dmk 
Amdyx jüj wtw Exgü Efteckx nrv päapwg wsjm wek sn efteckbxvwgwi Nxkwuaeüwkxeyfzlzwkyezkxr.

Rnk Yfmxvkmümdmgz hwk xmyxgif Tgedrli nhg Hgdnqwgmif dtrf VkchMhsd ohr wbgie Whomfxrl 
wtw Zblxgzkeef trrxbkwg nrv wbi Wgmvgibi mgw Emmhogkkidtmmgg uijxvlfxg.
Jwkgij zbfl xl mf VkchMhsd wbi Eözemuadiam, Welxbif sn tsvdif hwij xgxhtvowg (SMH).

Schlüssel: test

Der Text ist richtig verschlüsselt worden. Dies geschar mit einem anderen Programm. Ich bekomme den Text nur bis zur hälfte richtig entschlüsselt mit meinen Programm ich finde leider auch nicht den Fehler habe mir auch schon die zwischenschritte ausgeben lassen allerdings ohne erfolg. Würde mich freuen wenn einer eine lösung findet.


//EDIT: Hab festgestellt das sobald ein ß vorkommt er danach nicht mehr zurecht kommt. Kennt da einer ne Lösung das zu beheben hab da leder nichts hinbekommen

Gruß
Lazybone[/code]

 

[Marco13]

So beim ersten Drüberschauen: Sowas

if(aCh >= 65 && aCh <= 90) {

ist natürlich der Killer - die sind für ein "ß" oder für Umlaute einfach nicht erfüllt! So solltest derartige Abfragen durch
Character.isLetter(aCh)
und
Character.isOwerCase(aCh)
machen. Was genau das für Auswirkungen auf die Verschlüsselungsmethode hat, müsstest du dann noch genauer prüfen. Vermutlich wirst du nichtmehr einfach solche Rechnungen wie

if(NText.charAt(i) >= 97){
    nCh += 32;
}

machen können....

 

[Lazybone]

Er soll ja nur A-Z und a-z verschlüsseln alle anderen Zeichen soll er so wieder ausgeben wie er Sie eingelesen hat.

 

[Marco13]

Der Text ist richtig verschlüsselt worden.
Was heißt "richtig" in diesem Fall?
Dies geschar mit einem anderen Programm.
Die Frage, wie das andere Programm mit einem "ß" umgeht, ist ja hierbei nicht ganz unwichtig... Interessant ist zumindest die Ausgabe dieses (compiliererbaren :meld: ) Testprogramms:

import java.util.*;

class Vigenere
{
    public static void main(String args[])
    {
        System.out.println(encode("etAußerdem", "test"));
        System.out.println(decode("xxSnßxvvxf", "test"));
        System.out.println(decode(encode("etAußerdem", "test"), "test"));
    }

    public static String encode(String NText, String code)
    {
        StringBuffer ctext = new StringBuffer();
        for(int i = 0, a = 0; i < NText.length(); i++) {
            char key = code.toUpperCase().charAt(a%code.length());
            char aCh = NText.toUpperCase().charAt(i);
            char nCh = ' ';
            if(aCh >= 65 && aCh <= 90) {
                nCh = (char)(aCh - 65 + key);
                if((int)nCh > 90){
                    nCh -= 26;
                }
                if(NText.charAt(i) >= 97){
                    nCh += 32;
                }
                ctext.append(nCh);
                a++;
            }else{
                ctext.append(aCh);
            }

        }
        return ctext.toString();
    }

    public static String decode(String NText, String code)
    {
        StringBuffer ctext = new StringBuffer();
        StringBuffer btext = new StringBuffer();
        for(int i = 0, a = 0, b = 0; i < NText.length(); i++) {

            char key = code.toUpperCase().charAt(a%code.length());
            char aCh = NText.charAt(i);

            //System.out.println("Input "+NText.charAt(i));

            char nCh = ' ';
            if(aCh >= 65 && aCh <= 90) {
                aCh = NText.toUpperCase().charAt(i);
                nCh = (char)(aCh + 65 - key);
                if((int)nCh < 65){
                    nCh += 26;
                }
                if(NText.charAt(i) >= 97)
                {
                    System.out.println("Passiert nie...");
                    nCh += 32;
                }
                //System.out.println("Output1 "+nCh);

                ctext.append(nCh);
                a++;
            }else if(aCh >= 97 && aCh <= 122){
                aCh = NText.toUpperCase().charAt(i);
                nCh = (char)(aCh + 97 - key);
                if((int)nCh < 97){
                    nCh += 26;
                }
                //System.out.println("Output2 "+nCh);

                ctext.append(nCh);
                a++;
            }else{
                //System.out.println("Not encrypted "+NText.charAt(i));
                ctext.append(NText.charAt(i));
            }
        }
        return ctext.toString();
    }
}

Die Ausgabe ist:

xxSnlwwkwi (das ist das Ergebnis DEINER encode-Methode, wobei die Methode des anderen Programms "xxSnßxvvxf" liefert)
etAußztdce (das ist der Versuch, mit DEINER decode-Methode den Verschlüsselten Text des anderen Programms zu decoden)
etAusserde (das ist eine Hintereinanderausführung DEINER encode/decode-Methoden - ß wird zu ss, aber es funktioniert asatzweise)

Wenn du mit deinem Programm die Ausgabe eines anderen Programms wieder entschlüsseln willst, müßt ihr euch schon "einigen", wie ihr mit einem "ß" umgehen wollt...

 

[Lazybone]

Das ß wird nicht bei der verschlüsselung einbezogen es bleibt so wie es ist genauso wie alle anderen sonderzeichen nur A-Z wird verschlüsselt.

 

[Marco13]

Java ist manchmal doch um einiges schlauer, als einem recht sein kann:
System.out.println("Außerdem".toUpperCase()); // gibt AUSSERDEM aus
d.h. durch deine
aCh = NText.toUpperCase().charAt(i);
zerhaust du dir alles, was nach einem 'ß' kommt (nach einem 'ß' stimmt der Zugriffs-Index 'i' einfach nicht mehr).
Hm. Lösungsansätze gibt's da jetzt einige. Ich überlasse es dir, dir den besten rauszusuchen :bae:

 

[Lazybone]

Danke Marko hab dan mal wieder was dazu gerlernt ^^ ich schau mal das ich ne lösung finde danke

 

[Guest]

So hab ne Lösung gefunden. Poste für andere auch mal den Quellcode

    public static String code(String NText, String code) {
        
        StringBuilder ctext = new StringBuilder();
        for(int i = 0, a = 0; i < NText.length(); i++) {
            
            char key = code.toUpperCase(Locale.getDefault()).charAt(a%code.length());
            char aCh = NText.charAt(i);
            char nCh = ' ';
            
            if(aCh >= 65 && aCh <= 90) {
                aCh = NText.charAt(i);
                nCh = (char)(aCh + key - 65);
                if((int)nCh > 90){
                    nCh -= 26;
                }
                ctext.append(nCh);
                a++;
            }else if(aCh >= 97 && aCh <= 122){
                aCh = NText.charAt(i);
                nCh = (char)(aCh + key - 65 );
                if((int)nCh <= 97){
                    nCh += 26;
                }
                if((int)nCh > 122){
                    nCh -= 26;
                }
                
                ctext.append(nCh);
                a++;
            }else{
                nCh = (char)(aCh);
                ctext.append(nCh);
            }
        }
        return ctext.toString();
    }
    
    public static String decode(String NText, String code) {
        StringBuilder ctext = new StringBuilder();
        
        int a = 0;
        for(int i = 0; i < NText.length(); i++) {
            char key = code.toUpperCase().charAt(a%code.length());
            char aCh = NText.charAt(i);
            char nCh = ' ';
            
            if(aCh >= 65 && aCh <= 90) {
                aCh = NText.charAt(i);
                nCh = (char)(aCh + 65 - key);
                if((int)nCh < 65){
                    nCh += 26;
                }
                if(NText.charAt(i) >= 97){
                    nCh += 32;
                }
                ctext.append(nCh);
                a++;
            }else if(aCh >= 97 && aCh <= 122){
                aCh = NText.charAt(i);
                nCh = (char)(aCh + 65 - key);
                if((int)nCh < 97){
                    nCh += 26;
                }
                ctext.append(nCh);
                a++;
            }else{
                nCh = (char)(aCh);
                ctext.append(NText.charAt(i));
            }
        }
        return ctext.toString();
    }

 

[Marco13]

Schön, dass das dann doch noch geklappt hat

In der Hoffnung, dass das jetzt dann nicht zu diskreditierend wirkt:

            char aCh = NText.charAt(i);
...
            if(aCh >= 65 && aCh <= 90) {
                aCh = NText.charAt(i);
...
                if(NText.charAt(i) >= 97){
                    nCh += 32;
                }
...
            }else if(aCh >= 97 && aCh <= 122){
                aCh = NText.charAt(i);

aCh ändert sich nach der ersten Zuweisung nichtmehr, d.h. die beiden anderen Zuweisungen sind überflüssig, und in der inneren if-Abfrage könntest du auch direkt aCh verwenden - aber die kann sowieso nie erfüllt sein, deswegen wäre da "weglassen" auch eine Alternative...

EDIT: Und wenn diese innere if-Abfrage wegfällt, sind die beiden Äußeren if-Blöcke doch sogar gleich oder...?
EDIT2: Nee, sind sie nicht. Aber fast :roll: