Update Number 1

Author: Virgula0

src/main/java/Arguments/DetectArgumentsFacade.java

@@ -19,15 +19,14 @@
 import java.security.InvalidKeyException;
 import java.security.NoSuchAlgorithmException;
 import java.security.spec.InvalidKeySpecException;
-import java.util.Arrays;
 import java.util.List;
 
 public class DetectArgumentsFacade implements Runnable {
 
-    private final String[] args;
+    private final List<String> args;
     private final List<Logger> logger;
 
-    public DetectArgumentsFacade(String[] arguments, List<Logger> log) {
+    public DetectArgumentsFacade(List<String> arguments, List<Logger> log) {
         this.args = arguments;
         this.logger = log;
     }
@@ -48,7 +47,7 @@ public void detectArguments() throws InterruptedException, NoSuchAlgorithmExcept
         OperatingSystemAbstract finalOP = op.matches(null);
         this.logger.add(FactoryClassUtility.getShellLogger(finalOP));
         encryptionsAvailable.setLoggers(logger);
-        Encryption enc = encryptionsAvailable.matches(Arrays.asList(args), this.logger);
+        Encryption enc = encryptionsAvailable.matches(args, this.logger);
         if (enc == null) {
             main.usage();
             throw new ArgumentsNotValidException("You must choose to use RSA or AES with -b option");

src/main/java/Encryption/AESEncryption.java

@@ -115,6 +115,7 @@ public void writeIv(File file) throws IOException {
         loggers.forEach(x -> x.log("IV wrote into: " + file.toPath()));
     }
 
+
     private IvParameterSpec generateIv() {
         byte[] iv = new byte[16];
         new SecureRandom().nextBytes(iv);

src/main/java/Encryption/AsyncEncryption.java

@@ -19,17 +19,66 @@
  * Default is set to false
  **/
 public interface AsyncEncryption extends Encryption {
+    /**
+     * Get Public Key in PEM Format
+     *
+     * @return PEM public key as a string
+     */
     String getPEMPublicKey();
 
+    /**
+     * Get Private Key in PEM Format
+     *
+     * @return PEM private key as a string
+     */
     String getPEMPrivateKey();
 
+    /**
+     * Set the size key. Should be a power of 2. 2^10=1024 for example.
+     *
+     * @return void
+     */
     void setKeySize(int size) throws NoSuchAlgorithmException;
 
+    /**
+     * Set the public key. You should provide a public key with the following format:
+     * <p>
+     * -----BEGIN PUBLIC KEY-----
+     * XXXXXXXXXXXXXXXXXXXXXXXXXX
+     * -----END PUBLIC KEY-----
+     *
+     * @param publicKey
+     * @throws InvalidKeySpecException  The Specified key is not in the correct format.
+     * @throws NoSuchAlgorithmException Algorithm not found.
+     */
     void setPublicKey(String publicKey) throws InvalidKeySpecException, NoSuchAlgorithmException;
 
+    /**
+     * Set the private key. You should provide a private key with the following format:
+     * <p>
+     * -----BEGIN RSA PRIVATE KEY-----
+     * XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+     * -----END RSA PRIVATE KEY-----
+     *
+     * @param privateKey
+     * @throws InvalidKeySpecException  The Specified key is not in the correct format.
+     * @throws NoSuchAlgorithmException Algorithm not found.
+     */
     void setPrivateKey(String privateKey) throws InvalidKeySpecException, NoSuchAlgorithmException;
 
+    /**
+     * Write the generated or set public key into a file with a PEM format.
+     *
+     * @param file
+     * @throws IOException
+     */
     void writePublicKeyToFile(File file) throws IOException;
 
+    /**
+     * Write the generated or set private key into a file with a PEM format.
+     *
+     * @param file
+     * @throws IOException
+     */
     void writePrivateKeyToFile(File file) throws IOException;
 }

src/main/java/Encryption/SimmetricEncryption.java

@@ -8,21 +8,21 @@
 import java.security.spec.InvalidKeySpecException;
 
 /**
- * -s <128 | 192 | 256> specify the size of the key with one of the shown value.                                \n" +
- * Default is 128.                                                                                      \n" +
- * -fiv <FILELOCATION> specify the hexadecimal file where specified VI islocated                                \n" +
- * -p <PASS:SALT> specify a password for encryption/decryption with the specified PASS and SALT                 \n" +
- * -k <KEYFILELOCATION> specify location for setting a specific Base64 encoded key                              \n" +
- * -a <CBS|CFB|OFB|CTR|GCM> choose alghorithm type                                                              \n" +
- * Default is CBS                                                                                       \n" +
- * -wiv <FILENAME> Creates a file with the latest VI used or the specified one if there is.                     \n" +
- * -wk <FILENAME> Creates a file with the latest Key Encoded value used or the specified one if there is.       \n" +
- * -i <FILENAME> Input file encrypted/decrypted or physical file to encrypt/decrypt.                            \n" +
- * -o <FILENAME> Output file to specify if you want to encrypt/decrypt an entire physical file or               \n" +
- * where you want to save encrypted/decrypted content.                                            \n" +
- * -v Set verbose to true                                                                                       \n" +
+ * -s <128 | 192 | 256> specify the size of the key with one of the shown value.
+ * Default is 128.
+ * -fiv <FILELOCATION> specify the hexadecimal file where specified VI islocated
+ * -p <PASS:SALT> specify a password for encryption/decryption with the specified PASS and SALT
+ * -k <KEYFILELOCATION> specify location for setting a specific Base64 encoded key
+ * -a <CBS|CFB|OFB|CTR|GCM> choose alghorithm type
+ * Default is CBS
+ * -wiv <FILENAME> Creates a file with the latest VI used or the specified one if there is.
+ * -wk <FILENAME> Creates a file with the latest Key Encoded value used or the specified one if there is.
+ * -i <FILENAME> Input file encrypted/decrypted or physical file to encrypt/decrypt.
+ * -o <FILENAME> Output file to specify if you want to encrypt/decrypt an entire physical file or
+ * where you want to save encrypted/decrypted content.
+ * -v Set verbose to true
  * Default is set to false
- */
+ **/
 public interface SimmetricEncryption extends Encryption {
     /**
      * The method can be used to set a password to encrypt data
@@ -43,16 +43,49 @@ public interface SimmetricEncryption extends Encryption {
      */
     void setIv(String iv);
 
+    /**
+     * Write Iv Generated (Or set with setIv method) in a file.
+     *
+     * @param file
+     * @throws IOException
+     */
     void writeIv(File file) throws IOException;
 
+    /**
+     * Write Key Generated (Or set with setKey method) in a file.
+     *
+     * @param file
+     * @throws IOException
+     */
     void writeKey(File file) throws IOException;
 
+    /**
+     * Set size with the generated key which will be used when encrypting/decrypting.
+     *
+     * @param size
+     */
     void setSize(int size);
 
+    /**
+     * Set algorithm default: AES/CBC/PKCS5Padding
+     * Replace CBS with CFB OR OFB OR CTR OR GCM.
+     *
+     * @param algo
+     */
     void setAlgo(String algo);
 
+    /**
+     * Get the generated IV or setted IV as a string of bytes
+     *
+     * @return
+     */
     String getIV();
 
+    /**
+     * Get the generated key as Base64 encoded String value.
+     *
+     * @return
+     */
     String getKey();
 
     /**
@@ -61,4 +94,5 @@ public interface SimmetricEncryption extends Encryption {
      * @param password set the encoded password for the AES cipher
      */
     void setKey(String password);
+
 }

src/main/java/Loggers/ConsoleLogger.java

@@ -54,11 +54,11 @@ public void changeableLogger(String str) {
     }
 
     @Override
-    public String getHasChangedLog() throws IOException {
+    public String getHasChangedLog() throws IOException, InterruptedException {
         boolean cng = this.changed;
         if (cng) {
             this.changed = false;
-            new ProcessBuilder(this.op.clearTerminalCommand()).inheritIO().start();
+            new ProcessBuilder(this.op.clearTerminalCommand()).inheritIO().start().waitFor();//waitFor(100,TimeUnit.MILLISECONDS);
             return changeableBuilder.toString();
         }
         return null;

src/main/java/main/main.java

@@ -6,6 +6,7 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 public class main {
@@ -22,7 +23,7 @@ public static void usage() {
                 "      -fiv <FILELOCATION> specify the hexadecimal file where specified VI islocated                                \n" +
                 "      -p <PASS:SALT> specify a password for encryption/decryption with the specified PASS and SALT                 \n" +
                 "      -k <KEYFILELOCATION> specify location for setting a specific Base64 encoded key                              \n" +
-                "      -a <CBS|CFB|OFB|CTR|GCM> choose alghorithm type                                                              \n" +
+                "      -a <CBC|CFB|OFB|CTR> choose alghorithm type                                                              \n" +
                 "              Default is CBS                                                                                       \n" +
                 "      -wiv <FILENAME> Creates a file with the latest VI used or the specified one if there is.                     \n" +
                 "      -wk <FILENAME> Creates a file with the latest Key Encoded value used or the specified one if there is.       \n" +
@@ -59,28 +60,29 @@ public static void main(String... args) throws InterruptedException, IOException
             System.exit(0);
         }
 
-        DetectArgumentsFacade instance = new DetectArgumentsFacade(args, new ArrayList<>());
+        List<String> arguments = Arrays.asList(args);
+
+        DetectArgumentsFacade instance = new DetectArgumentsFacade(arguments, new ArrayList<>());
         Thread a = new Thread(instance);
         a.start();
 
         List<Logger> loggers = instance.getLoggers();
+        boolean bool = false;
 
-        while (true) {
-            /*
-            loggers.forEach(x -> {
-                String s = x.getLogs();
-                if (!s.isEmpty())
-                        System.out.print(s);
-            });
+        if (arguments.contains("-v"))
+            bool = true;
 
-             */
+        while (true) {
             for (Logger x : loggers) {
                 String s = x.getHasChangedLog();
                 String z = x.getLogs();
-                if (!z.isEmpty())
+                if (z != null && !z.isEmpty())
                     System.out.print(z);
-                if (s != null)
+                if (s != null) {
                     System.out.print(s);
+                    if (bool)
+                        Thread.sleep(250);
+                }
             }
         }
     }