From 520ee69e342aaeec45ae6676d987f48401428415 Mon Sep 17 00:00:00 2001
From: khalil2535 <khalil2535@localhost>
Date: Sat, 14 Apr 2018 06:39:16 +0300
Subject: [PATCH] Update chiphers

---
 ciphers/ColumnarTranspositionCipher.java | 216 +++++++++++++----------
 ciphers/RSA.java                         |  74 ++++++--
 2 files changed, 178 insertions(+), 112 deletions(-)

diff --git a/ciphers/ColumnarTranspositionCipher.java b/ciphers/ColumnarTranspositionCipher.java
index b12743715..0b79bcc1b 100644
--- a/ciphers/ColumnarTranspositionCipher.java
+++ b/ciphers/ColumnarTranspositionCipher.java
@@ -1,29 +1,36 @@
-/**
+package ciphers;
+
+/**
  * Columnar Transposition Cipher Encryption and Decryption.
+ *
  * @author <a href="https://github.com/freitzzz">freitzzz</a>
  */
 public class ColumnarTranspositionCipher {
+
     private static String keyword;
     private static Object[][] table;
     private static String abecedarium;
-    public static final String ABECEDARIUM="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789,.;:-@";
-    private static final String ENCRYPTION_FIELD="≈";
-    private static final char ENCRYPTION_FIELD_CHAR='≈';
+    public static final String ABECEDARIUM = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789,.;:-@";
+    private static final String ENCRYPTION_FIELD = "≈";
+    private static final char ENCRYPTION_FIELD_CHAR = '≈';
+
     /**
      * Encrypts a certain String with the Columnar Transposition Cipher Rule
+     *
      * @param word Word being encrypted
      * @param keyword String with keyword being used
-     * @return a String with the word encrypted by the Columnar Transposition Cipher Rule
+     * @return a String with the word encrypted by the Columnar Transposition
+     * Cipher Rule
      */
-    public static String encrpyter(String word,String keyword){
-        ColumnarTranspositionCipher.keyword=keyword;
+    public static String encrpyter(String word, String keyword) {
+        ColumnarTranspositionCipher.keyword = keyword;
         abecedariumBuilder(500);
-        table=tableBuilder(word);
-        Object[][] sortedTable=sortTable(table);
-        String wordEncrypted="";
-        for(int i=0;i<sortedTable[0].length;i++){
-            for(int j=1;j<sortedTable.length;j++){
-                wordEncrypted+=sortedTable[j][i];
+        table = tableBuilder(word);
+        Object[][] sortedTable = sortTable(table);
+        String wordEncrypted = "";
+        for (int i = 0; i < sortedTable[i].length; i++) {
+            for (int j = 1; j < sortedTable.length; j++) {
+                wordEncrypted += sortedTable[j][i];
             }
         }
         return wordEncrypted;
@@ -31,138 +38,161 @@ public class ColumnarTranspositionCipher {
 
     /**
      * Encrypts a certain String with the Columnar Transposition Cipher Rule
+     *
      * @param word Word being encrypted
      * @param keyword String with keyword being used
-     * @param abecedarium String with the abecedarium being used. null for default one
-     * @return a String with the word encrypted by the Columnar Transposition Cipher Rule
+     * @param abecedarium String with the abecedarium being used. null for
+     * default one
+     * @return a String with the word encrypted by the Columnar Transposition
+     * Cipher Rule
      */
-    public static String encrpyter(String word,String keyword,String abecedarium){
-        ColumnarTranspositionCipher.keyword=keyword;
-        if(abecedarium!=null){
-            ColumnarTranspositionCipher.abecedarium=abecedarium;
-        }else{
-            ColumnarTranspositionCipher.abecedarium=ABECEDARIUM;
+    public static String encrpyter(String word, String keyword, String abecedarium) {
+        ColumnarTranspositionCipher.keyword = keyword;
+        if (abecedarium != null) {
+            ColumnarTranspositionCipher.abecedarium = abecedarium;
+        } else {
+            ColumnarTranspositionCipher.abecedarium = ABECEDARIUM;
         }
-        table=tableBuilder(word);
-        Object[][] sortedTable=sortTable(table);
-        String wordEncrypted="";
-        for(int i=0;i<sortedTable[0].length;i++){
-            for(int j=1;j<sortedTable.length;j++){
-                wordEncrypted+=sortedTable[j][i];
+        table = tableBuilder(word);
+        Object[][] sortedTable = sortTable(table);
+        String wordEncrypted = "";
+        for (int i = 0; i < sortedTable[0].length; i++) {
+            for (int j = 1; j < sortedTable.length; j++) {
+                wordEncrypted += sortedTable[j][i];
             }
         }
         return wordEncrypted;
     }
+
     /**
-     * Decryps a certain encrypted String with the Columnar Transposition Cipher Rule
-     * @return a String decrypted with the word ecrypted by the Columnar Transpositiion Cipher Rule
+     * Decrypts a certain encrypted String with the Columnar Transposition
+     * Cipher Rule
+     *
+     * @return a String decrypted with the word encrypted by the Columnar
+     * Transposition Cipher Rule
      */
-    public static String decrypter(){
-        String wordDecrypted="";
-        for(int i=1;i<table.length;i++){
-            for(int j=0;j<table[i].length;j++){
-                wordDecrypted+=table[i][j];
+    public static String decrypter() {
+        String wordDecrypted = "";
+        for (int i = 1; i < table.length; i++) {
+            for (Object item : table[i]) {
+                wordDecrypted += item;
             }
         }
-        return wordDecrypted.replaceAll(ENCRYPTION_FIELD,"");
+        return wordDecrypted.replaceAll(ENCRYPTION_FIELD, "");
     }
+
     /**
-     * Builds a table with the word to be encrpyted in rows by the Columnar Transposition Cipher Rule
-     * @return An Object[][] with the word to be encrypted filled in rows and columns
+     * Builds a table with the word to be encrypted in rows by the Columnar
+     * Transposition Cipher Rule
+     *
+     * @return An Object[][] with the word to be encrypted filled in rows and
+     * columns
      */
-    private static Object[][] tableBuilder(String word){
-        Object[][] table=new Object[rows(word)+1][keyword.length()];
-        char[] wordInChards=word.toCharArray();
+    private static Object[][] tableBuilder(String word) {
+        Object[][] table = new Object[numberOfRows(word) + 1][keyword.length()];
+        char[] wordInChards = word.toCharArray();
         //Fils in the respective numbers
-        table[0]=findElements();
-        int charElement=0;
-        for(int i=1;i<table.length;i++){
-            for(int j=0;j<table[i].length;j++){
-                if(charElement<wordInChards.length){
-                    table[i][j]=(char)wordInChards[charElement];
+        table[0] = findElements();
+        int charElement = 0;
+        for (int i = 1; i < table.length; i++) {
+            for (int j = 0; j < table[i].length; j++) {
+                if (charElement < wordInChards.length) {
+                    table[i][j] = wordInChards[charElement];
                     charElement++;
-                }else{
-                    table[i][j]=ENCRYPTION_FIELD_CHAR;
+                } else {
+                    table[i][j] = ENCRYPTION_FIELD_CHAR;
                 }
             }
         }
         return table;
     }
+
     /**
-     * Determines the number of rows the table should have regarding the Columnar Transposition Cipher Rule
-     * @return an int with the number of rows that the table should have in order to respect the Columnar Transposition Cipher Rule.
+     * Determines the number of rows the table should have regarding the
+     * Columnar Transposition Cipher Rule
+     *
+     * @return an int with the number of rows that the table should have in
+     * order to respect the Columnar Transposition Cipher Rule.
      */
-    private static int rows(String word){
-        if((double)word.length()/keyword.length()>word.length()/keyword.length()){
-            return (word.length()/keyword.length())+1;
-        }else{
-            return word.length()/keyword.length();
+    private static int numberOfRows(String word) {
+        if ((double) word.length() / keyword.length() > word.length() / keyword.length()) {
+            return (word.length() / keyword.length()) + 1;
+        } else {
+            return word.length() / keyword.length();
         }
     }
-    private static Object[] findElements(){
-        Object[] charValues=new Object[keyword.length()];
-        for(int i=0;i<charValues.length;i++){
-            for(int j=0;j<abecedarium.length();j++){
-                if(keyword.charAt(i)==abecedarium.charAt(j))charValues[i]=j;
+
+    private static Object[] findElements() {
+        Object[] charValues = new Object[keyword.length()];
+        for (int i = 0; i < charValues.length; i++) {
+            for (int j = 0; j < abecedarium.length(); j++) {
+                if (keyword.charAt(i) == abecedarium.charAt(j)) {
+                    charValues[i] = j;
+                }
             }
         }
         return charValues;
     }
-    private static Object[][] sortTable(Object[][] table){
-        Object[][] tableSorted=new Object[table.length][table[0].length];
-        for(int i=0;i<tableSorted.length;i++){
-            for(int j=0;j<tableSorted[i].length;j++){
-                tableSorted[i][j]=table[i][j];
-            }
+
+    private static Object[][] sortTable(Object[][] table) {
+        Object[][] tableSorted = new Object[table.length][table[0].length];
+        for (int i = 0; i < tableSorted.length; i++) {
+            System.arraycopy(table[i], 0, tableSorted[i], 0, tableSorted[i].length);
         }
-        for(int i=0;i<tableSorted[0].length;i++){
-            for(int j=i+1;j<tableSorted[0].length;j++){
-                if((int)tableSorted[0][i]>(int)table[0][j]){
-                    Object[] column=getColumn(tableSorted,tableSorted.length,i);
-                    switchColumns(tableSorted,j,i,column);
+        for (int i = 0; i < tableSorted[0].length; i++) {
+            for (int j = i + 1; j < tableSorted[0].length; j++) {
+                if ((int) tableSorted[0][i] > (int) table[0][j]) {
+                    Object[] column = getColumn(tableSorted, tableSorted.length, i);
+                    switchColumns(tableSorted, j, i, column);
                 }
             }
         }
         return tableSorted;
     }
-    private static Object[] getColumn(Object[][] table,int rows,int column){
-        Object[] columnArray=new Object[rows];
-        for(int i=0;i<rows;i++){
-            columnArray[i]=table[i][column];
+
+    private static Object[] getColumn(Object[][] table, int rows, int column) {
+        Object[] columnArray = new Object[rows];
+        for (int i = 0; i < rows; i++) {
+            columnArray[i] = table[i][column];
         }
         return columnArray;
     }
-    private static void switchColumns(Object[][] table, int firstColumnIndex,int secondColumnIndex,Object[] columnToSwitch){
-        for(int i=0;i<table.length;i++){
-            table[i][secondColumnIndex]=table[i][firstColumnIndex];
-            table[i][firstColumnIndex]=columnToSwitch[i];
+
+    private static void switchColumns(Object[][] table, int firstColumnIndex, int secondColumnIndex, Object[] columnToSwitch) {
+        for (int i = 0; i < table.length; i++) {
+            table[i][secondColumnIndex] = table[i][firstColumnIndex];
+            table[i][firstColumnIndex] = columnToSwitch[i];
         }
     }
+
     /**
      * Creates an abecedarium with a specified ascii inded
+     *
      * @param value Number of characters being used based on the ASCII Table
      */
-    private static void abecedariumBuilder(int value){
-        abecedarium="";
-        for(int i=0;i<value;i++){
-            abecedarium+=(char)i;
+    private static void abecedariumBuilder(int value) {
+        abecedarium = "";
+        for (int i = 0; i < value; i++) {
+            abecedarium += (char) i;
         }
     }
-    private static void showTable(){
-        for(int i=0;i<table.length;i++){
-            for(int j=0;j<table[i].length;j++){
-                System.out.print(table[i][j]+" ");
+
+    private static void showTable() {
+        for (Object[] table1 : table) {
+            for (Object item : table1) {
+                System.out.print(item + " ");
             }
             System.out.println();
         }
     }
-    public static void main(String[] args){
-        String keywordForExample="asd215";
-        String wordBeingEncrypted="This is a test of the Columnar Transposition Cipher";
+
+    public static void main(String[] args) {
+        String keywordForExample = "asd215";
+        String wordBeingEncrypted = "This is a test of the Columnar Transposition Cipher";
         System.out.println("### Example of Columnar Transposition Cipher ###\n");
-        System.out.println("Word being encryped ->>> "+wordBeingEncrypted);
-        System.out.println("Word encrypted ->>> "+ColumnarTranspositionCipher.encrpyter(wordBeingEncrypted,keywordForExample));
-        System.out.println("Word decryped ->>> "+ColumnarTranspositionCipher.decrypter());
+        System.out.println("Word being encryped ->>> " + wordBeingEncrypted);
+        System.out.println("Word encrypted ->>> " + ColumnarTranspositionCipher.encrpyter(wordBeingEncrypted, keywordForExample));
+        System.out.println("Word decryped ->>> " + ColumnarTranspositionCipher.decrypter());
         System.out.println("\n### Encrypted Table ###");
         showTable();
     }
diff --git a/ciphers/RSA.java b/ciphers/RSA.java
index 5baa61b04..acb99f0f6 100644
--- a/ciphers/RSA.java
+++ b/ciphers/RSA.java
@@ -2,34 +2,82 @@ package ciphers;
 
 import java.math.BigInteger;
 import java.security.SecureRandom;
+import javax.swing.JOptionPane;
 
 /**
- * Created by Nguyen Duy Tiep on 23-Oct-17.
+ * @author Nguyen Duy Tiep on 23-Oct-17.
  */
-public class RSA {
+public final class RSA {
+
+    /**
+     * Trivial test program.
+     *
+     * @param args
+     * @deprecated TODO remove main and make JUnit Testing or any other
+     * methodology
+     */
+    public static void main(String[] args) {
+
+        RSA rsa = new RSA(1024);
+        String text1 = JOptionPane.showInputDialog("Enter a message to encrypt :");
+
+        String ciphertext = rsa.encrypt(text1);
+        JOptionPane.showMessageDialog(null, "Your encrypted message : " + ciphertext);
+
+        JOptionPane.showMessageDialog(null, "Your message after decrypt : " + rsa.decrypt(ciphertext));
+    }
+
     private BigInteger modulus, privateKey, publicKey;
 
+    /**
+     *
+     * @param bits
+     */
     public RSA(int bits) {
         generateKeys(bits);
     }
 
+    /**
+     *
+     * @param message
+     * @return encrypted message
+     */
     public synchronized String encrypt(String message) {
         return (new BigInteger(message.getBytes())).modPow(publicKey, modulus).toString();
     }
 
+    /**
+     *
+     * @param message
+     * @return encrypted message as big integer
+     */
     public synchronized BigInteger encrypt(BigInteger message) {
         return message.modPow(publicKey, modulus);
     }
 
-    public synchronized String decrypt(String message) {
-        return new String((new BigInteger(message)).modPow(privateKey, modulus).toByteArray());
+    /**
+     *
+     * @param encryptedMessage
+     * @return plain message
+     */
+    public synchronized String decrypt(String encryptedMessage) {
+        return new String((new BigInteger(encryptedMessage)).modPow(privateKey, modulus).toByteArray());
     }
 
-    public synchronized BigInteger decrypt(BigInteger message) {
-        return message.modPow(privateKey, modulus);
+    /**
+     *
+     * @param encryptedMessage
+     * @return plain message as big integer
+     */
+    public synchronized BigInteger decrypt(BigInteger encryptedMessage) {
+        return encryptedMessage.modPow(privateKey, modulus);
     }
 
-    /** Generate a new public and private key set. */
+    /**
+     * Generate a new public and private key set.
+     *
+     * @param bits
+     */
     public synchronized void generateKeys(int bits) {
         SecureRandom r = new SecureRandom();
         BigInteger p = new BigInteger(bits / 2, 100, r);
@@ -47,16 +95,4 @@ public class RSA {
         privateKey = publicKey.modInverse(m);
     }
 
-    /** Trivial test program. */
-    public static void main(String[] args) {
-        RSA rsa = new RSA(1024);
-
-        String text1 = "This is a message";
-        System.out.println("Plaintext: " + text1);
-
-        String ciphertext = rsa.encrypt(text1);
-        System.out.println("Ciphertext: " + ciphertext);
-
-        System.out.println("Plaintext: " + rsa.decrypt(ciphertext));
-    }
 }