feat: decryption with different algorithms and keylenghts

fix #24 fix #31

Author: modothprav

src/FileEncryptor.java

@@ -46,18 +46,21 @@ public class FileEncryptor {
     private static int BLOCKSIZE;
 
     // Error Message
-    private static final String validCmdMsg = "Valid Encryption commandL: java FileEncryptor enc [Passoword] [inputFile] [outputFile]\n"
-    + "Valid Encryption command: java FileEncryptor enc [Algorithm] [Key length] [Password] [inputFile] [outputFile]\n"
-    + "Valid Decryption command: java FileEncryptor dec [Password] [inputFile] [outputFile]\n"
-    + "Valid Info command: java FileEncryptor info [filePath]\n"
-    + "Valid Key lengths: 128. 448. 192. 32 etc"
+    private static final String ERROR_MSG = "\nValid Encryption command: java FileEncryptor enc [Passoword] [inputFile] [outputFile]\n"
+    + "\t\t\t  java FileEncryptor enc [Algorithm] [Key length] [Password] [inputFile] [outputFile]\n"
+    + "\t\t\t  java FileEncryptor enc [Algorithm] [Password] [inputFile] [outputFile]\n"
+    + "\t\t\t  java FileEncryptor enc [Key length] [Password] [inputFile] [outputFile]\n\n"
+    + "Valid Decryption command: java FileEncryptor dec [Password] [inputFile] [outputFile]\n\n"
+    + "Valid Info command: java FileEncryptor info [filePath]\n\n"
+    + "Valid Key lengths: 128, 448, 192, 32 etc\n\n"
     + "NOTE: The only algorithms accepted are AES and Blowfish\n"
     + "NOTE: Must specify a valid Key length (in bits) with respect to the algorithm specified\n"
-    + "NOTE: The default Algorithm being used is " + DEFAULT_ALGORITHM + " and the Default Key Length is " + DEFAULT_KEY_LENGTH;
+    + "NOTE: The default Algorithm being used is " + DEFAULT_ALGORITHM + " and the Default Key Length is " + DEFAULT_KEY_LENGTH + " bits\n"
+    + "NOTE: If no Algorithm or Key length is specifed the Default values will be used\n";
 
     public static void main(String[] args) throws Exception {
 
-        if (args.length < 2) { throw new IllegalArgumentException("Not Enough Argunments specified\n" + validCmdMsg); }
+        if (args.length < 2) { throw new IllegalArgumentException("Not Enough Argunments specified\n" + ERROR_MSG); }
 
         // Convert String arguments to char arrays
         char[][] charArgs = Util.getCharArguments(args);
@@ -70,14 +73,14 @@ public static void main(String[] args) throws Exception {
             return;
         }
 
-        if (charArgs.length < 4) { throw new IllegalArgumentException("Not Enough Argunments specified\n" + validCmdMsg); }
+        if (charArgs.length < 4) { throw new IllegalArgumentException("Not Enough Argunments specified\n" + ERROR_MSG); }
 
         // Options Available
         char[] enc = "enc".toCharArray();
         char[] dec = "dec".toCharArray();
 
         if (!Arrays.equals(charArgs[0], enc) && !Arrays.equals(charArgs[0], dec)) {
-            throw new IllegalArgumentException("Neither enc (encrypt), dec (decrypt) or info option specified\n" + validCmdMsg);
+            throw new IllegalArgumentException("Neither enc (encrypt), dec (decrypt) or info option specified\n" + ERROR_MSG);
         }
 
         if (Arrays.equals(charArgs[0], enc)) { // Encrypt
@@ -87,7 +90,7 @@ public static void main(String[] args) throws Exception {
 
             int argIndex = 1; // will get incremented everytime a valid argument is encountered
 
-            // If no algorithm argument is specified the Default will be applied
+            // If no or incompatiable algorithm argument is specified the Default will be applied
             if (Arrays.equals(charArgs[argIndex], aes) || Arrays.equals(charArgs[argIndex], blowfish)) {
                 ALGORITHM = new String(charArgs[1]);
                 CIPHER = ALGORITHM + "/CBC/PKCS5PADDING";
@@ -103,6 +106,7 @@ public static void main(String[] args) throws Exception {
 
             // If no Key length specified then the Default will be applied
             try {
+                // Perform Key length checks
                 int keyLength = Integer.parseInt(new String(charArgs[argIndex]));
                 if (keyLength % 8 != 0) { throw new IllegalArgumentException("Invalid Key Length: not divisible by 8"); }
 
@@ -115,17 +119,17 @@ public static void main(String[] args) throws Exception {
                 }
 
                 KEY_LENGTH = keyLength;
-
                 argIndex++;
             } catch (NumberFormatException e) {
                 KEY_LENGTH = DEFAULT_KEY_LENGTH;
             }
 
+            // Check if password and/or file paths have been specified
+            if (argIndex + 2 >= charArgs.length) { throw new IllegalArgumentException("Not enough arguments specified" + ERROR_MSG); }
+
             encrypt(charArgs[argIndex], new String(charArgs[argIndex + 1]), new String(charArgs[argIndex + 2]));
 
         } else if (Arrays.equals(charArgs[0], dec)) { // Decrypt
-            ALGORITHM = DEFAULT_ALGORITHM;
-            CIPHER = DEFAULT_CIPHER;
             decrypt(charArgs[1], new String(charArgs[2]), new String(charArgs[3]));
 
         }
@@ -159,8 +163,7 @@ public static void main(String[] args) throws Exception {
     public static void encrypt(char[] password, String inputPath, String outputPath) throws NoSuchAlgorithmException, 
     NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IOException, InvalidKeySpecException {
         //Generate vector and salts
-        final byte[] initVector = new byte[BLOCKSIZE/8];
-        final byte[] salt = new byte[16], macSalt = new byte[16];
+        final byte[] initVector = new byte[BLOCKSIZE/8], salt = new byte[16], macSalt = new byte[16];
 
         SecureRandom sr = new SecureRandom();
         sr.nextBytes(initVector); sr.nextBytes(salt); sr.nextBytes(macSalt);
@@ -221,7 +224,11 @@ private static boolean writeEncryptedFile(Path inputPath, Path outputPath, Ciphe
 
             try (FileOutputStream fout = new FileOutputStream(outputPath.toFile());) {
                 // Write Metadata
-                fout.write(cipher.getIV()); fout.write(salt); fout.write(macSalt); fout.write(mac);
+                final byte[] algorithm = Util.convertCharToByte(ALGORITHM.toCharArray());
+    
+                fout.write(BLOCKSIZE); fout.write(KEY_LENGTH/8); fout.write(algorithm.length);
+                fout.write(algorithm); fout.write(cipher.getIV()); fout.write(salt); 
+                fout.write(macSalt); fout.write(mac);
 
                 try (CipherOutputStream cipherOut = new CipherOutputStream(fout, cipher);) {
                     final byte[] bytes = new byte[1024];
@@ -295,13 +302,14 @@ public static void decrypt(char[] password, String inputPath, String outputPath)
     private static boolean writeDecryptedFile(Path inputPath, Path outputPath, char[] password) throws NoSuchAlgorithmException, 
     NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, InvalidKeySpecException {
         try (InputStream encryptedData = Files.newInputStream(inputPath);){
-        
             // Read metadata from the input file
-            final byte[] initVector = new byte[16], salt = new byte[16], macSalt = new byte[16], givenMac = new byte[32];
-            
+            BLOCKSIZE = encryptedData.read(); KEY_LENGTH = encryptedData.read() * 8; int algoLength = encryptedData.read();
+            ALGORITHM = new String(encryptedData.readNBytes(algoLength)); CIPHER = ALGORITHM + "/CBC/PKCS5PADDING";
+
+            final byte[] initVector = new byte[BLOCKSIZE/8], salt = new byte[16], macSalt = new byte[16], givenMac = new byte[32];
             encryptedData.read(initVector); encryptedData.read(salt); encryptedData.read(macSalt); encryptedData.read(givenMac);
 
-            final byte[] key = generateKey(password, salt, 128);
+            final byte[] key = generateKey(password, salt, KEY_LENGTH);
             final byte[] macKey = generateKey(password, macSalt, 256);
 
             // Password no longer needed