Ask Question

Name:
Title:
Your Question:

Answer Question

Name:
Your Answer:
User Submitted Source Code!


Description:
  a
Language: JAVA
Code:
/**
 * <p>File: MonoAlphabetic.java</p>
 * <p>Title: Cryptography</p>
 * <p>Description: Course on introduction to typography</p>
 * <p>Date: March 2015</p>
 * @author Faton M. Berisha
 * @version 1.0.0
 */

package cryptography;

import java.util.*;

/**
 * Mono-alphabetic substitution cryptographic model.
 * 
 * @author Faton M. Berisha
 *
 */
public class MonoAlphabetic {
     public static Map<Character, Double> FREQUENCY_ENG;
     
     public MonoAlphabetic() {
          FREQUENCY_ENG = new HashMap<Character, Double>(26);
          double[] freqEng
               = {8.17, 1.49, 2.78, 4.25, 12.70, 2.23, 2.02, 6.09, 6.97, 0.15,
                    0.77, 4.03, 2.41, 6.75, 7.51, 1.93, 0.10, 5.99, 6.33, 9.06,
                    2.76, 0.98, 2.36, 0.15, 1.97, 0.07};

          for (int i = 0; i < 26; i++) {
               Character ch = new Character((char)(i + 'A'));
               Double freq = new Double(freqEng[i]);
               FREQUENCY_ENG.put(ch, freq);
          }
     }
     
     /**
      * Mono-alphabetic substitution encryption algorithm.
      * 
      * @param message
      *            message to encrypt
      * @param key
      *            <code>Map<Character, Character></code> encryption key
      * @return encrypted message
      */
     public String encrypt(String message, Map<Character, Character> key) {
          StringBuffer code = new StringBuffer();
          for (int i = 0; i < message.length(); i++) {
               char ch = message.charAt(i);
               if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) {
                    ch = Character.toUpperCase(ch);
                    Character c = key.get(new Character(ch));
                    code.append(c.charValue());
               }
          }
          return new String(code);
     }

     /**
      * Mono-alphabetic substitution decryption algorithm.
      * 
      * @param code
      *            encrypted code to decrypt
      * @param key
      *            <code>Map<Character, Character></code> decryption key
      * @return decrypted message
      */
     public String decrypt(String code, Map<Character, Character> key) {
          Map<Character, Character> keyInv
               = new HashMap<Character, Character>(26);
          for (int i = 0; i < 26; i++) {
               Character keyChar = new Character((char) (i + 'A'));
               Character valueChar = key.get(keyChar);
               keyInv.put(valueChar, keyChar);
          }
          
          return encrypt(code, keyInv);
     }

     /**
      * Mono-alphabetic substitution key generating algorithm.
      * 
      * @return generated random <code>Map<Character, Character></code> key
      */
     public Map<Character, Character> generate() {
          Map<Character, Character> key
               = new HashMap<Character, Character>(26);

          char[] letter = new char[26];
          for (int i = 0; i < 26; i++) {
               letter[i] = (char) (i + 'A');
          }

          for (int i = 0; i < 26; i++) {
               int left = 26 - i;
               Character keyChar = new Character((char) (i + 'A'));
               int rand = (int) (Math.random() * left);
               Character valueChar = new Character(letter[rand]);
               key.put(keyChar, valueChar);
               for (int j = rand; j < left - 1; j++) {
                    letter[j] = letter[j + 1];
               }
          }
          return key;
     }
     
     /**
      * Mono-alphabetic encryption analysis algorithm.
      * 
      * @param code
      *            encrypted message to analyze
      * @param key
      *            <code>Map<Character, Character></code> analyzing key
      * @return partially decrypted message
      */
     public String analysis(String code, Map<Character, Character> key) {
          StringBuffer answer = new StringBuffer();
          for (int i = 0; i < code.length(); i++) {
               char ch = code.charAt(i);
               Character c = new Character(ch);
               if (ch >= 'A' && ch <= 'Z') {
                    c = key.get(c);
               }
               answer.append(c.charValue());
          }
          return new String(answer);
     }

     public Map<Character, Double> letterFrequency (String code) {
          Map<Character, Double> frequency
               = new HashMap<Character, Double>(26);
          for (int i = 0; i < code.length(); i++) {
               char ch = Character.toUpperCase(code.charAt(i));
               Character keyChar = new Character(ch);
               if (frequency.containsKey(keyChar)) {
                    int value = frequency.get(keyChar).intValue();
                    frequency.put(keyChar, new Double(++value));
               } else {
                    frequency.put(keyChar, new Double(1.0));
               }
          }

          for (int i = 0; i < 26; i++) {
               Character keyChar = new Character((char)(i + 'A'));
               if (frequency.containsKey(keyChar)) {
                    double value = frequency.get(keyChar).doubleValue();
                    value *= 100.0 / code.length();
                    value = Math.round(100 * value) / 100.0;
                    frequency.put(keyChar, new Double(value));
               }
          }

          return frequency;
     }
     
     public Map<String, Double> multigramFrequency (String code, int m) {
          Map<String, Double> frequency
               = new HashMap<String, Double>(26);
          for (int i = 0; i < code.length() - m + 1; i++) {
               String str = code.substring(i, i + m);
               if (frequency.containsKey(str)) {
                    int value = frequency.get(str).intValue();
                    frequency.put(str, new Double(++value));
               } else {
                    frequency.put(str, new Double(1.0));
               }
          }
          return frequency;
     }
     
     public List<Map.Entry<?, Double>>
               sort(Map<?, Double> map) {
          List<Map.Entry<?, Double>> list
               = new LinkedList<Map.Entry<?, Double>>(
                    map.entrySet());
          Comparator<Map.Entry<?, Double>> c = new EntryComparator();
          Collections.sort(list, c);
          return list;
     }

     private class EntryComparator
               implements Comparator<Map.Entry<?, Double>> {
          public int compare(Map.Entry<?, Double> me1,
                    Map.Entry<?, Double> me2) {
               return me2.getValue().compareTo(me1.getValue());
          }
     }
     
}
Comments: