G
Guest
Gast
Hallo zusammen,
ich bin gerade dabei mit Java und Verschlüsselungen herumzuspielen.
Nun habe ich mir ein Programm geschrieben, welches einen String via publicKey verschlüsselt und verschickt. Der Empfänger hat den dazugehörigen privateKey und soll den String wieder entschlüsseln.
Soweit so gut.
Als erstes habe ich ein KeyPair erstellt und private- sowie publicKey gespeichert. Den publicKey habe ich im Netzwerk auf meinen zweiten PC kopiert.
Vielleicht erstmal den Code, damit ihr es euch anschauen könnt ^^
Auf der Sender-Seite:
und auf der Empfängerseite:
So, übertragen tut er schon mal schön. Also ich bekomme als Empfänger den verschlüsselten String mit
richtig angezeigt. Wenn ich jedoch die empfangenen Daten an den Decrypter übergebe, damit er diese wieder entschlüsselt gibt es nur einen leeren String als Rückgabe.
Ich habe mir mal den "byte[] data" angeguckt. Er hat meistens eine Länge von 128 (genau so wie der String eine Länge von 128 Zeichen hat,wenn ich ihn aus den Datenbytes erstelle. Angezeigt werden jedoch immer weniger).
Die Länge des vom Versende verschickten Strings liegt meist um die 120 Zeichen.
Ich denke also, dass der Byte-Array nicht die korrekte Größe annimmt sondern die größe der nächsten 2er-Potenz.
Kann das sein? Oder hat irgendwer eine Idee, wo der Fehler sonst liegen kann?
Ich würde mich sehr freuen, wenn ihr mir trotz des umfangreichen Quelltexts und Problem, helfen könnten.
Vielen Dank schon mal im Voraus
ich bin gerade dabei mit Java und Verschlüsselungen herumzuspielen.
Nun habe ich mir ein Programm geschrieben, welches einen String via publicKey verschlüsselt und verschickt. Der Empfänger hat den dazugehörigen privateKey und soll den String wieder entschlüsseln.
Soweit so gut.
Als erstes habe ich ein KeyPair erstellt und private- sowie publicKey gespeichert. Den publicKey habe ich im Netzwerk auf meinen zweiten PC kopiert.
Vielleicht erstmal den Code, damit ihr es euch anschauen könnt ^^
Auf der Sender-Seite:
Code:
public class Main {
public static void main(String[] args) throws Exception{
Encrypter en = new Encrypter();
Writer wr = new Writer();
String data = "test";
byte[] encData = en.encrypt(data);
wr.write(encData);
}
}
----------------------------------------------------------------------------------------
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class Writer {
public void write(byte[] data) {
try {
// eine Nachricht wird an den Server geschickt
InetAddress ia = InetAddress.getByName("192.168.2.5");
DatagramPacket packet = new DatagramPacket(data, data.length, ia,
4711);
DatagramSocket dgSock = new DatagramSocket();
dgSock.send(packet);
} catch (Exception e) {
e.printStackTrace();
}
}
}
---------------------------------------------------------------------------------------------
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.security.PublicKey;
import javax.crypto.Cipher;
import javax.crypto.CipherOutputStream;
public class Encrypter {
File publicKeyFile;
PublicKey publicKey;
Cipher cipher;
public Encrypter(){
try{
publicKeyFile = new File("public.key");
publicKey = readPublicKey(publicKeyFile);
cipher = Cipher.getInstance("RSA");
}
catch(Exception e){
e.printStackTrace();
}
}
public byte[] encrypt(String data){
try{
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
ByteArrayOutputStream baosEncryptedData = new ByteArrayOutputStream();
CipherOutputStream cos = new CipherOutputStream(baosEncryptedData,cipher);
cos.write(data.getBytes("UTF-8"));
cos.flush();
cos.close();
return baosEncryptedData.toByteArray();
}
catch(Exception e){
e.printStackTrace();
}
return null;
}
private PublicKey readPublicKey(File file) throws Exception {
ObjectInputStream objectInputStream = new ObjectInputStream(
new FileInputStream(file));
PublicKey publicKey = (PublicKey) objectInputStream.readObject();
objectInputStream.close();
return publicKey;
}
}und auf der Empfängerseite:
Code:
public class MainListener {
public static void main(String[] args) {
Decrypter d = new Decrypter();
Listener l = new Listener(d);
l.run();
}
}
---------------------------------------------------------------------------
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.security.InvalidKeyException;
import java.security.PrivateKey;
import java.security.PublicKey;
import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
public class Decrypter {
File privateKeyFile;
PrivateKey privateKey;
Cipher cipher;
private PrivateKey readPrivateKey(File file) throws Exception {
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
PrivateKey privateKey = (PrivateKey)objectInputStream.readObject();
objectInputStream.close();
return privateKey;
}
// Methode zum entschlüsseln einer verschlüsselten Nachricht
String decrypt(byte[] encryptedData){
try{
privateKeyFile = new File("private.key");
privateKey = readPrivateKey(privateKeyFile);
cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
CipherInputStream cis = new CipherInputStream(new ByteArrayInputStream(encryptedData), cipher);
ByteArrayOutputStream baosDecryptedData = new ByteArrayOutputStream();
byte[] buffer = new byte[8192];
int len = 0;
while ((len = cis.read(buffer)) > 0) {
baosDecryptedData.write(buffer, 0, len);
}
baosDecryptedData.flush();
cis.close();
return new String(baosDecryptedData.toByteArray(), "UTF-8");
}catch(Exception e){
e.printStackTrace();
return new String("FAIL");
}
}
}
---------------------------------------------------------------------------
import java.net.DatagramPacket;
import java.net.DatagramSocket;
public class Listener {
Decrypter d;
public Listener(Decrypter d){
this.d = d;
}
public void run(){
try {
DatagramSocket client = new DatagramSocket(4711);
while (true) {
DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
// Es wird auf eintreffende Nachrichten/Pakete gewartet
client.receive(packet);
System.out.println("recieved");
byte[] data = packet.getData();
String encData = new String(data, 0, packet.getLength());
String decData = d.decrypt(data);
}
}catch(Exception e){
e.printStackTrace();
}
}
}So, übertragen tut er schon mal schön. Also ich bekomme als Empfänger den verschlüsselten String mit
Code:
String encData = new String(data, 0, packet.getLength());Ich habe mir mal den "byte[] data" angeguckt. Er hat meistens eine Länge von 128 (genau so wie der String eine Länge von 128 Zeichen hat,wenn ich ihn aus den Datenbytes erstelle. Angezeigt werden jedoch immer weniger).
Die Länge des vom Versende verschickten Strings liegt meist um die 120 Zeichen.
Ich denke also, dass der Byte-Array nicht die korrekte Größe annimmt sondern die größe der nächsten 2er-Potenz.
Kann das sein? Oder hat irgendwer eine Idee, wo der Fehler sonst liegen kann?
Ich würde mich sehr freuen, wenn ihr mir trotz des umfangreichen Quelltexts und Problem, helfen könnten.
Vielen Dank schon mal im Voraus
