Multiples languages

Week4/Multiple Languages/VigenereProgram/CaesarCipher.ctxt

@@ -0,0 +1,19 @@
+#BlueJ class context
+comment0.target=CaesarCipher
+comment1.params=key
+comment1.target=CaesarCipher(int)
+comment2.params=c\ from\ to
+comment2.target=char\ transformLetter(char,\ java.lang.String,\ java.lang.String)
+comment3.params=c
+comment3.target=char\ encryptLetter(char)
+comment4.params=c
+comment4.target=char\ decryptLetter(char)
+comment5.params=input\ from\ to
+comment5.target=java.lang.String\ transform(java.lang.String,\ java.lang.String,\ java.lang.String)
+comment6.params=input
+comment6.target=java.lang.String\ encrypt(java.lang.String)
+comment7.params=input
+comment7.target=java.lang.String\ decrypt(java.lang.String)
+comment8.params=
+comment8.target=java.lang.String\ toString()
+numComments=9

Week4/Multiple Languages/VigenereProgram/CaesarCipher.java

@@ -0,0 +1,55 @@
+import edu.duke.*;
+
+public class CaesarCipher {
+    private String alphabet;
+    private String shiftedAlphabet;
+    private int theKey;
+
+    public CaesarCipher(int key) {
+        theKey = key;
+        alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        shiftedAlphabet = alphabet.substring(key) +
+                            alphabet.substring(0,key);
+        alphabet = alphabet + alphabet.toLowerCase();
+        shiftedAlphabet = shiftedAlphabet + shiftedAlphabet.toLowerCase();
+    }
+
+    private char transformLetter(char c, String from, String to) {
+        int idx = from.indexOf(c);
+        if (idx != -1) {
+            return to.charAt(idx);
+        }
+        return c;
+    }
+
+    public char encryptLetter(char c) {
+        return transformLetter(c, alphabet, shiftedAlphabet);
+    }
+
+    public char decryptLetter(char c) {
+        return transformLetter(c, shiftedAlphabet, alphabet);
+    }
+
+    private String transform(String input, String from, String to){
+        StringBuilder sb = new StringBuilder(input);
+        for (int i = 0; i < sb.length(); i++) {
+            char c = sb.charAt(i);
+            c = transformLetter(c, from, to);
+            sb.setCharAt(i, c);
+        }
+        return sb.toString();
+    }
+
+    public String encrypt(String input) {
+        return transform(input, alphabet, shiftedAlphabet);
+    }
+
+    public String decrypt(String input) {
+        return transform(input, shiftedAlphabet, alphabet);
+    }
+
+    public String toString() {
+        return "" + theKey;
+    }
+
+}

Week4/Multiple Languages/VigenereProgram/CaesarCracker.ctxt

@@ -0,0 +1,15 @@
+#BlueJ class context
+comment0.target=CaesarCracker
+comment1.params=
+comment1.target=CaesarCracker()
+comment2.params=c
+comment2.target=CaesarCracker(char)
+comment3.params=message
+comment3.target=int[]\ countLetters(java.lang.String)
+comment4.params=vals
+comment4.target=int\ maxIndex(int[])
+comment5.params=encrypted
+comment5.target=int\ getKey(java.lang.String)
+comment6.params=encrypted
+comment6.target=java.lang.String\ decrypt(java.lang.String)
+numComments=7

Week4/Multiple Languages/VigenereProgram/CaesarCracker.java

@@ -0,0 +1,53 @@
+import edu.duke.*;
+
+public class CaesarCracker {
+    char mostCommon;
+
+    public CaesarCracker() {
+        mostCommon = 'e';
+    }
+
+    public CaesarCracker(char c) {
+        mostCommon = c;
+    }
+
+    public int[] countLetters(String message){
+        String alph = "abcdefghijklmnopqrstuvwxyz";
+        int[] counts = new int[26];
+        for(int k=0; k < message.length(); k++){
+            int dex = alph.indexOf(Character.toLowerCase(message.charAt(k)));
+            if (dex != -1){
+                counts[dex] += 1;
+            }
+        }
+        return counts;
+    }
+
+    public int maxIndex(int[] vals){
+        int maxDex = 0;
+        for(int k=0; k < vals.length; k++){
+            if (vals[k] > vals[maxDex]){
+                maxDex = k;
+            }
+        }
+        return maxDex;
+    }
+
+    public int getKey(String encrypted){
+        int[] freqs = countLetters(encrypted);
+        int maxDex = maxIndex(freqs);
+        int mostCommonPos = mostCommon - 'a';
+        int dkey = maxDex - mostCommonPos;
+        if (maxDex < mostCommonPos) {
+            dkey = 26 - (mostCommonPos-maxDex);
+        }
+        return dkey;
+    }
+
+    public String decrypt(String encrypted){
+        int key = getKey(encrypted);
+        CaesarCipher cc = new CaesarCipher(key);
+        return cc.decrypt(encrypted);
+    }
+
+}

Week4/Multiple Languages/VigenereProgram/VigenereBreaker.ctxt

@@ -0,0 +1,19 @@
+#BlueJ class context
+comment0.target=VigenereBreaker
+comment1.params=message\ whichSlice\ totalSlices
+comment1.target=java.lang.String\ sliceString(java.lang.String,\ int,\ int)
+comment2.params=encrypted\ klength\ mostCommon
+comment2.target=int[]\ tryKeyLength(java.lang.String,\ int,\ char)
+comment3.params=fr
+comment3.target=java.util.HashSet\ readDictionary(edu.duke.FileResource)
+comment4.params=message\ dict
+comment4.target=int\ countWords(java.lang.String,\ java.util.HashSet)
+comment5.params=encrypted\ dict
+comment5.target=java.lang.String\ breakForLanguage(java.lang.String,\ java.util.HashSet)
+comment6.params=dict
+comment6.target=char\ mostCommomCharIn(java.util.HashSet)
+comment7.params=encrypted\ MyMap
+comment7.target=java.lang.String\ breakForAllLangs(java.lang.String,\ java.util.HashMap)
+comment8.params=
+comment8.target=java.lang.String\ breakVigenere()
+numComments=9

Week4/Multiple Languages/VigenereProgram/VigenereBreaker.java

@@ -0,0 +1,155 @@
+import java.util.*;
+import edu.duke.*;
+import java.lang.*;
+import java.io.*;
+import java.nio.charset.StandardCharsets.*;
+import java.nio.charset.Charset;
+
+public class VigenereBreaker {
+    public static String Source = "dictionaries";
+    public HashMap<String,HashSet<String>> languages =
+    new HashMap<String,HashSet<String>>();
+    ArrayList<Integer> freqs = new ArrayList<Integer>();
+    ArrayList<Character> chars = new ArrayList<Character>();
+
+    public String sliceString(String message, int whichSlice, int totalSlices) {
+        //String slicing = new String();
+        StringBuilder slicing = new StringBuilder(message);
+        String result = new String();
+        for(int k = whichSlice;k<slicing.length();k+=totalSlices){
+            result += slicing.charAt(k);
+        }
+        return result;
+    }
+
+    public int[] tryKeyLength(String encrypted, int klength, char mostCommon) {
+        CaesarCracker CaesarCracker = new CaesarCracker('e');
+        int aKey;
+        int[] key = new int[klength];
+        for(int k =0;k<klength;k++) {
+           aKey = CaesarCracker.getKey(sliceString(encrypted,k,klength));
+           key[k] = aKey;
+           //k+=1;
+        }
+        return key;
+    }
+
+    public HashSet<String> readDictionary(FileResource fr) {
+        HashSet<String> h = new HashSet<String>();
+        for (String line : fr.lines()) {
+                h.add(line.toLowerCase());// print or process s
+         }
+
+    return h;
+    }
+
+   public int countWords(String message, HashSet<String> dict) {
+    int counts = 0; 
+    ArrayList<String> MessageInWords = new ArrayList<String>(Arrays.asList(message.split("\\W")));
+    for(int i = 0 ; i < MessageInWords.size(); i++ ) { 
+        if (dict.contains(MessageInWords.get(i).toLowerCase())) {
+                // If not put ip in with a value of 1
+                counts+=1;
+            } 
+               }                                     
+    return counts;                                     
+    }
+
+   public String breakForLanguage(String encrypted, HashSet<String> dict) {
+        int max = 0;
+        int keyReturn[] = new int[100];
+        int KeyLength = 0;
+        String aMessage = new String();
+        String largestDecryption = new String();
+        String[] decrypted = new String[100];
+        for(int klength =1; klength < 100 ; klength++) {
+            keyReturn = tryKeyLength(encrypted, klength, mostCommomCharIn(dict));
+            VigenereCipher VCipher  = new VigenereCipher(keyReturn) ;
+            aMessage = VCipher.decrypt(encrypted);
+            //counts is a value returned, no use starting from 0
+            int counts = countWords(aMessage, dict);
+            if(counts > max){
+                max = counts;
+                largestDecryption = aMessage;
+                KeyLength = klength;
+            }  
+        }
+
+        System.out.println("Max counts: "+ max);        
+        System.out.println("The proper Key Length is : "+ KeyLength);         
+        return largestDecryption;
+    }
+
+   public char mostCommomCharIn(HashSet<String> dict) {  
+    //count frequency of Letters in a dictionary
+    freqs.clear();
+    String  alph = "abcdefghijklmnñopqrstuvwxyz";
+    int[] mycounts = new int[27];
+    byte[] alphabet = alph.getBytes(Charset.forName("UTF-8"));
+    //System.out.println(" bytesArray in String " + alphabet.toString());
+    String alphabetUT8 = new String(alphabet, Charset.forName("UTF-8"));
+    //System.out.println(" The alphabet in UTF8 " +alphabetUT8);
+    for (String s : dict) {
+         int Wordlength = s.length();
+         for (int i=0; i<Wordlength; i++) {
+             int dex = alphabetUT8.indexOf(Character.toLowerCase(s.charAt(i)));
+             if (dex != -1) {
+                 mycounts[dex] += 1; 
+             }
+         }
+    }
+
+   //Max
+   int maxDex = 0;
+   for(int k=0; k < mycounts.length; k++){
+       if (mycounts[k] > mycounts[maxDex]) {
+           maxDex = k;
+            }
+   }
+
+   char mostCommon = alphabetUT8.charAt(maxDex);
+   //System.out.println("max index "+ maxDex);
+   System.out.println("most common char "+ mostCommon);
+   return mostCommon;
+
+  }
+
+  public String breakForAllLangs(String encrypted, HashMap<String,HashSet<String>> MyMap) {
+      String largestDecryption = new String(); 
+      int max = 0 ;
+      String identifyLanguage = new String();
+      HashSet<String> h = new HashSet<String>();  
+      for(String l : MyMap.keySet()) {
+        HashSet<String> readingResult = MyMap.get(l);
+        int counts = countWords(encrypted,readingResult);
+         if(counts > max){
+            max = counts;
+            largestDecryption = breakForLanguage(encrypted, readingResult);
+            identifyLanguage = l;
+        }
+
+      }
+      System.out.println(" identified language " + identifyLanguage);
+      return largestDecryption;   
+  }
+
+  public String breakVigenere() {
+      String MaxDecryption = new String();
+      //FileResource resource = new FileResource("ViginereMessages/athens_keyflute.txt");
+      FileResource resource = new FileResource("messages/secretmessage4.txt");
+      String message = resource.asString();
+      HashSet<String> DictContent = new HashSet<String>();
+      String [] labels = {"Danish","Dutch","English","French","German","Italian","Portuguese","Spanish"};
+      for(String s : labels) {
+          FileResource dictResource = new FileResource(Source+"/"+ s);
+          DictContent = readDictionary(dictResource);
+          languages.put(s,DictContent);
+          System.out.println("language "+ s + "\t total words in dictionary "+ DictContent.size());
+          mostCommomCharIn(DictContent);
+          System.out.println(" MostCommonChar in "+ s + " "+mostCommomCharIn(DictContent));
+      }
+      MaxDecryption = breakForAllLangs(message, languages);
+      return MaxDecryption; 
+  }
+
+}

Week4/Multiple Languages/VigenereProgram/VigenereCipher.ctxt

@@ -0,0 +1,11 @@
+#BlueJ class context
+comment0.target=VigenereCipher
+comment1.params=key
+comment1.target=VigenereCipher(int[])
+comment2.params=input
+comment2.target=java.lang.String\ encrypt(java.lang.String)
+comment3.params=input
+comment3.target=java.lang.String\ decrypt(java.lang.String)
+comment4.params=
+comment4.target=java.lang.String\ toString()
+numComments=5

Week4/Multiple Languages/VigenereProgram/VigenereCipher.java

@@ -0,0 +1,42 @@
+import edu.duke.*;
+import java.util.*;
+
+public class VigenereCipher {
+    CaesarCipher[] ciphers;
+
+    public VigenereCipher(int[] key) {
+        ciphers = new CaesarCipher[key.length];
+        for (int i = 0; i < key.length; i++) {
+            ciphers[i] = new CaesarCipher(key[i]);
+        }
+    }
+
+    public String encrypt(String input) {
+        StringBuilder answer = new StringBuilder();
+        int i = 0;
+        for (char c : input.toCharArray()) {
+            int cipherIndex = i % ciphers.length;
+            CaesarCipher thisCipher = ciphers[cipherIndex];
+            answer.append(thisCipher.encryptLetter(c));
+            i++;
+        }
+        return answer.toString();
+    }
+
+    public String decrypt(String input) {
+        StringBuilder answer = new StringBuilder();
+        int i = 0;
+        for (char c : input.toCharArray()) {
+            int cipherIndex = i % ciphers.length;
+            CaesarCipher thisCipher = ciphers[cipherIndex];
+            answer.append(thisCipher.decryptLetter(c));
+            i++;
+        }
+        return answer.toString();
+    }
+
+    public String toString() {
+        return Arrays.toString(ciphers);
+    }
+
+}

Week4/Multiple Languages/VigenereProgram/VigenereCipherTest.ctxt

@@ -0,0 +1,19 @@
+#BlueJ class context
+comment0.target=VigenereCipherTest
+comment1.params=
+comment1.target=void\ testCaesarCipher()
+comment2.params=
+comment2.target=void\ testCaesarCracker()
+comment3.params=
+comment3.target=void\ TestVigenereCipher()
+comment4.params=
+comment4.target=void\ TestSliceString()
+comment5.params=
+comment5.target=void\ TestTryKeyLength()
+comment6.params=
+comment6.target=void\ TestCountWords()
+comment7.params=
+comment7.target=void\ TestMostCommomCharIn()
+comment8.params=
+comment8.target=void\ BreakVigenereTest()
+numComments=9