byte-weise Verschlüsselung

[blubbrezn]

Ich wollte ein kleines Programm programmieren, mit dem man einen String in ein Byte array umwandeln
und dann zu jedem einzelnen Byte einen Int (Schlüssel) addiert. Dann soll das Array wieder in einen String umgewandelt werden.

class Test2 {
    private String s;
    
    public Test2() {
        s = "Hallo wie geht es dir"; 
    }
    public void lockString(int key){
        byte[] buffer;
        buffer = s.getBytes();
        
        for(int i=0;i<s.length();i++){
            buffer[i]+=key;
            while(buffer[i]>255){
                buffer[i]-=256;
            }
        }
        s = new String(buffer);
        System.out.println(s);

    }
    public void unlockString(int key){
        byte[] buffer;
        buffer = s.getBytes();
        for(int i=0;i<s.length();i++){
            buffer[i]-=key;
            while(buffer[i]<0){
                buffer[i]+=256;
            }
        }
        s = new String(buffer);
        System.out.println(s);

    }
}

Das Problem ist, dass wen ich als key 4134 (einziges Beispiel was ich durch Zufall gefunden hab) nehme, funktioniert die entschlüsselung nicht richtig.

Wäre sehr nett wenn mir jmd helfen könnte, weil ich weis einfach nicht warum das so ist.

 

[SlaterB]

Java ist eben gemein, bei

public class Test
{

    public static void main(String[] args)
    {
        byte[] b =  {-40, 40, 126};
        b = new String(b).getBytes();
        System.out.println(Arrays.toString(b));
    }
}

kommt nicht dasselbe Array wieder raus, sondern als Ausgabe

[-17, -65, -67, 40, 126]

auf bytes <-> String kann man sich nicht wirklich verlassen, evtl. gehts wenn du allein die negativen Bytes wegläßt,
sorge für positive Bereiche, wie auch immer, hast du vielleicht auch schon vor, klappt nur noch nicht


-----

            while(buffer[i]<0){
                buffer[i]+=256;
            }

ist übrigens eine Endlosschleife, jedes byte +256 und wieder auf byte gecastet ist dasselbe,

die erste Schleife [c]while(buffer>255){[/c] ebenso, die kann aber zumindest nie starten,
da byte nur den Bereich -127 bis +128 hat

gehe auf short oder int und dann mit deinen Schleifen Bereich 0-255 halten

 

[blubbrezn]

Würde es besser funktionieren wenn ich das ganze mit Character statt mit Bytes machen würde?

Aber da weis ich nicht wie ich da einen Int addieren soll?

 

[SlaterB]

char ist wie short, int oder byte auch nur ein Zahlenbereich, da kannst du + und - rechnen,

char ist wie short und int größer als byte, insofern kann das schon helfen gegen Negative,
und char[] <-> String ist in der Tat vertrauenswürdiger als byte[] <-> String, besonders wenn wieder ohne Negative

insgesamt eine exellente Idee, ja 😉

 

[blubbrezn]

SUPER! danke so funktioniert es
bis zu 10 Stellen aber das liegt dann daran das in den int nicht mehr reinpasst oder?

import java.util.*;

class Test {
    private static String s;


    public Test() {

        s = "Hallo wie geht es dir";


    }
    public static void lockString(int key){
        char[] buffer;
        buffer = new  char[s.length()];
        s.getChars(0,s.length(),buffer,0);
        for(int i=0;i<s.length();i++){
            buffer[i]+=key;

        }
        s = new String(buffer);
        System.out.println(s);

    }
    public static void unlockString(int key){
        char[] buffer;
        buffer = new  char[s.length()];
        s.getChars(0,s.length(),buffer,0);
        for(int i=0;i<s.length();i++){
            buffer[i]-=key;

        }
        s = new String(buffer);
        System.out.println(s);

    }
    public static void main(String[] args) {
        new Test();
        System.out.println("Schlüssel eingeben");
        Scanner input = new Scanner(System.in);
        int key = input.nextInt();
        System.out.println(key);
        lockString(key);
        unlockString(key);
        main(args);
    }

}

 

[SlaterB]

10 Stellen für den Schlüssel?
sicher, ein int ist begrenzt

 

[TheRealSpikee]

Ich werf jetzt einfach mal AES mit in den Raum ...

import java.io.*;
import javax.crypto.*;
import java.security.*;
public class AESHelper
{
	private BufferedReader in=null;
	private PrintStream out=null;
	private Cipher encryptCipher=null;
	private Cipher decryptCipher=null;
	private SecretKey secretKey=null;
	public AESHelper(BufferedReader in, PrintStream out, SecretKey secretKey) { this.in=in; this.out=out; this.secretKey=secretKey; }
	public void initCipher() throws Exception
	{
		(encryptCipher=Cipher.getInstance("AES")).init(Cipher.ENCRYPT_MODE, secretKey);
		(decryptCipher=Cipher.getInstance("AES")).init(Cipher.DECRYPT_MODE, secretKey);
	}
	public static SecretKey generateKey() throws Exception
	{
		KeyGenerator keyGenerator=KeyGenerator.getInstance("AES");
		keyGenerator.init(new SecureRandom());
		return keyGenerator.generateKey();
	}
	public void sendMessage(String msg) throws Exception
	{
		out.println(ToolKit.byteArrayToHexString(crypt(msg.getBytes(), encryptCipher)));
	}
	public String receiveMessage() throws Exception
	{
		String line="";
		while((line=in.readLine())!=null)
		{
			if(!line.equals(""))
				break;
		}
		return new String(crypt(ToolKit.hexStringToByteArray(line), decryptCipher));
	}
	private byte[] crypt(byte[] dataInput, Cipher cipher) throws Exception
	{
		ByteArrayInputStream bais=new ByteArrayInputStream(dataInput);
		ByteArrayOutputStream baos=new ByteArrayOutputStream();
		int blockSize=cipher.getBlockSize();
		int outputSize=cipher.getOutputSize(blockSize);
		byte[] input=new byte[blockSize];
		byte[] output=new byte[outputSize];
		int readBytes=0;
		boolean finish=false;
		while(!finish)
		{
			readBytes=bais.read(input);
			if(readBytes==blockSize)
			{
				int outputLength=cipher.update(input, 0, blockSize, output);
				baos.write(output, 0, outputLength);
			}
			else
				finish=true;
		}
		if(readBytes>0)
			output=cipher.doFinal(input, 0, readBytes);
		else
			output=cipher.doFinal();
		baos.write(output);
		return (baos.toByteArray());
	}
}

class ToolKit
{
	public static String byteArrayToHexString(byte[] input)
	{
		StringBuffer sb=new StringBuffer(input.length*2);
		for(int i=0; i<input.length; i++)
		{
			int v=input[i]&0xFF;
			if(v<16)
				sb.append("0");
			sb.append(Integer.toHexString(v));
		}
		return sb.toString();
	}
	public static byte[] hexStringToByteArray(String input)
	{
		byte[] ret=new byte[input.length()/2];
		for(int i=0; i<ret.length; i++)
		{
			int index=i*2;
			int v=Integer.parseInt(input.substring(index, index+2), 16);
			ret[i]=(byte)v;
		}
		return ret;
	}
}

Da AES in der Regel eine Block-Länge von 128Bit / 16Byte hat hat der Output eine Länge von 16Byte bei einem Input von 1Byte-15Byte , 32Byte bei Input 16Byte-31Byte usw ...
Heißt also : der Output hat immer eine bestimmte Länge bei einer bestimmten Länge des Inputs. Sollte in ungefähr das sein was du suchst.


*Ist zwar wie mit Kanonen auf Spatzen schießen ... aber funktioniert*