Problem mit führender Null bei Schlüsselerzeugung

[Don83]

Hallo liebes Forum,

ersteinmal möcht ich mich kurz äußern wie froh ich bin, dass das Forum wieder lebt! :toll:

Dann aber direkt weiter zu meiner Frage. Ich habe folgenden Code implementiert mit dem ich einen Bitkey erzeuge und im Hexadezimal Format ausgebe.

In 15 von 16 Fällen funktioniert alles wie gehabt. Gibt es aber eine führende Null wird diese abgeschnitten und ich erhalte nur 63 anstelle von 64 Zeichen. Ansich kein Problem an sich, ich kann diese Fälle abfangen, aber ich würde halt auch gerne verstehen wieso dieses Problem besteht und im Moment tue ich das noch nicht. ???:L

Nachfolgend der Code.

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

public class KeyGenNTD {

	public static void main(String[] args) throws NoSuchAlgorithmException,
			FileNotFoundException, IOException {

		// Schlüssel erzeugen
		byte[] key = null;

		KeyGenerator kgen = KeyGenerator.getInstance("AES");
		// args1 = bitlänge
		kgen.init(256);
		SecretKey skey = kgen.generateKey();
		key = skey.getEncoded();
		System.out.println(Arrays.toString(key));
		String data = new BigInteger(1, key).toString(16);

		// Den Schlüssel in eine Datei schreiben (args[0])
		String secretKeyFileName = "key.txt";
		FileWriter writy = new FileWriter(new File(secretKeyFileName));
		
		data=data.toUpperCase();
		writy.write(data);
		writy.flush();
		writy.close();
		
	}
}

EDIT: Komischer Weise werden die "[]" im Foren Javacode falsch angezeigt. Hoffe das führt nicht zu Verwirrung.

 

[Pippl]

In 15 von 16 Fällen funktioniert alles wie gehabt. Gibt es aber eine führende Null wird diese abgeschnitten und ich erhalte nur 63 anstelle von 64 Zeichen. ..... ich würde halt auch gerne verstehen wieso dieses Problem besteht und im Moment tue ich das noch nicht. ???:L

		String data = new BigInteger(1, key).toString(16);

Du wandelst hier [c]key[/c] in ein BigInteger um. Numerische Datentypen speichern keine führenden "0". Dadurch werden auch nur 63 Zeichen in die Datei geschrieben.

Hier wird gelöst wie man einfach führende "0" zu einen String bekommt

Offtopic: Du hast in der Schule auch "1+1=2" gerechnet und nicht "01+01=02" 😉

 

[Don83]

Ah vielen Dank!

 

[Pippl]

Ich muss meine Aussage berichtigen.
Die führende "0" ist zwar im Speicher vorhanden (damit man natürlich weiß hier kommt eine "0"), aber die Darstellung passiert ohne führende "0" da es hier keinen Informationsgewinn gibt.

 

[Don83]

Ok alles klar,

ich denke gerade auch noch über das Ganze nach. Rückmeldung wäre super ob ich das Ganze richtig verstehe:

Also es wird ja erstmal ein Bitkey erstellt mit 256 Bits (1en und 0en).
Diese werden dann erstmal in ein Byte Array umgewandelt. Dieses besteht aus 32 Bytes, da jeweils 8 bits = 1 byte.

2^8 mögliche Bytes gibt es. (256) <-Ascii

Nagut in Java wird das wohl durch Zahlen zwischen -128 bis 127 dargestellt.

Die Bytearrays sehen jetzt bei mir wie folgend aus...
[7, -14, -111, 40, 101, -88, 99, 62, -44, -106, 85, -32, -125, 23, -36, -67, 114, -56, 73, 40, -114, 70, 109, 70, 62, 89, -72, -38, -15, -39, 59, 77]

Ok jetzt wirds bei mir schwammig... Das Byte-Array wird nun in ein Biginteger umgewandelt. Big Integer durchblicke ich noch nicht ganz.

String data = new BigInteger(1, key).toString(16);

Ok soweit ich weis wird iiiiiiirgendwie eine Zahl berechnet. Wenn wir die Basis auf 10 setzen würden hätten wir eine menschlich lesbare Zahl, bei der Basis 16 eben Hexadezimalcode.

Die genaue Umrechnung verstehe ich erstmal noch nicht so wirklich, aber im Grunde genommen... wenn bei dieser Zahl dann eine 0 vorne steht wird diese Weggelassen? Weil "Zahlen" keine 0 vorne haben können. Nachdem es aber 64 Zeichen sein müssten... kann ich auffüllen...

So zu obigen Bytearray erhalte ich auf jeden Fall folgende Zahl:

Key: 7F2912865A8633ED49655E08317DCBD72C849288E466D463E59B8DAF1D93B4D
Nur 63 Zeichen.

Diese wäre also gleichbedeutend zu folgender "Zeichenkette":
Key: 07F2912865A8633ED49655E08317DCBD72C849288E466D463E59B8DAF1D93B4D

Also Hexadezimalzahlen dürfen quasi grundsätzlich nicht mit nullen anfangen.
Wenn ich nun aber 7F2912865A8633ED49655E08317DCBD72C849288E466D463E59B8DAF1D93B4D
zurückrechne komme ich wieder auf mein altes Bitaarray. Mit führender null kann ich ja nicht zurückrechnen, da dies dann keine Zahl wäre,oder?

das heisst also, wenn ich nun einen Key mit 63 Zeichen habe und einmal mit 64 Zeichen und ich fülle den mit 63 Zeichen vorne mit einer null auf müsste ich durch umrechnen bei BEIDEN Zeichenketten wieder auf das Bitarray kommen können, oder nicht?

 

[Pippl]

... wenn bei dieser Zahl dann eine 0 vorne steht wird diese Weggelassen? Weil "Zahlen" keine 0 vorne haben können.

Es wird jede Ziffer gespeichert, natürlich auch führende 0.
Die führende 0 wird nur nicht auf der Konsole angezeigt, weil die entsprechende String-Repräsentation keinen führende 0 beinhaltet. Das du die führende 0 nicht angezeigt bekommst ist nur eine Darstellung!

Anderes Beispiel: Ein Datum wird in einer Datenbank gespeichert. Die Speicherung erfolgt als Zahl und nicht als Datumstring. Damit du bei einem SELECT dann trotzdem ein lesbares Datum hast wird hier einfach die Zahl entsprechende umgewandelt.