Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

DES falsche ASCII werte bei decodierung

Werbeanzeige

Task-Manager

Alter Hase

  • »Task-Manager« ist der Autor dieses Themas

Beiträge: 1 087

Wohnort: am PC

Beruf: Student

  • Private Nachricht senden

1

06.03.2010, 18:03

DES falsche ASCII werte bei decodierung

Hi ich poste hier mal meinen DES Key (nur die relevaten Teile)
bei der Decodierung kommen immer falsche ASCII werte heraus :(

Codier-Klasse

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//Includes 

import java.awt.*; 
import java.awt.event.*; 
import javax.swing.*; 

//Main-Klasse 

public class Codierer extends JFrame implements ActionListener 
{ 
    //GUI-Variablen 

    private JLabel lStatus, lKlartext, lGeheimtext, lKey; 
    private JTextField tKey; 
    private JTextArea tKlartext, tGeheimtext; 
    private JButton bCodiere; 
    
    //---- Initialisierung ------------------------------------------------ 

    public Codierer() 
    { 
        //---- GUI -------------------------------------------------------- 

           ... 
        //----------------------------------------------------------------- 

    } 
    //--------------------------------------------------------------------- 

    
    //---- Die erste Codier Klasse ---------------------------------------- 

    public void MainCodiere() 
    { 
        String sKey  = tKey.getText();  //String wird mit dem key gefüllt 

        
        //führt die klasse mit dem Paritäts-check aus 

        if(MakePariCheck(sKey) == false)    
        { 
            //wenn die Paritäts-klasse false liefert stimmen die Bits nicht 

            lStatus.setText("Key: Paritätsbits nicht korrekt!");    
        } 
        else 
        { 
            //Überprüfung gelungen! Zweite Codier Klasse wird ausgeführt 

            lStatus.setText("Wird verschluesselt"); 
            SubCodiere(sKey);                        
        } 
    } 
    //----------------------------------------------------------------------- 

    
    //---- Zweite Instanz der Codierung ---------------------------------- 

    public void SubCodiere(String sKey) 
    {      
        String sKlartext = tKlartext.getText();    //der Klartext wird als String gespeichert        


        //Solange der Klartext nicht durch 8 teilbar ist leerzeichen anfügen 

        while(sKlartext.length()%8 != 0)    
        { 
            sKlartext = sKlartext + " "; 
        } 
        
        //Solange der Klartext noch zeichen beinhaltet 

        while(sKlartext.length() > 1) 
        {    
            String sBuffer = "";                                        //Buffer erstellen 

            String block = "";                                          //Block erstellen 

            sBuffer = sKlartext.substring(0,8);                         //Block mit den ersten 8 zeichen füllen 

            sKlartext = sKlartext.substring(8, sKlartext.length());     //Block vom klartext abziehen 

            
            //Durchläuft den Block 

            for(int i = 0; i<8; i++) 
            { 
                int iBuffer;        //speichert die ASCII werte 

                String binary;      //speichert die ASCII werte als String 

                
                iBuffer = (int)sBuffer.charAt(i);           //ASCII wert wird ausgelesen 

                binary = Integer.toBinaryString(iBuffer);   //und als Binär string gespeichert 

                
                //füllt den BinärString auf, falls die Zahl zu klein war 

                while(binary.length() < 8) 
                { 
                    binary = "0" + binary; 
                } 
                
                block = block + binary; //fügt alle Binärstrings zusammen 

            } 
            //Der Block und der Key werden in die zweite UnterInstanz der Codierung geschickt    

            SubCodiere2(block,sKey); 
        }        
    } 
    //------------------------------------------------------------------ 

    
    //---- Zweite Unterinstanz der Codierung --------------------------- 

    public void SubCodiere2(String block, String key) 
    { 
        block = IP(block);                          //Block wird der IP unterzogen 

        String roundKey = PCone(key);               //roundKey wird der PC-1 unterzogen 

        String lKey = roundKey.substring(0,28);     //lKey wird aus dem roundKey gesplittet 

        String rKey = roundKey.substring(28,56);    //rKey wird aus dem roundKey gesplittet 

        String lBlock = block.substring(0,32);      //lBlock wird aus dem Block gesplittet 

        String rBlock = block.substring(32,64);     //rBlock wird aus dem BLock gesplittet 

        String result = "";                         //Ergebnis string 

        
        //Die 16 Runden 

        for(int i = 0; i<16; i++) 
        { 
            String buffer;                          //buffer für den switch von l und rBlock 

            rKey = Shift(rKey, i);                  //rKey wird geshiftet 

            lKey = Shift(lKey, i);                  //lKey wird geshiftet 

            roundKey = lKey + rKey;                 //roundKey wird aus lKey und rKey zusammengesetzt 

            roundKey = PCtwo(roundKey);             //roundKey wird der PC-2 unterzogen 

            buffer = FunktionF(lBlock, roundKey);   //FunktionF wird mit lBlock und roundKey durchgeführt 

            buffer = XOR(rBlock, buffer);           //XOR mit dem Erebnis der FunktionF und dem rBlock 

            
            //fals nicht runde 15 Blöcke tauschen 

            if(i != 15) 
            { 
                rBlock = lBlock;                    //neuer rBlock = alter lBlock 

                lBlock = buffer;                    //neuer lBlock = ergebnis aus dem XOR 

            } 
            else 
            { 
                rBlock = buffer;                    //in der letzen runde bleibt der rBlock der rBlock! 

            } 
        } 
        
        result = lBlock + rBlock;       //Ergebnis wird aus l und rBlock zusammengefügt 

        result = FP(result);            //Ergebnis wird der FP unterzogen 

        
        tGeheimtext.setText(tGeheimtext.getText() + result);    //Ergebnis wird an den Geheimtext angefügt 

    } 
    //-------------------------------------------------------------------- 

    
    //---- Die Funktion F -------------------------------------------------------- 

    public String FunktionF(String block, String key) 
    { 
        String buffer  = "";        //Bufer erstellen 

        String back = "";           //Rückgabewert erstellen 


        block = EP(block);          //Block wird der EP unterzogen 

        buffer = XOR(block, key);   //XOR wird mit dem Block und dem Key durchgeführt 


        //buffer wird in 8 Teile zerlegt 

        for(int i = 0; i<8; i++) 
        { 
            String s = buffer.substring(i*6,i*6+6); //neue Strings aus dem Buffer á 6 stellen 

            s = Box(s,i+1);                         //Strings werden in die Betrefenden Boxen geschickt 

            back = back+s;                          //Strings werden an den Rückgabe String angefügt 

        } 
        
        back = P(back);     //Rückgabe String wird P unterzogen 


        return back;      
    }    
    //------------------------------------------------------------------------------ 

}


Decodier-Klase

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//Includes 

import java.awt.*; 
import java.awt.event.*; 
import javax.swing.*; 

//Main-Klasse 

public class Decodierer extends JFrame implements ActionListener 
{ 
    //GUI-Variablen 

    private JLabel lStatus, lKlartext, lGeheimtext, lKey; 
    private JTextField tKey; 
    private JTextArea tKlartext, tGeheimtext; 
    private JButton bDecodiere; 
    
    //---- Initialisierung ------------------------------------------------ 

    public Decodierer() 
    { 
        //---- GUI -------------------------------------------------------- 

       ... 
     } 
    
    //---- Die erste Decodier Klasse -------------------------------------- 

    public void MainDecodiere() 
    { 
        String sKey = tKey.getText();                   //Key als string 

        String sGeheimtext = tGeheimtext.getText();     //Geheimtext als String 

        
         //führt die klasse mit dem Paritäts-check aus 

        if(MakePariCheck(sKey) == false)    
        { 
            //wenn die Paritäts-klasse false liefert stimmen die Bits nicht 

            lStatus.setText("Key: Paritätsbits nicht korrekt!");    
        } 
        else 
        { 
            //Überprüfung gelungen! Zweite Codier Klasse wird ausgeführt 

            lStatus.setText("Wird entschluesselt"); 
            
            //Solange Geheimtext nicht leer ist 

            while(sGeheimtext.length() > 1) 
            {    
                String block = ""; 
                //Block erzeugen 

                block = sGeheimtext.substring(0,64);      
                //Block abziehen von dem Geheimtext 

                sGeheimtext = sGeheimtext.substring(64, sGeheimtext.length()); 
                //mit dem Block und dem Key die zweite Instanz der Decodiere Klasse aufrufen 

                SubDecodiere(block, sKey); 
            }                      
        } 
    } 
    //----------------------------------------------------------------------- 

    
    //---- Die Unterinstanz von Decodieren ------------------------------- 

    public void SubDecodiere(String block, String key) 
    { 
        block = IP(block);                          //Block wird der IP unterzogen 

        String roundKey = PCone(key);               //der roundKey wird der PC-1 unterzogen 

        String lKey = roundKey.substring(0,28);     //lKey wird aus dem roundKey gesplittet 

        String rKey = roundKey.substring(28,56);    //rKey wird aus dem roundKey gesplittet 

        String lBlock = block.substring(0,32);      //lBlock wird aus dem Block gesplittet 

        String rBlock = block.substring(32,64);     //rBlock wird aus dem Block gesplittet 

        
        String result = "";                         //Ergebnis 

        
        String sKeyBuffer[] = new String[16];       //String um die runden Keys zu speichern 

        String sResult[] = new String[8];           //String-Array um den Block in die 8 zeichen Blöcke aufzuteilen  

        int iResult[] = new int[8];                 //Int-Array um die convertieren Binär-Codes zu speichern 

        char cResult[] = new char[8];               //Char-Array um die Zahlen in die einzelnen ASCII zeichen zu convertieren 

        
        int counter = 15;                           //counter für die runden Keys wird auf 15 gesetzt 

        
        //die Keys werden generiert und im sKeyBuffer-Array gespeichert 

        for(int j = 0; j<16; j++) 
        { 
            rKey = Shift(rKey, j);          //rKey wird verschoben 

            lKey = Shift(lKey, j);          //lKey wird verschoben 

            roundKey = lKey + rKey;         //roundKey wird zusammengesetzt 

            roundKey = PCtwo(roundKey);     //roundKey wird der Permutation 2 unterzogen 

            sKeyBuffer[j] = roundKey;       //roundKey wird im Array gespeichert 

        } 
        
        //die 16 Runden 

        for(int i = 0; i<16; i++) 
        { 
            roundKey = sKeyBuffer[counter];         //Key an der Stelle des Counters wird ausgelesen 

            String buffer;                          //Buffer wird erstellt 

            buffer = FunktionF(lBlock, roundKey);   //FunktionF wird mit lBlock und dem rundenKey durchgeführt 

            buffer = XOR(rBlock, buffer);           //XOR wird mit dem rBlock und dem Ergebnis der FuntkonF durchgeführt 

            
            //fals nicht runde 15 Blöcke tauschen 

            if(i != 15) 
            { 
                rBlock = lBlock;                    //neuer rBlock = alter lBlock 

                lBlock = buffer;                    //neuer lBlock = ergebnis aus dem XOR 

            } 
            else 
            { 
                rBlock = buffer;                    //in der letzen runde bleibt der rBlock der rBlock! 

            } 
            
            counter--;                              //counter für die Keys wird zurückgezählt 

        } 
        
        result = lBlock + rBlock;       //Ergebnis wird aus den Blöcken zusammengefügt 

        result = FP(result);            //Ergebnis wird der FP unterzogen 

        
        // Ergebnis wird in 8 Teil-Blöcke unterteilt 

        for(int k = 0; k<8; k++) 
        { 
            sResult[k] = result.substring(k*8,k*8+8);       //TeilBlock wird gespeichert 

            iResult[k] = Integer.parseInt(sResult[k], 2);   //Binär-Zahl wird als Integer gepseichert 

            cResult[k] = (char)iResult[k];                  //Int-Wert wird als Zeichen gepseichert 

        }      
        
        String sStringBuffer = new String(cResult);     //Alle Zeichen werden zu einem String zusammengefügt 

        result = sStringBuffer;                         //Ergebnis ist der Zeichen-String 

        
        tKlartext.setText(tKlartext.getText()+result);  //An das Gesamt-Ergebnis wird der String angefügt 

    } 
    //-------------------------------------------------------------------- 

    
    //---- Die Funktion F -------------------------------------------------------- 

    public String FunktionF(String block, String key) 
    { 
        String buffer  = "";        //Bufer erstellen 

        String back = "";           //Rückgabewert erstellen 


        block = EP(block);          //Block wird der EP unterzogen 

        buffer = XOR(block, key);   //XOR wird mit dem Block und dem Key durchgeführt 


        //buffer wird in 8 Teile zerlegt 

        for(int i = 0; i<8; i++) 
        { 
            String s = buffer.substring(i*6,i*6+6); //neue Strings aus dem Buffer á 6 stellen 

            s = Box(s,i+1);                         //Strings werden in die Betrefenden Boxen geschickt 

            back = back+s;                          //Strings werden an den Rückgabe String angefügt 

        } 
        
        back = P(back);     //Rückgabe String wird P unterzogen 


        return back;      
    }


Die Permutationen, Substitutionen, und die S-Boxen hab ich im Quelltext rausgelassen, da ich diese Mehrfach extern geprüft hab (auch aufm Papier) und diese funktionieren...
falls ichs i-wo vergessen hab:

mfg
Task-Manager

Rechtschreibfehler sind mein Eigentum und gewollt!

Task-Manager

Alter Hase

  • »Task-Manager« ist der Autor dieses Themas

Beiträge: 1 087

Wohnort: am PC

Beruf: Student

  • Private Nachricht senden

2

07.03.2010, 10:25

OK jetzt wirds richtig lustig!

der Quelltext funktioniert, aber nur bedingt. bei eingaben wie "Mathe ist super" kommt meistens nur "Mathe ist supur" raus. Anscheinend ist das aber stark Key abhängig :/ bei manchen Keys kommt anähernd das raus, was soll, bei manchen funktionierts einfach gar nicht-.-
falls ichs i-wo vergessen hab:

mfg
Task-Manager

Rechtschreibfehler sind mein Eigentum und gewollt!