RC4-Chiffre (funktioniert eingeschränkt)

Master1991

Mitglied
Hi, habe den nachfolgenden Quelltext erzeugt (Quelle ist der Wikipedia PseudoCode).

Der Code verschlüsselt einen Text mithilfe des RC4 Algorithmus, dies Funktioniert zwar auch aber das verschlüsselte Text verwendet alle ASCII zeichen.

Wenn ich das gleiche bei anderen RC4 algorithmen eingebe kommen jedoch nur Buchstabe und Zahlen heraus, statt kryptische Sonderzeichen die nicht einmal CopyPast bar sind.

Wo liegt das Problem?

Java:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package rc4.chiffre;

import java.util.ArrayList;
import java.util.Scanner;

/**
 *
 * @author ...
 */
public class RC4Chiffre {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        String userDefinedPassphrase;
        Scanner sc = new Scanner(System.in);
        ArrayList<Character> plain = new ArrayList<>();
        ArrayList<Character> passphrase = new ArrayList<>();
        ArrayList<Character> userTextArray = new ArrayList<>();
        ArrayList<Character> ergebnis = new ArrayList<>();

        
        System.out.print("Zu verschluesselnder Text: ");
        userTextArray = StringToCharacterArray(sc.nextLine());
        System.out.print("Zu verwendender Passphrase: ");
        userDefinedPassphrase = sc.nextLine();
        passphrase = StringToCharacterArray(userDefinedPassphrase);
        
        ergebnis = rc4(sbox(passphrase), userTextArray);
        System.out.println();
        System.out.print("Encrypted: ");
        for (Character ergebni : ergebnis) {
            System.out.print(ergebni);
        }
        System.out.println("\n");
        System.out.print("Zum Entschluesseln Passphrase eingeben: ");
        userDefinedPassphrase = sc.nextLine();
        passphrase = StringToCharacterArray(userDefinedPassphrase);
        
        System.out.println();
        ergebnis = rc4(sbox(passphrase), ergebnis);
        System.out.print("Decrypted: ");
        for (Character ergebni : ergebnis) {
            System.out.print(ergebni);
        }
        System.out.println();
    }

    public static ArrayList<Character> sbox(ArrayList<Character> passphrase) {
        int l = passphrase.size();
        char tempChar;
        ArrayList<Character> s = new ArrayList<>();

        for (int i = 0; i <= 255; i++) {
            s.add((char) i);
        }
        int j = 0;
        for (int i = 0; i <= 255; i++) {
            j = (j + s.get(i) + passphrase.get(i % l)) % 256;
            //vertauschen
            tempChar = s.get(i);
            s.set(i, s.get(j));
            s.set(j, tempChar);
        }
    return s;
   //k[]: gegebene Schlüssel-Zeichenfolge der Länge 5 bis 256 Byte
    //L := Länge des Schlüssels in Byte
    //s[]: Byte-Vektor der Länge 256
    //Für i = 0 bis 255     
    //s[i] := i
    //j := 0
    //Für i = 0 bis 255
    //j := (j + s[i] + k[i mod L]) mod 256
    //vertausche s[i] mit s[j]
}

public static ArrayList<Character> rc4(ArrayList<Character> s,ArrayList<Character> plain){
        ArrayList<Character> encrypted = new ArrayList<>();
        char tempChar;
        int randomNumber,xor;
        int i = 0;
        int j = 0;
        
        for (int l = 0; l < plain.size(); l++) {
            encrypted.add((char) l);
        }
        
        for(int k = 0; k<plain.size(); k++){
            i = (i+1)%256;
            j = (j+ s.get(i))%256;
            //vertauschen
            tempChar = s.get(i);
            s.set(i, s.get(j));
            s.set(j, tempChar);
            randomNumber = s.get((s.get(i)+s.get(j))%256);
            xor = randomNumber^plain.get(k);
            encrypted.set(k,(char)xor);
        }
        return encrypted;
        
    // klar[]: gegebene Klartext-Zeichenfolge der Länge X
    // schl[]: Vektor zum Abspeichern des Schlüsseltextes
    // i := 0
    // j := 0
    // Für n = 0 bis X-1
    //   i := (i + 1) mod 256
    //   j := (j + s[i]) mod 256
    //   vertausche s[i] mit s[j]
    //   zufallszahl := s[(s[i] + s[j]) mod 256]
    //   schl[n] := zufallszahl XOR klar[n]   
    }

    private static ArrayList<Character> StringToCharacterArray(String passphrase) {
        ArrayList<Character> passphraseArray = new ArrayList<Character>();
        for (char c : passphrase.toCharArray()){
            passphraseArray.add(c);
        }
        
        return passphraseArray;
}
    
}
 
Ohne deinen Code sorgfältig gelesen zu haben... Viell liegts am encoding der anderen Chiffre, also die RC4-chiffre erzeugt einen bytestream ("nicht copy-paste -bar" xD) , der in hex darstellung ausgegeben wird ?!
 
Also momentan sieht es so aus, das er den eingegebenen Text als ASCII zeichen Interpretiert, jedefalls bin ich davon ausgegangen das Java(Netbeans) Standard Char ASCII ist?!

Wenn dem nicht so ist liegt dort der Hase im Pfeffer begraben.

Ich hab die Ausgabe nun auf Hex geändert, so sieht es schonmal wesentlich schöner aus.

Nach wie vor geht allerdings die Verschlüsselung von Sonderzeichen (zB 'ä' nicht richtig).

Ist das Java ASCII 7Bit? Das ä wäre über 127...Das wäre zumindest eine erklärung...

Wenn dem so ist: Kann ich Java (Netbeans) sagen er soll 8Bit ASCII verwenden?
 
Ne, die jvm verwendet standardmäßig UTF-8
Also 255 Verschiedene Zeichen...

Aber klar kann man die Charsets ändern...
Einfach mal in der Doku nach Charsets suchen 🙂
 
Klär mich auf, eine der beiden Aussagen ist falsch. UTF-8 hat doch etwas mehr als 255 Zeichen

Also ein JVM char entspricht intern einen unsignierten Byte also acht bit => 0 - 255 Mögliche Zeichen
Die JVM codiert standartmäßig Unicodezeichen in UTF-8 Format...

UTF-8 ist eine Art der Zeichenkodierung in 1-4 byte...
Ein char enspricht dem ersten byte im UTF-8 format....

Jetzt klarer?
 
Noch nicht ganz. UTF-8 kodiert nur 7 Bits der 8 vorhandenen. Das erste Bit ist konstant 0 (im ersten Block). Somit hast du nur 127 mögliche Zeichen. Was wiederum dem ASCII-Standard entspricht.
 
Zuletzt bearbeitet:

Neue Themen


Zurück
Oben