Initial commit for Network Information Security Exercises

Signed-off-by: Tuan-Dat Tran <tuan-dat.tran@tudattr.dev>

src/de/unidue/iem/tdr/nis/client/Loesungsmethoden.java

@@ -0,0 +1,219 @@
+package de.unidue.iem.tdr.nis.client;
+
+/**
+ * Created by tu on 15/05/17.
+ */
+public class Loesungsmethoden {
+
+    /**
+     * Staendig geteilt die kleinste moegliche Primzahl rechnen
+     */
+    public String factorization(int num) {
+        // 126 / 2 = 63 -> nicht weiter durch 2 teilbar, naechste p
+        // 63 / 3 = 21 -> weiter durch 3 teilbar, 3 weiternutzen
+        // 21 / 3 = 7 -> nicht weiter durch 3 teilbar, naechste p
+        // 7 / 7 = 1 -> fertig
+        // returns 2, 3, 3, 7;
+        StringBuilder sb = new StringBuilder();
+        int result = num;
+        int prime = 2;
+        while (result != 1) {
+            prime = 2;
+            while (!devideable(result, prime)) {
+                prime = getNextPrime(prime, num);
+            }
+            result /= prime;
+            sb.append(prime).append("*");
+        }
+        sb.deleteCharAt(sb.length() - 1);
+        return sb.toString();
+    }
+
+    private boolean devideable(int devidable, int by) {
+        return (devidable % by) == 0;
+    }
+
+    private int getNextPrime(int initPrime, int cap) {
+        for (int i = initPrime; i <= cap; i++) {
+            if (isPrime(i) && !(i == initPrime || i == cap)) {
+                return i;
+            }
+        }
+        System.exit(0);
+        return 0;
+    }
+
+    private boolean isPrime(int possPrime) {
+        if (possPrime == 0) {
+            return false;
+        }
+        for (int i = 1; i <= possPrime; i++) {
+            if (!(i == 1 || i == possPrime)) {
+                return !devideable(possPrime, i);
+            }
+        }
+        return true;
+    }
+
+    public String stringXOR(String one, String two) {
+        if (!(one.length() == two.length())) {
+            String appendable = "";
+            if (one.length() < two.length()) {
+                for (int i = 0; i < two.length() - one.length(); i++) {
+                    appendable += "0";
+                }
+                one = appendable + one;
+            } else {
+                for (int i = 0; i < one.length() - two.length(); i++) {
+                    appendable += "0";
+                }
+                two = appendable + two;
+            }
+        }
+        char firstBit;
+        char secondBit;
+        StringBuilder result = new StringBuilder();
+        for (int i = 0; i < one.length(); i++) {
+            firstBit = one.charAt(i);
+            secondBit = two.charAt(i);
+            result.append(charXOR(firstBit, secondBit));
+        }
+        return result.toString();
+    }
+
+    private char charXOR(char a, char b) {
+        if (a == b) {
+            return '0';
+        } else if (a != b) {
+            return '1';
+        }
+        return '.';
+    }
+
+    public String stringConv(String hex) {
+        StringBuilder result = new StringBuilder();
+        for (int i = 0; i < hex.length(); i++) {
+            String bite = hexConv(hex.charAt(i));
+            result.append(bite);
+        }
+        return result.toString();
+    }
+
+    private String hexConv(char hex) {
+        switch (hex) {
+            case '0':
+                return "0000";
+            case '1':
+                return "0001";
+            case '2':
+                return "0010";
+            case '3':
+                return "0011";
+            case '4':
+                return "0100";
+            case '5':
+                return "0101";
+            case '6':
+                return "0110";
+            case '7':
+                return "0111";
+            case '8':
+                return "1000";
+            case '9':
+                return "1001";
+            case 'a':
+                return "1010";
+            case 'b':
+                return "1011";
+            case 'c':
+                return "1100";
+            case 'd':
+                return "1101";
+            case 'e':
+                return "1110";
+            case 'f':
+                return "1111";
+            default:
+                return "empty";
+        }
+    }
+
+    public int MOD(int a, int b) {
+        // 21 mod 10
+        // 21 - 10 = 11
+        // 11 - 10 = 1
+        // oops 1 - 10 is negative 👍
+        while ((a - b) > 0) {
+            a -= b;
+        }
+        return a;
+    }
+
+    public String decrypt_vigenere(String c_msg, String key) {
+        char[][] vigArray = getVigenereTable();
+        char[] c_msgArray = c_msg.toCharArray();
+        char[] keyArray = key.toCharArray();
+        StringBuilder de_msg = new StringBuilder();
+        for(int i = 0; i<c_msgArray.length; i++){
+            for (int j = 0; j < vigArray.length; j++) {
+                if (c_msgArray[i]==vigArray[keyArray[][j]]){
+                    de_msg.append(c_msgArray);
+                }
+            }
+        }
+        return de_msg.toString();
+    }
+
+    private char[][] getVigenereTable() {
+        char[][] vigTable = new char[26][26];
+        for (int i = vigTable.length-1; i >= 0; i--) {
+            vigTable[vigTable.length-1-i] = vigenereArray(i+1);
+        }
+        return vigTable;
+    }
+
+    private char[] vigenereArray(int rot) {
+        char[] vigenereTable = new char[26];
+        char[] asciiTable = getASCIITable();
+        if(rot%26==0){
+            return asciiTable;
+        }
+        for (int i = 0; i < vigenereTable.length; i++) {
+            vigenereTable[(i+rot) % vigenereTable.length ] = getASCIITable()[i];
+        }
+        return vigenereTable;
+    }
+
+    private char[] getASCIITable() {
+        char[] table = new char[26];
+        int j = 0;
+        for (int i = 1; i <= 26; i++) {
+            table[j] = getAsciiLetter(i);
+            j++;
+        }
+        return table;
+    }
+
+    private char getAsciiLetter(int ord) {
+        if (ord > 26 || ord <= 0) {
+            ord = -96;
+        }
+        ord = ord + 96;
+        return (char) ord;
+    }
+
+    private int getAsciiNumber(char chr){
+        return (int) chr;
+    }
+
+    public static void main(String[] args) {
+        Loesungsmethoden lm = new Loesungsmethoden();
+        int index = 0;
+        for(char[] sub: lm.getVigenereTable()){
+            for(char i: sub){
+                System.out.print(i);
+            }
+            System.out.println();
+        }
+    }
+}