Changed the encrypted data format

Added a new class to store the encrypted data, and added the GSON
library to serialize said class effectively.

pom.xml

@@ -8,6 +8,12 @@
 	<description>A super-simple account management system.</description>
 
 	<dependencies>
+		<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
+		<dependency>
+			<groupId>com.google.code.gson</groupId>
+			<artifactId>gson</artifactId>
+			<version>2.7</version>
+		</dependency>
 		<!-- https://mvnrepository.com/artifact/org.json/json -->
 		<dependency>
 			<groupId>org.json</groupId>
@@ -16,9 +22,9 @@
 		</dependency>
 		<!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
 		<dependency>
-		    <groupId>commons-codec</groupId>
-		    <artifactId>commons-codec</artifactId>
-		    <version>1.9</version>
+			<groupId>commons-codec</groupId>
+			<artifactId>commons-codec</artifactId>
+			<version>1.9</version>
 		</dependency>
 	</dependencies>
 

src/eu/tankernn/accounts/AccountManager.java

@@ -3,6 +3,7 @@ package eu.tankernn.accounts;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
+import java.io.ObjectStreamException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -16,8 +17,9 @@ import org.json.JSONObject;
 
 import eu.tankernn.accounts.frame.MainFrame;
 import eu.tankernn.accounts.frame.PasswordDialog;
-import eu.tankernn.accounts.util.Encryption;
-import eu.tankernn.accounts.util.InvalidPasswordException;
+import eu.tankernn.accounts.util.encryption.EncryptedComplex;
+import eu.tankernn.accounts.util.encryption.Encryption;
+import eu.tankernn.accounts.util.encryption.InvalidPasswordException;
 
 public class AccountManager {
 	public static final String CURRENCY = "SEK";
@@ -56,47 +58,44 @@ public class AccountManager {
 	 *            The file to load
 	 */
 	public static void openFile(File file) {
-		// Open plain text file
+		Object data = null;
 		try {
-			String jsonString = FileManager.readFileAsString(file);
-			//If '[' is first, the JSON is *probably* valid
-			if (jsonString.startsWith("[")) {
-				accounts = parseJSON(jsonString);
-				lastPassword = null;
-				lastJSONString = jsonString;
-				return;
+			try {
+				// Try to read the file as a byte[][]
+				data = FileManager.readObjectFromFile(file, byte[][].class);
+			} catch (ObjectStreamException | ClassNotFoundException e1) {
+				// Read the file as string
+				data = FileManager.readFileAsString(file);
 			}
 		} catch (IOException e) {
 			e.printStackTrace();
 			return;
 		}
-		// Open encrypted file
-		byte[][] data = null; 
-		try {
-			data = FileManager.readObjectFromFile(file, byte[][].class);
-		} catch (IOException e) {
-			e.printStackTrace();
-			return;
-		} catch (ClassNotFoundException e) {
-			e.printStackTrace();
-			return;
-		}
 		String jsonString = new String();
-		do {
-			try {
-				char[] password = PasswordDialog
-						.showPasswordDialog("The data is encrypted, please enter the password to decrypt it.");
-				if (password == null) {
-					// Start the program without loading a file
-					return;
+		// If '[' is first, the JSON is *probably* valid
+		if (data instanceof String && ((String) data).startsWith("[")) {
+			lastPassword = null;
+			jsonString = new String((String) data);
+		} else {
+			// Try to decrypt the string or byte[][]
+			do {
+				try {
+					char[] password = PasswordDialog
+							.showPasswordDialog("The data is encrypted, please enter the password to decrypt it.");
+					if (password == null) {
+						// Start the program without loading a file
+						return;
+					}
+					jsonString = data instanceof String ? Encryption.decryptEncoded((String) data, password)
+							: Encryption.decrypt(new EncryptedComplex((byte[][]) data), password);
+					lastPassword = password;
+					break;
+				} catch (InvalidPasswordException e) {
+					continue;
 				}
-				jsonString = Encryption.decrypt(data, password);
-				lastPassword = password;
-				break;
-			} catch (InvalidPasswordException e) {
-				continue;
-			}
-		} while (jsonString.toCharArray()[0] != '[');
+			} while (jsonString.toCharArray()[0] != '[');
+		}
+		
 		accounts = parseJSON(jsonString);
 		lastJSONString = jsonString;
 		window.refresh();
@@ -131,20 +130,17 @@ public class AccountManager {
 	public static void saveFile(boolean saveAs) {
 		try {
 			String newData = exportJSON();
-			byte[][] encryptedData = null;
+			String encryptedData = new String(newData);
 			if (saveWithEncryption) {
 				while (lastPassword == null || lastPassword.length < 5) {
-					lastPassword = PasswordDialog
-							.showPasswordDialog("Select a password to encrypt the account file with. (At least 5 characters, preferrably longer)");
+					lastPassword = PasswordDialog.showPasswordDialog(
+							"Select a password to encrypt the account file with. (At least 5 characters, preferrably longer)");
 				}
-				encryptedData = Encryption.encrypt(newData, lastPassword);
+				encryptedData = Encryption.encryptEncoded(newData, lastPassword);
 			}
-			if (encryptedData == null)
-				FileManager.writeStringToFile(saveAs, newData);
-			else
-				FileManager.writeObjectToFile(saveAs, encryptedData);
+			FileManager.writeStringToFile(saveAs, encryptedData);
 			lastJSONString = newData;
-		} catch (ClassNotFoundException | IOException e1) {
+		} catch (IOException e1) {
 			e1.printStackTrace();
 		}
 	}

src/eu/tankernn/accounts/FileManager.java

@@ -36,15 +36,24 @@ public class FileManager {
 		return null;
 	}
 
+	public static void writeLastFileToCache(File file) {
+		FILE_CHOOSER.setSelectedFile(file);
+		// Remember this filename
+		if (!file.equals(lastFilenameCache))
+			try {
+				FileManager.writeStringToFile(lastFilenameCache, file.getAbsolutePath());
+			} catch (FileNotFoundException e) {
+				e.printStackTrace();
+			}
+	}
+
 	public static String readFileAsString(File file) throws IOException {
 		if (file == null) {
 			FILE_CHOOSER.showOpenDialog(null);
 			file = FILE_CHOOSER.getSelectedFile();
 		}
 
-		// Remember this filename
-		if (!file.equals(lastFilenameCache))
-			FileManager.writeStringToFile(lastFilenameCache, file.getAbsolutePath());
+		writeLastFileToCache(file);
 
 		BufferedReader reader = new BufferedReader(new FileReader(file));
 		StringBuilder builder = new StringBuilder();
@@ -77,7 +86,7 @@ public class FileManager {
 
 		newFile.createNewFile();
 
-		FileManager.writeStringToFile(lastFilenameCache, newFile.getAbsolutePath());
+		writeLastFileToCache(newFile);
 		writeStringToFile(newFile, "[]");
 
 		return newFile;
@@ -115,7 +124,8 @@ public class FileManager {
 		return FILE_CHOOSER.getSelectedFile();
 	}
 
-	public static <T> T readObjectFromFile(File file, Class<T> class1) throws IOException, ClassNotFoundException {
+	public static <T> T readObjectFromFile(File file, Class<T> class1)
+			throws ClassNotFoundException, FileNotFoundException, IOException {
 		if (file == null) {
 			FILE_CHOOSER.showOpenDialog(null);
 			file = FILE_CHOOSER.getSelectedFile();
@@ -123,6 +133,7 @@ public class FileManager {
 		ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
 		T obj = class1.cast(in.readObject());
 		in.close();
+		writeLastFileToCache(file);
 		return obj;
 	}
 

src/eu/tankernn/accounts/util/encryption/EncryptedComplex.java

@@ -0,0 +1,66 @@
+package eu.tankernn.accounts.util.encryption;
+
+import org.apache.commons.codec.DecoderException;
+import org.apache.commons.codec.binary.Base64;
+import org.apache.commons.codec.binary.Hex;
+
+public class EncryptedComplex {
+	private byte[] salt, iv, data;
+
+	public EncryptedComplex(byte[] salt, byte[] iv, byte[] data) {
+		this.salt = salt;
+		this.iv = iv;
+		this.data = data;
+	}
+	
+	/**
+	 * Convert the legacy format into the new one.
+	 * @param b The old encrypted complex format.
+	 */
+	public EncryptedComplex(byte[][] b) {
+		this(b[0], b[1], b[2]);
+	}
+
+	public EncryptedComplex(String salt, String iv, String data) {
+		this.salt = decode(salt);
+		this.iv = decode(iv);
+		this.data = decode(data);
+	}
+
+	private String encode(byte[] b) {
+		// Easily switch to other encoding types
+		return Base64.encodeBase64String(b);
+	}
+
+	private byte[] decode(String str) {
+		try {
+			return Hex.decodeHex(str.toCharArray());
+		} catch (DecoderException e) {
+			return Base64.decodeBase64(str);
+		}
+	}
+
+	public byte[] getSalt() {
+		return salt;
+	}
+
+	public byte[] getIV() {
+		return iv;
+	}
+
+	public byte[] getData() {
+		return data;
+	}
+
+	public String getEncodedSalt() {
+		return encode(salt);
+	}
+
+	public String getEncodedIv() {
+		return encode(iv);
+	}
+
+	public String getEncodedData() {
+		return encode(data);
+	}
+}

src/eu/tankernn/accounts/util/encryption/EncryptedComplexSerializer.java

@@ -0,0 +1,32 @@
+package eu.tankernn.accounts.util.encryption;
+
+import java.lang.reflect.Type;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+
+public class EncryptedComplexSerializer
+		implements JsonSerializer<EncryptedComplex>, JsonDeserializer<EncryptedComplex> {
+
+	@Override
+	public JsonElement serialize(EncryptedComplex src, Type typeOfSrc, JsonSerializationContext context) {
+		JsonObject object = new JsonObject();
+		object.addProperty("salt", src.getEncodedSalt());
+		object.addProperty("IV", src.getEncodedIv());
+		object.addProperty("data", src.getEncodedData());
+		return object;
+	}
+
+	@Override
+	public EncryptedComplex deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
+			throws JsonParseException {
+		JsonObject obj = json.getAsJsonObject();
+		return new EncryptedComplex(obj.get("salt").getAsString(), obj.get("IV").getAsString(), obj.get("data").getAsString());
+	}
+
+}

src/eu/tankernn/accounts/util/Encryption.java → src/eu/tankernn/accounts/util/encryption/Encryption.java

@@ -1,4 +1,4 @@
-package eu.tankernn.accounts.util;
+package eu.tankernn.accounts.util.encryption;
 
 import java.io.UnsupportedEncodingException;
 import java.security.AlgorithmParameters;
@@ -9,7 +9,6 @@ import java.security.SecureRandom;
 import java.security.spec.InvalidKeySpecException;
 import java.security.spec.InvalidParameterSpecException;
 import java.security.spec.KeySpec;
-import java.util.Arrays;
 
 import javax.crypto.BadPaddingException;
 import javax.crypto.Cipher;
@@ -21,53 +20,39 @@ import javax.crypto.spec.GCMParameterSpec;
 import javax.crypto.spec.PBEKeySpec;
 import javax.crypto.spec.SecretKeySpec;
 
-import org.apache.commons.codec.DecoderException;
-import org.apache.commons.codec.binary.Base64;
-import org.apache.commons.codec.binary.Hex;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
 
 public class Encryption {
-
+	
 	private static final String CIPHER_TYPE = "AES/GCM/PKCS5Padding";
-	public static final String STRING_SEPARATOR = "#";
+	private static final Gson GSON = new GsonBuilder().registerTypeAdapter(EncryptedComplex.class, new EncryptedComplexSerializer()).setPrettyPrinting().create();
 
 	public static String decryptEncoded(String dataString, char[] password) throws InvalidPasswordException {
-		String[] splitted = dataString.split(STRING_SEPARATOR);
-
-		byte[][] encryptedComplex = (byte[][]) Arrays.asList(splitted).stream().map(s -> {
-			try {
-				return Hex.decodeHex(s.toCharArray());
-			} catch (DecoderException e) {
-				return Base64.decodeBase64(s);
-			}
-		}).toArray();
-
-		return decrypt(encryptedComplex, password);
+		EncryptedComplex ec = GSON.fromJson(dataString, EncryptedComplex.class);
+		return decrypt(ec, password);
 	}
 
 	/**
 	 * Decrypts an encrypted string of data.
 	 * 
-	 * @param data
-	 *            A Base64-encoded string with the format 'SALT#IV#DATA'
+	 * @param ec
+	 *            An object containing all the data needed to restore the
+	 *            original
 	 * @param password
 	 *            The password used when the string was encrypted
 	 * @return The decrypted string
 	 * @throws InvalidPasswordException
 	 *             if the password is incorrect
 	 */
-	public static String decrypt(byte[][] data, char[] password) throws InvalidPasswordException {
-		return decrypt(data[0], data[1], data[2], password);
-	}
-
-	private static String decrypt(byte[] salt, byte[] iv, byte[] data, char[] password)
-			throws InvalidPasswordException {
+	public static String decrypt(EncryptedComplex ec, char[] password) throws InvalidPasswordException {
 		try {
-			SecretKey secret = composeKey(salt, password);
+			SecretKey secret = composeKey(ec.getSalt(), password);
 			Cipher cipher = Cipher.getInstance(CIPHER_TYPE);
 
-			GCMParameterSpec params = new GCMParameterSpec(128, iv);
+			GCMParameterSpec params = new GCMParameterSpec(128, ec.getIV());
 			cipher.init(Cipher.DECRYPT_MODE, secret, params);
-			String plainText = new String(cipher.doFinal(data), "UTF-8");
+			String plainText = new String(cipher.doFinal(ec.getData()), "UTF-8");
 			return plainText;
 		} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException | IllegalBlockSizeException
 				| InvalidKeySpecException | UnsupportedEncodingException | InvalidAlgorithmParameterException e) {
@@ -79,13 +64,8 @@ public class Encryption {
 	}
 
 	public static String encryptEncoded(String data, char[] password) {
-		byte[][] encryptedComplex = encrypt(data, password);
-
-		String saltString = Base64.encodeBase64String(encryptedComplex[0]);
-		String ivString = Base64.encodeBase64String(encryptedComplex[1]);
-		String dataString = Base64.encodeBase64String(encryptedComplex[2]);
-
-		return String.join(STRING_SEPARATOR, saltString, ivString, dataString);
+		EncryptedComplex ec = encrypt(data, password);
+		return GSON.toJson(ec);
 	}
 
 	/**
@@ -98,7 +78,7 @@ public class Encryption {
 	 * @return All information needed to get the original data back, except the
 	 *         password.
 	 */
-	public static byte[][] encrypt(String data, char[] password) {
+	public static EncryptedComplex encrypt(String data, char[] password) {
 		return encrypt(new SecureRandom().generateSeed(8), data, password);
 	}
 
@@ -108,10 +88,10 @@ public class Encryption {
 	 * @param salt
 	 * @param data
 	 * @param password
-	 * @return A two-dimensional byte array where [0] is the salt bytes, [1] is
-	 *         the IV bytes and [2] is the encrypted data bytes.
+	 * @return An object containing all information, except the password, needed
+	 *         to restore the original data.
 	 */
-	private static byte[][] encrypt(byte[] salt, String data, char[] password) {
+	private static EncryptedComplex encrypt(byte[] salt, String data, char[] password) {
 		try {
 			SecretKey secret = composeKey(salt, password);
 			Cipher cipher = Cipher.getInstance(CIPHER_TYPE);
@@ -120,7 +100,7 @@ public class Encryption {
 			byte[] iv = params.getParameterSpec(GCMParameterSpec.class).getIV();
 			byte[] cipherText = cipher.doFinal(data.getBytes());
 
-			return new byte[][] { salt, iv, cipherText };
+			return new EncryptedComplex(salt, iv, cipherText);
 		} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException | IllegalBlockSizeException
 				| BadPaddingException | InvalidKeySpecException | InvalidParameterSpecException e) {
 			e.printStackTrace();
@@ -143,7 +123,7 @@ public class Encryption {
 	 * @param args
 	 */
 	public static void main(String[] args) {
-		byte[][] encrypted = encrypt("asd", "password".toCharArray());
+		EncryptedComplex encrypted = encrypt("asd", "password".toCharArray());
 		System.out.println(encrypted);
 		String decrypted = "";
 		try {

src/eu/tankernn/accounts/util/InvalidPasswordException.java → src/eu/tankernn/accounts/util/encryption/InvalidPasswordException.java

@@ -1,4 +1,4 @@
-package eu.tankernn.accounts.util;
+package eu.tankernn.accounts.util.encryption;
 
 public class InvalidPasswordException extends Exception {