# Java AES Ver- und Entschlüsselung



## Dominik1986 (22. Okt 2012)

Hallo zusammen,

Ich habe mir eine Java-Klasse zum ver- und entschlüsseln geschrieben. Das Verschlüsseln klappt einwandfrei, allerdings habe ich beim Entschlüsseln Probleme. Hier erhalte ich eine IllegalBlockSizeException. 

Mein Code:


```
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;


public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String password = "WMservice"; 
		encryptPassword(password);
	}

	private static void encryptPassword(String password) {
		Key key = loadKey();
		if (key == null) {
			storeKeyInFile();
			key = loadKey();
		}
		String encryptString = "";
		try {
			Cipher cipher = Cipher.getInstance("AES");
			byte[] encrypted = password.getBytes("UTF8");
			cipher.init(Cipher.ENCRYPT_MODE, key);
			byte[] encryptBytes = cipher.doFinal(encrypted);
			encryptString = new String(encryptBytes);
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println(encryptString);
		decryptPassword(encryptString);
	}

	private static void decryptPassword(String encryptString) {
		try {
			Key key = loadKey();
			Cipher cipher = Cipher.getInstance("AES");
			cipher.init(Cipher.DECRYPT_MODE, key);
			byte[] decryptedBytes = cipher.doFinal(encryptString.getBytes());
			String decryptString = new String(decryptedBytes);
			System.out.println(decryptString);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		}		
	}

	private static Key loadKey() {
		Key key = null;
		KeyStore ks = null;
		try {
			ks = KeyStore.getInstance("JCEKS");
			InputStream readStream = new FileInputStream("C:\\key");
			ks.load(readStream, "test".toCharArray());
			key = ks.getKey("key", "test".toCharArray());
			readStream.close();
		} catch (KeyStoreException e) {
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (CertificateException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (UnrecoverableKeyException e) {
			e.printStackTrace();
		}
		return key;
	}

	private static void storeKeyInFile() {
		try {
			KeyGenerator keyGen = KeyGenerator.getInstance("AES");
			keyGen.init(256);
			Key secretKey = keyGen.generateKey();
			KeyStore ks = KeyStore.getInstance("JCEKS");
			ks.load(null, "test".toCharArray());
			ks.setKeyEntry("key", secretKey, "test".toCharArray(), null);
			OutputStream writeStream = new FileOutputStream("C:\\key");
			ks.store(writeStream, "test".toCharArray());
			writeStream.close();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (KeyStoreException e) {
			e.printStackTrace();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (CertificateException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}		
	}
}
```

und die Exception:


```
javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher
	at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)
	at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..)
	at com.sun.crypto.provider.AESCipher.engineDoFinal(DashoA13*..)
	at javax.crypto.Cipher.doFinal(DashoA13*..)
	at Test.decryptPassword(Test.java:57)
	at Test.encryptPassword(Test.java:49)
	at Test.main(Test.java:29)
```

Hoffe jemand kann mir hier helfen 

Gruß,

Dominik


----------



## trööööööööt (22. Okt 2012)

```
import java.io.*;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
public class AESHelper
{	
	private SecretKey key;
	private Cipher encryptCipher;
	private Cipher decryptCipher;
	public AESHelper(SecretKey key)
	{
		this.key=key;
	}
	public static SecretKey generateKey()
	{
		try
		{
			KeyGenerator keyGen=KeyGenerator.getInstance("AES");
			keyGen.init(128);
			return keyGen.generateKey();
		}
		catch(Exception e)
		{
			e.printStackTrace();
			return null;
		}
	}
	public boolean initCipher()
	{
		try
		{
			IvParameterSpec iv=new IvParameterSpec(key.getEncoded());
			encryptCipher=Cipher.getInstance("AES/CBC/PKCS5PADDING");
			encryptCipher.init(Cipher.ENCRYPT_MODE, key, iv);
			decryptCipher=Cipher.getInstance("AES/CBC/PKCS5PADDING");
			decryptCipher.init(Cipher.DECRYPT_MODE, key, iv);
			return true;
		}
		catch(Exception e)
		{
			e.printStackTrace();
			return false;
		}
	}
	public byte[] encryptRAW(byte[] input)
	{
		try
		{
			return crypt(input, encryptCipher);
		}
		catch(Exception e)
		{
			e.printStackTrace();
			return null;
		}
	}
	public String encryptString(String input)
	{
		byte[] rawinput=input.getBytes();
		byte[] rawoutput=encryptRAW(rawinput);
		if(rawoutput==null)
		{
			return null;
		}
		return binaryToHexString(rawoutput);
	}
	public byte[] decryptRAW(byte[] input)
	{
		try
		{
			return crypt(input, decryptCipher);
		}
		catch(Exception e)
		{
			e.printStackTrace();
			return null;
		}
	}
	public String decryptString(String input)
	{
		byte[] rawinput=hexStringToBinary(input);
		byte[] rawoutput=decryptRAW(rawinput);
		if(rawoutput==null)
		{
			return null;
		}
		return new String(rawoutput);
	}
	private byte[] crypt(byte[] data, Cipher cipher) throws Exception
	{
		ByteArrayInputStream bais=new ByteArrayInputStream(data);
		ByteArrayOutputStream baos=new ByteArrayOutputStream();
		int blockSize=cipher.getBlockSize();
		int outputSize=cipher.getOutputSize(blockSize);
		byte[] input=new byte[blockSize];
		byte[] output=new byte[outputSize];
		int inLength=0;
		boolean finished=false;
		while(!finished)
		{
			inLength=bais.read(input);
			if(inLength==blockSize)
			{
				int outLength=cipher.update(input, 0, blockSize, output);
				baos.write(output, 0, outLength);
			}
			else
			{
				finished=true;
			}
		}
		if(inLength>0)
		{
			output=cipher.doFinal(input, 0, inLength);
		}
		else
		{
			output=cipher.doFinal();
		}
		baos.write(output);
		return baos.toByteArray();
	}
	private String binaryToHexString(byte[] input)
	{
		StringBuilder stringBuilder=new StringBuilder(input.length*2);
		for(byte b : input)
		{
			int i=b&0xFF;
			if(i<16)
			{
				stringBuilder.append("0");
			}
			stringBuilder.append(Integer.toHexString(i));
		}
		return stringBuilder.toString();
	}
	private byte[] hexStringToBinary(String input)
	{
		byte[] output=new byte[input.length()/2];
		for(int i=0; i<output.length; i++)
		{
			output[i]=(byte)Integer.parseInt(input.substring(i*2, (i*2)+2), 16);
		}
		return output;
	}
}
```

funktioniert ... werde mich mal durch deinen code wühlen


----------



## trööööööööt (22. Okt 2012)

du hast gleich 2 fehler

1) Zeile 101 : init(256) geht nicht ...
java unterstützt so nur 128 ... wenn du 192 und 256 nutzen willst musst du dir die policy laden oder BouncyCastle nutzen

2) Zeilen 43, 49, 57 : das ergebnis von Cipher.doFinal(byte[]) sind RAW-daten ... die kannst du nicht einfach in einen String wandeln ...
der fehler passiert durch byte[]>String>byte[] ... denn das hintere byte was du decrypten willst ist nicht mehr das vordere byte was du als ergebnis des cryptens bekommst


----------



## Dominik1986 (22. Okt 2012)

trööööööööt hat gesagt.:


> du hast gleich 2 fehler
> 
> 1) Zeile 101 : init(256) geht nicht ...
> java unterstützt so nur 128 ... wenn du 192 und 256 nutzen willst musst du dir die policy laden oder BouncyCastle nutzen
> ...



Zu 1: Ja die hab ich schon, deshalb funktioniert es bei mir
Zu 2: Achso ok, also ist die Typkonvertierung Schuld, wie könnte ich das dann am Besten lösen?


----------



## trööööööööt (22. Okt 2012)

1) gut ... das du die unlimited policy hast wusste ich nicht (war aber eigentlich klar sonst hätte es ne IllegalKeySizeException gegeben und keine IllegalBlockSizeException) ... würde dir aber für den "produktiven" einsatz trotzdem von abraten ...
wenn es unbedingt 256 sein muss sollte man im public-umfeld trotzdem eher BouncyCastle nutzen anstatt seine user aufzufordern sich die policy zu installieren ... oder sich auf 128 beschränken ...

2) ich würde es jetzt nicht unbedingt eine schlichte type-konvertierung nennen (denn String.getBytes() und new String(byte[]) nutzen charset-enconding) ... aber grob : ja, das ist daran schuld ...
sinnvoll wäre eine "standard"-darstellung von binär-daten
hier sind vor allem Base64 und HEX zu nennen

da Base64 so leider nicht direkt in java implementiert wurde (zumindest nicht ohne gegen einige "clean code" regeln zu verstoßen) muss man entweder eine fremd-lib nutzen die es anbietet oder es sich in ein paar zeilen selbst implementieren (hab da jetzt gerade leider nichts zur hand)
zu base64 ist noch anzumerken : die ausgabe ist etwa 33% länger als die eingabe ...

die andere variante (wie ich sie verwende) besteht darin jeweils ein byte in zwei hex-zeichen zu codieren ...
dies ist die normale form für z.b. hash-werte oder auch im sog. "Hex-Editor" ...
Java kann hier teilweise helfen da es methoden gibt die ints als hex ausgeben und auch wieder parsen können ... lediglich die führende "0" bei werten unter 0x10 muss man selbst padden (wobei es auch hier tricks gibt)
hier wird jedoch deutlich das die ausgabe doppelt so lang ist wie die eingabe und somit auch den doppelten speicher frisst ...
ist vielleicht nicht das sauberste ... aber am einfachsten umzusetzen ...


----------



## Dominik1986 (22. Okt 2012)

trööööööööt hat gesagt.:


> 1) gut ... das du die unlimited policy hast wusste ich nicht (war aber eigentlich klar sonst hätte es ne IllegalKeySizeException gegeben und keine IllegalBlockSizeException) ... würde dir aber für den "produktiven" einsatz trotzdem von abraten ...
> wenn es unbedingt 256 sein muss sollte man im public-umfeld trotzdem eher BouncyCastle nutzen anstatt seine user aufzufordern sich die policy zu installieren ... oder sich auf 128 beschränken ...
> 
> 2) ich würde es jetzt nicht unbedingt eine schlichte type-konvertierung nennen (denn String.getBytes() und new String(byte[]) nutzen charset-enconding) ... aber grob : ja, das ist daran schuld ...
> ...




Ok dann werde ich mir mal das Base64 anschauen 
Oder mir einfach mal dein Beispiel näher ansehen  Das habe ich heute kurz einmal getestet, indem ich mir eine Testklasse mit main-Methode geschrieben habe, die dann die Methode encryptString aufgerufen hat. Aber irgendwie hat das nicht geklappt, da kam eine Exception, habe ich hier vielleicht einen Zwischenschritt vergessen?


----------



## trööööööööt (26. Okt 2012)

Dominik1986 hat gesagt.:


> Ok dann werde ich mir mal das Base64 anschauen
> Oder mir einfach mal dein Beispiel näher ansehen  Das habe ich heute kurz einmal getestet, indem ich mir eine Testklasse mit main-Methode geschrieben habe, die dann die Methode encryptString aufgerufen hat. Aber irgendwie hat das nicht geklappt, da kam eine Exception, habe ich hier vielleicht einen Zwischenschritt vergessen?



wenn du mir den stacktrace gepostet hättest hätte ich dir auch sofort sagen können ob und wenn was du falsch gemacht hast ...

korrekterweise müsste es eigentlich auch
[java=59]byte[] rawinput=input.getBytes("UTF-8");[/code]
und
[java=87]return new String(rawoutput, "UTF-8");[/code]
heißen um encoding-fehler zu vermeiden ...
da ich die klasse jedoch mal schnell aus einem sehr alten projekt kopiert habe wo ich da noch nicht so drauf geachtet habe wie heute hab ichs auch erst gemerkt als ichs schon gepostet habe ...


hier mal ein beispiel call der dem entspricht wie es damals geplant war (aktuelle version läuft anders)

```
SecretKey secretKey=AESHelper.generateKey();
if(secretKey==null)
{
	throw new NullPointerException("SecretKey == null");
}
AESHelper aesHelper=new AESHelper(secretKey);
if(!aesHelper.initCipher())
{
	throw new IllegalStateException("Cipher not inited");
}
String original="this is a test";
System.out.println("original : "+original);
String encrypted=aesHelper.encryptString(original);
if(encrypted==null)
{
	throw new NullPointerException("failed to encrypt");
}
System.out.println("encrypted : "+encrypted);
String decrypted=aesHelper.decryptString(encrypted);
if(decrypted==null)
{
	throw new NullPointerException("failed to decrypt");
}
System.out.println("decrypted : "+decrypted);
System.out.println("equal : "+original.equals(decrypted));
```
das wäre jetzt mal ein call-stack wie er ursprünglich mal gedacht war ...
wichtig natürlich das initCiper() gecallt wird ... ansonsten fliegt einiges an exceptions ...


----------



## Dominik1986 (26. Okt 2012)

Danke für die Antwort, hab es heute getestet und hat geklappt, also mit den 128 Bit, mit den 256 Bit geht es nicht, da bekomm ich diese Exception:



> java.security.InvalidAlgorithmParameterException: Wrong IV length: must be 16 bytes long
> at com.sun.crypto.provider.SunJCE_f.a(DashoA13*..)
> at com.sun.crypto.provider.AESCipher.engineInit(DashoA13*..)
> at javax.crypto.Cipher.a(DashoA13*..)
> ...



Hier mal der Code dazu:


```
import java.io.*;
import javax.crypto.*;
import javax.crypto.spec.*;

public class AESHelper {
	private SecretKey key;
	private Cipher encryptCipher;
	private Cipher decryptCipher;

	public AESHelper(SecretKey key) {
		this.key = key;
	}

	public static SecretKey generateKey() {
		try {
			KeyGenerator keyGen = KeyGenerator.getInstance("AES");
			keyGen.init(256);
			return keyGen.generateKey();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	public boolean initCipher() {
		try {			
			IvParameterSpec iv = new IvParameterSpec(key.getEncoded());
			System.out.println(iv.getIV().length);
			encryptCipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
			encryptCipher.init(Cipher.ENCRYPT_MODE, key, iv);
			decryptCipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
			decryptCipher.init(Cipher.DECRYPT_MODE, key, iv);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	public byte[] encryptRAW(byte[] input) {
		try {
			return crypt(input, encryptCipher);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	public String encryptString(String input) throws UnsupportedEncodingException {
		byte[] rawinput = input.getBytes("UTF-8");
		byte[] rawoutput = encryptRAW(rawinput);
		if (rawoutput == null) {
			return null;
		}
		return binaryToHexString(rawoutput);
	}

	public byte[] decryptRAW(byte[] input) {
		try {
			return crypt(input, decryptCipher);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	public String decryptString(String input) throws UnsupportedEncodingException {
		byte[] rawinput = hexStringToBinary(input);
		byte[] rawoutput = decryptRAW(rawinput);
		if (rawoutput == null) {
			return null;
		}
		return new String(rawoutput, "UTF-8");
	}

	private byte[] crypt(byte[] data, Cipher cipher) throws Exception {
		ByteArrayInputStream bais = new ByteArrayInputStream(data);
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		int blockSize = cipher.getBlockSize();
		int outputSize = cipher.getOutputSize(blockSize);
		byte[] input = new byte[blockSize];
		byte[] output = new byte[outputSize];
		int inLength = 0;
		boolean finished = false;
		while (!finished) {
			inLength = bais.read(input);
			if (inLength == blockSize) {
				int outLength = cipher.update(input, 0, blockSize, output);
				baos.write(output, 0, outLength);
			} else {
				finished = true;
			}
		}
		if (inLength > 0) {
			output = cipher.doFinal(input, 0, inLength);
		} else {
			output = cipher.doFinal();
		}
		baos.write(output);
		return baos.toByteArray();
	}

	private String binaryToHexString(byte[] input) {
		StringBuilder stringBuilder = new StringBuilder(input.length * 2);
		for (byte b : input) {
			int i = b & 0xFF;
			if (i < 16) {
				stringBuilder.append("0");
			}
			stringBuilder.append(Integer.toHexString(i));
		}
		return stringBuilder.toString();
	}

	private byte[] hexStringToBinary(String input) {
		byte[] output = new byte[input.length() / 2];
		for (int i = 0; i < output.length; i++) {
			output[i] = (byte) Integer.parseInt(
					input.substring(i * 2, (i * 2) + 2), 16);
		}
		return output;
	}
}
```



```
import java.io.UnsupportedEncodingException;

import javax.crypto.SecretKey;


public class Test {

	public static void main(String[] args) {
		SecretKey secretKey = AESHelper.generateKey();
		if (secretKey == null) {
			throw new NullPointerException();
		}
		AESHelper aesHelper = new AESHelper(secretKey);
		if (!aesHelper.initCipher()) {
			throw new IllegalStateException();
		}
		String original = "WMservice";
		System.out.println(original);
		try {
			String encrypted = aesHelper.encryptString("Orignal: " + original);
			if (encrypted == null) {
				throw new NullPointerException();
			}
			System.out.println("Encrypted " + encrypted);
			String decrypted = aesHelper.decryptString(encrypted);
			if (decrypted == null) {
				throw new NullPointerException();
			}
			System.out.println("Decrypted: " + decrypted);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
	}
}
```


----------



## trööööööööt (26. Okt 2012)

ich versteh zwar immer noch nicht den grund warum du versuchst java mit der policy zu AES256 zu zwingen (wäre nett wenn du mir das mal erklären würdest) und warum du dafür dann nicht BouncyCastle nutzt ...

persönlich habe ich mich nie mit AES256 beschäftigt da ich 1) kein bock hatte mich mit BC zu beschäftigen und 2) meine software nun mal auf ner "standard-VM" laufen soll ...

das gemeldete problem ist eigentlich eindeutig : der IV passt nicht ...
grund : du versuchst aus einem 32byte key einen IV zu erstellen ... AES ist aber auf blockgröße 128 beschränkt und braucht darum auch einen IV von nur 16byte ...
lösung wäre jetzt das du einfach nur die hälfte des byte-arrays von Key.getEncoded() an den konstruktor übergibst ...

oder du guckst dir BC an und versuchst rauszubekommen ob Rijndeal256/256 unterstützt wird ... dann passt es wieder ...
(soweit wie ich jetzt schnell mal gegoogled hab ist es wohl möglich, aber ziemlich kompliziert)

geb dich also entweder mit AES128 zufrieden oder sorg selbst dafür das du aus deinem 192/256 key einen 128 IV bekommst ...


----------



## Dominik1986 (26. Okt 2012)

Ok danke


----------

