Add a function to get the ordered sequence that can form a key.

project.clj

@@ -7,7 +7,8 @@
                  [org.clojure/tools.cli "1.0.219"]
                  [org.apache.tika/tika-core "1.28.5"]
                  [org.apache.tika/tika-langdetect "1.28.5"]
-                 [cheshire "5.12.0"]]
+                 [cheshire "5.12.0"]
+                 [org.clojure/math.combinatorics "0.2.0"]]
   :main ^:skip-aot cipher-analytical-machine.core
   :java-source-paths ["src/main/java"]
   :target-path "target/%s"

src/cipher_analytical_machine/analyzers/analyzers.clj

@@ -11,6 +11,16 @@
             (inc (get acc val 0))))
    {} text))
 
+(defn reverse-count-characters
+  "Convert a map of pairs to a map where the characters grouped by the count and a count is the key."
+  [count-map]
+  (reduce
+   (fn [acc [symbol count]]
+     (->> (conj (get acc count []) symbol)
+          (into [])
+          (assoc acc count)))
+   {} count-map))
+
 (defn chi-squared-letter-statistic
   "To calculate the frequency distribution of a letter."
   [letter-count letter-frequence length-text]

src/cipher_analytical_machine/analyzers/simple_substitution.clj

@@ -0,0 +1,31 @@
+(ns cipher-analytical-machine.analyzers.simple-substitution
+  (:require [clojure.string :as cs]
+            [clojure.math.combinatorics :as comb]
+            [cipher-analytical-machine.ciphers.simple-substitution :as ss]
+            [cipher-analytical-machine.analyzers.analyzers :as analyzers]
+            [cipher-analytical-machine.analyzers.caesar :as caesar])
+  (:gen-class))
+
+(defn get-possible-key-vector
+  "Convert a possible key map to a vector of possible keys. For example, if you have a map: {\\a [\\a \\b \\c] \\b [\\b \\c] \\c [\\a \\c]}, then the vector is [[\\a \\b \\c] [\\b \\c] [\\a \\c]]."
+  [possible-key-map symbols]
+  (reduce
+   (fn [acc el]
+     (conj acc (get possible-key-map el)))
+   [] symbols))
+
+(defn get-possible-key-vector-from-reversed-count-map
+  "Convert a reversed count map to a vector. Example, from {2 [\\a \\b] 1 [\\d] 3 [\\e]} to [[\\e] [\\a \\b] [\\d]])."
+  [reversed-count-map]
+  (->>  reversed-count-map
+        (into [])
+        (sort-by #(- (first %)))
+        (map second)
+        (into [])))
+
+(defn get-possible-keys
+  "Return possible keys for a possible key vector. For example, if you have a map: {\\a [\\a \\b \\c] \\b [\\b \\c] \\c [\\a \\c]}, then the vector is [[\\a \\b \\c] [\\b \\c] [\\a \\c]] and keys (\"aba\" \"abc\" ...)."
+  [possible-key-vector]
+  (->> (apply comb/cartesian-product possible-key-vector)
+       (map cs/join)))
+

src/cipher_analytical_machine/ciphers/gamma.clj

@@ -0,0 +1,78 @@
+(ns cipher-analytical-machine.ciphers.gamma
+  (:require
+   [clojure.set :as set]
+   [clojure.string :as cs]
+   [cipher-analytical-machine.ciphers.simple-substitution :as ss])
+  (:gen-class))
+
+(defn add-mod
+  [f s module]
+  (-> (+ f s)
+      (mod module)))
+
+(defn generate-seq
+  "Generate a lazy sequence for a key (a b c)."
+  [a b c module]
+  ((fn build-seq [a b c]
+     (lazy-seq (cons a (build-seq b c (add-mod a c module))))) a b c))
+
+(defn generate-gamma-seq
+  "Generate the gamma seq from a sequence."
+  [acc seq module]
+  (if (= (second seq) nil) acc
+    (generate-gamma-seq
+     (conj acc (add-mod (first seq) (second seq) module))
+     (rest seq)
+     module)))
+
+(defn generate-gamma
+  "Generate the gamma from a key (a b c)."
+  [a b c module size]
+  (generate-gamma-seq []
+                      (->> (generate-seq a b c module)
+                           (take (inc size)))
+                      module))
+
+(defn encrypt-array
+  "Encrypt an array using the gamma cipher. The function is case-insensitive. The key is an array of three elements [a b c]. The array contains integer in range [0, module)."
+  [key module array]
+  (let [size (count array)
+        gamma (->> (apply conj [key module size])
+                   (apply generate-gamma))]
+    (->> gamma
+         (map vector array)
+         (map (fn [[a g]] (add-mod a g module))))))
+
+(defn encrypt-message
+  "Encrypt a message using the gamma cipher. The function is case-insensitive. The key is an array of three elements [a b c]. The array contains integer in range [0, module)."
+  [key symbols message]
+  (let [module (count symbols)
+        table (ss/generate-sorted-substitution-table symbols)]
+    (->> message
+         (ss/decrypt-by-table (set/map-invert table))
+         (encrypt-array key module)
+         (ss/decrypt-by-table table)
+         (cs/join))))
+
+(defn decrypt-array
+  "Decrypt an array using the gamma cipher. The function is case-insensitive. The key is an array of three elements [a b c]. The array contains integer in range [0, module)."
+  [key module array]
+  (let [size (count array)
+        gamma (->> (apply conj [key module size])
+                   (apply generate-gamma))]
+    (->> gamma
+         (map -)
+         (map vector array)
+         (map (fn [[a g]] (add-mod a g module))))))
+
+(defn decrypt-message
+  "Decrypt a message using the gamma cipher. The function is case-insensitive. The key is an array of three elements [a b c]. The array contains integer in range [0, module)."
+  [key symbols message]
+  (let [module (count symbols)
+        table (ss/generate-sorted-substitution-table symbols)]
+    (->> message
+         (ss/decrypt-by-table (set/map-invert table))
+         (decrypt-array key module)
+         (ss/decrypt-by-table table)
+         (cs/join))))
+

src/cipher_analytical_machine/ciphers/simple_substitution.clj

@@ -29,11 +29,16 @@
   [char substitution-table]
   (get substitution-table char))
 
+(defn decrypt-by-table
+  "Decrypt a message by the substitution-table"
+  [substitution-table message]
+  (map (fn [char] (find-value-in-table char substitution-table)) message))
+
 (defn encrypt-message
   "Encrypt a message using the simple substitution cipher. The function is case-insensitive. If a symbol isn't in the symbols list, then it will be removed."
   [message substitution-table]
   (->> message
-       (map (fn [char] (find-value-in-table char substitution-table)))
+       (decrypt-by-table substitution-table)
        (remove nil?)
        (cs/join \,)))
 
@@ -44,11 +49,6 @@
       (caesar/encrypt-message key symbols)
       (encrypt-message substitution-table)))
 
-(defn decrypt-by-table
-  "Decrypt a message by the substitution-table"
-  [substitution-table message]
-  (map (fn [char] (find-value-in-table char substitution-table)) message))
-
 (defn decrypt-message-by-symbol-table
   "Decrypt a message using the simple substitution cipher. The function is case-insensitive. The substitution-table must be (symbols, symbols)."
   [substitution-table message]

src/cipher_analytical_machine/cli/actions/cracking.clj

@@ -9,7 +9,8 @@
   (let [analyzer (:analyzer options)
         message (:message options)
         symbols (:symbols options)
-        frequencies symbol-frequencies/english-letter-frequencies]
+        frequencies (-> (get options :language "en")
+                        (symbol-frequencies/default-frequency-factory))]
     (cond
       (= analyzer "Chi^2")
       (caesar-analyzers/get-plaintext message symbols frequencies)

src/cipher_analytical_machine/cli/actions/cryptography.clj

@@ -1,7 +1,9 @@
 (ns cipher-analytical-machine.cli.actions.cryptography
   (:require
+   [clojure.string :as cs]
    [cipher-analytical-machine.ciphers.caesar :as caesar]
    [cipher-analytical-machine.ciphers.simple-substitution :as ss]
+   [cipher-analytical-machine.ciphers.gamma :as gamma]
    [cipher-analytical-machine.parsers.parsers :as ps]
    [cipher-analytical-machine.parsers.simple-substitution :as pss])
   (:gen-class))
@@ -38,6 +40,20 @@
             substitution-table (get data "table")]
         (ss/decrypt-message-with-caesar message key substitution-table symbols)))))
 
+(defn gamma-actions
+  [options arguments action-type]
+  (let [message (:message options)
+        key (->> (cs/split (:key options) #",")
+                 (map #(Integer/parseInt %))
+                 (into []))
+        symbols (:symbols options)]
+    (cond
+      (= action-type :encrypt)
+      (gamma/encrypt-message key symbols message)
+
+      (= action-type :decrypt)
+      (gamma/decrypt-message key symbols message))))
+
 (defn cryptography-actions
   [options arguments action-type]
   (let [cipher (:cipher options)]
@@ -46,5 +62,8 @@
       (caesar-actions options arguments action-type)
 
       (= cipher "Simple substitution and Caesar")
-      (simple-substitution-with-caesar-actions options arguments action-type))))
+      (simple-substitution-with-caesar-actions options arguments action-type)
+
+      (= cipher "Gamma")
+      (gamma-actions options arguments action-type))))
 

src/cipher_analytical_machine/cli/cli.clj

@@ -1,5 +1,7 @@
 (ns cipher-analytical-machine.cli.cli
   (:require
+   [cipher-analytical-machine.parsers.parsers :as ps]
+   [cipher-analytical-machine.parsers.gamma :as gamma-ps]
    [cipher-analytical-machine.cli.file :as file]
    [cipher-analytical-machine.symbols.factories :as sf]
    [cipher-analytical-machine.cli.options :as options]
@@ -77,6 +79,15 @@
            (or (contains? options :encrypt)
                (contains? options :decrypt)))
       (cond
+        (and (= (:cipher options) "Caesar")
+             (false? (ps/int-string? (:key options))))
+        {:exit-message (error-msg ["Please, use the key format: [+-](integer)!!! Example: 10, +9, -7."])}
+
+        (and (= (:cipher options) "Gamma")
+             (false? (gamma-ps/key? (:key options))))
+        {:exit-message (error-msg ["Please, use the key format: [+-](integer),[+-](integer),[+-](integer) !!! Example: 10,+9,-7."])}
+
+
         (contains? options :encrypt)
         {:options options :arguments arguments :action-type :encrypt}
 
@@ -160,3 +171,10 @@
 
      (show-and-save-output options))))
 
+(defn cli-main
+  [args]
+  (let [{:keys [options arguments action-type exit-message ok?]} (validate-args args)]
+    (if exit-message
+      (exit exit-message ok?)
+      (actions options arguments action-type))))
+

src/cipher_analytical_machine/cli/options.clj

@@ -22,7 +22,7 @@
     (option-values-as-list option values)))
 
 (def cipher-options
-  #{"Caesar" "Simple substitution and Caesar"})
+  #{"Caesar" "Simple substitution and Caesar" "Gamma"})
 
 (def default-cipher "Caesar")
 

src/cipher_analytical_machine/core.clj

@@ -5,8 +5,5 @@
 
 (defn -main
   [& args]
-  (let [{:keys [options arguments action-type exit-message ok?]} (cli/validate-args args)]
+  (cli/cli-main args))
-    (if exit-message
-      (cli/exit exit-message ok?)
-      (cli/actions options arguments action-type))))
 

src/cipher_analytical_machine/parsers/gamma.clj

@@ -0,0 +1,9 @@
+(ns cipher-analytical-machine.parsers.gamma
+  (:gen-class))
+
+(defn key?
+  "Return true if the string is an key of three integers."
+  [str]
+  (if (re-matches #"[+-]?\b\d+\b,[+-]?\b\d+\b,[+-]?\b\d+\b" str)
+    true false))
+

src/cipher_analytical_machine/parsers/parsers.clj

@@ -2,12 +2,18 @@
   (:require [cheshire.core :as cc])
   (:gen-class))
 
-(defn unsigned-int?
+(defn unsigned-int-string?
   "Return true if the string is an unsigned integer."
   [str]
   (if (re-matches #"\d+" str)
     true false))
 
+(defn int-string?
+  "Return true if the string is an signed integer."
+  [str]
+  (if (re-matches #"[+-]?\b\d+\b" str)
+    true false))
+
 (defn parse-unsigned-int
   "Return an integer if the argument is an integer."
   [str-or-int]
@@ -15,7 +21,7 @@
     (int? str-or-int)
     str-or-int
 
-    (unsigned-int? str-or-int)
+    (unsigned-int-string? str-or-int)
     (Integer/parseInt str-or-int)
 
     :else

src/cipher_analytical_machine/parsers/simple_substitution.clj

@@ -15,14 +15,14 @@
 (defn decode-key
   "Returns the first character if the string is a char. Return the number if the string is a number."
   [str]
-  (if (ps/unsigned-int? str)
+  (if (ps/unsigned-int-string? str)
     (Integer/parseInt str)
     (first str)))
 
 (defn decode-pair
   "Decode a numbers as a string and a char as a string"
   [acc [key value]]
-  (if (ps/unsigned-int? key)
+  (if (ps/unsigned-int-string? key)
     (assoc acc (decode-key key) (decode-key value))
     (assoc acc (decode-key key) value)))
 
@@ -38,7 +38,7 @@
 (defn generate-table-or-decode-json
   "It generate the table and return map with the key and the table if the argument is a key. Else it decode the json."
   [key-or-json symbols]
-  (if (ps/unsigned-int? key-or-json)
+  (if (ps/unsigned-int-string? key-or-json)
     (-> {"key" key-or-json}
         (assoc "table" (ss/generate-substitution-table symbols)))
     (decode-key-and-substitution-table-from-json key-or-json)))

src/cipher_analytical_machine/symbols/frequencies.clj

@@ -77,3 +77,16 @@
    \  0.138
 })
 
+(defn default-frequency-factory
+  "Returns a default map of letter frequencies for a language"
+  [language-code]
+  (cond
+    (= language-code "en")
+    english-letter-frequencies
+
+    (= language-code "uk")
+    ukrainian-letter-frequencies
+
+    :else
+    english-letter-frequencies))
+

test/cipher_analytical_machine/analyzers/analyzers_test.clj

@@ -8,6 +8,13 @@
     (is (= {\a 2 \b 1}
            (count-characters "aba")))))
 
+(deftest reverse-count-characters-test
+  (testing "The symbols must be grouped as a vector and the count must be a key."
+    (are [count-map expected-map]
+        (= expected-map (reverse-count-characters count-map))
+      {\a 1 \b 2 \c 1} {1 [\a \c] 2 [\b]}
+      {\a 1 \b 2 \c 3} {1 [\a] 2 [\b] 3 [\c]})))
+
 (deftest chi-squared-letter-statistic-test
   (testing "If the frequence of A is 0.1, the text length is 100 and contains 20 times, then the chi-squared is 10."
     (is (= 10.0

test/cipher_analytical_machine/analyzers/simple_substitution_test.clj

@@ -0,0 +1,30 @@
+(ns cipher-analytical-machine.analyzers.simple-substitution-test
+  (:require
+   [clojure.test :refer :all]
+   [cipher-analytical-machine.symbols.frequencies :as sf]
+   [cipher-analytical-machine.ciphers.simple-substitution :as ss]
+   [cipher-analytical-machine.analyzers.simple-substitution :refer :all])
+  (:gen-class))
+
+(deftest get-possible-keys-vector-test
+  (testing "The vector must be ordered by symbols"
+    (are [possible-keys-map symbols expected-key-vector]
+        (= expected-key-vector (get-possible-key-vector possible-keys-map symbols))
+      {\a [\a \b] \b [\b \a] \c [\a \c]} "abc" [[\a \b] [\b \a] [\a \c]]
+      {\a [\a \b] \c [\b \a] \b [\a \c]} "abc" [[\a \b] [\a \c] [\b \a]])))
+
+(deftest get-possible-key-vector-from-reversed-count-map-test
+  (testing ""
+    (are [reversed-count-map expected-key-vector]
+        (= expected-key-vector (get-possible-key-vector-from-reversed-count-map reversed-count-map))
+      {1 [\a \c] 2 [\b]}     [[\b] [\a \c]]
+      {2 [\a] 1 [\b] 3 [\c]} [[\c] [\a] [\b]])))
+
+(deftest get-possible-keys-test
+  (testing "The keys must be the all combinations"
+    (are [possible-keys-vector expected-keys]
+        (= expected-keys (get-possible-keys possible-keys-vector))
+      [[\a \b] [\f] [\a \c] [\g]] '("afag" "afcg" "bfag" "bfcg")
+      [[\a \b] [\a \c]] '("aa" "ac" "ba" "bc")
+      [[\a \b \c] [\a \c] [\b \c]] '("aab" "aac" "acb" "acc" "bab" "bac" "bcb" "bcc" "cab" "cac" "ccb" "ccc"))))
+

test/cipher_analytical_machine/ciphers/gamma_test.clj

@@ -0,0 +1,62 @@
+(ns cipher-analytical-machine.ciphers.gamma-test
+  (:require
+   [clojure.test :refer :all]
+   [cipher-analytical-machine.ciphers.gamma :refer :all]))
+
+(deftest add-mod-test
+  (testing "The remainder must be as expected."
+    (are [a b module expected]
+        (= expected (add-mod a b module))
+      5 2 4 3
+      1 2 3 0
+      2 2 3 1)))
+
+(deftest generate-seq-test
+  (testing "Checking that the next element of a sequence is calculated by (e[i-1] + e[i-3] % mod)."
+    (are [a b c module size expected]
+        (= expected (take size (generate-seq a b c module)))
+      4 32 15 33 10 [4 32 15 19 18 0 19 4 4 23]
+      1 2  3  3  9  [1 2 3 1 0 0 1 1 1])))
+
+(deftest generate-gamma-seq-test
+  (testing "Checking that the next element of a sequence is calculated by (s[i] + s[i+1] % mod)."
+    (are [acc seq module expected]
+        (= expected (generate-gamma-seq acc seq module))
+      [] [4 32 15 19 18 0 19 4 4 23] 33 [3 14 1 4 18 19 23 8 27]
+      [] [1 2 3 1 0 0 1 1 1]         3  [0 2 1 1 0 1 2 2])))
+
+(deftest generate-gamma-test
+  (testing "Checking that the gamma is generated as expected."
+    (are [a b c module size expected]
+        (= expected (generate-gamma a b c module size))
+      4 32 15 33 10 [3 14 1 4 18 19 23 8 27 17]
+      1 2  3  3  9  [0 2 1 1 0 1 2 2 0])))
+
+(deftest encrypt-array-test
+  (testing "Checking that the message is encrypted as expected: (msg+gamma)%module."
+    (are [key module array expected]
+        (= expected (encrypt-array key module array))
+      [4 32 15] 33 [3 14 1 4 18 19 23 8 27 17] [6 28 2 8 3 5 13 16 21 1]
+      [1 2  3 ] 3  [0 2 1 1 0 1 2 2 0]         [0 1 2 2 0 2 1 1 0])))
+
+(deftest encrypt-message-test
+  (testing "Checking that the message is encrypted as expected"
+    (are [key symbols message expected]
+        (= expected (encrypt-message key symbols message))
+      [4 32 15] "абвгґдеєжзиіїйклмнопрстуфхцчшщьюя" "гкбґопужчн" "ешвжгдймсб"
+      [1 2  3 ] "абв"  "авббабвва"  "абввавбба")))
+
+(deftest decrypt-array-test
+  (testing "Checking that the message is decrypted as expected."
+    (are [key module array expected]
+        (= expected (decrypt-array key module array))
+      [4 32 15] 33 [6 28 2 8 3 5 13 16 21 1] [3 14 1 4 18 19 23 8 27 17]
+      [1 2  3 ] 3  [0 1 2 2 0 2 1 1 0]       [0 2 1 1 0 1 2 2 0])))
+
+(deftest decrypt-message-test
+  (testing "Checking that the message is decrypted as expected"
+    (are [key symbols message expected]
+        (= expected (decrypt-message key symbols message))
+      [4 32 15] "абвгґдеєжзиіїйклмнопрстуфхцчшщьюя" "ешвжгдймсб" "гкбґопужчн"
+      [1 2  3 ] "абв" "абввавбба" "авббабвва")))
+

test/cipher_analytical_machine/parsers/gamma_test.clj

@@ -0,0 +1,20 @@
+(ns cipher-analytical-machine.parsers.gamma-test
+  (:require
+   [clojure.test :refer :all]
+   [cipher-analytical-machine.parsers.gamma :refer :all]))
+
+(deftest key?-test
+  (testing "The function return true only if the key in the format '%d,%d,%d'."
+    (are [str expected]
+        (= expected
+           (key? str))
+      "9"         false
+      "9,10"      false
+      "10,9,8"    true
+      "-10,9,-8"  true
+      "-10,-9,-8" true
+      "asd 10 "   false
+      " 10 "      false
+      "-10"       false
+      "abc"       false)))
+

test/cipher_analytical_machine/parsers/parsers_test.clj

@@ -3,13 +3,28 @@
    [clojure.test :refer :all]
    [cipher-analytical-machine.parsers.parsers :refer :all]))
 
-(deftest unsigned-int?-test
+(deftest unsigned-int-string?-test
   (testing "The function return true only for an unsingned integer as a string."
     (are [str expected]
         (= expected
-           (unsigned-int? str))
+           (unsigned-int-string? str))
+      "9" true
       "9" true
       "10" true
+      "asd 10 " false
+      " 10 " false
+      "-10" false
+      "abc" false)))
+
+(deftest int-string?-test
+  (testing "The function return true only for an singned integer as a string."
+    (are [str expected]
+        (= expected
+           (int-string? str))
+      "9" true
+      "10" true
+      "-10" true
+      "asd -10 " false
       " -10 " false
       "abc" false)))
 

test/cipher_analytical_machine/symbols/frequencies_test.clj

@@ -9,3 +9,13 @@
       (is (= "etaoinsrhldcumfpgwybvkxjqz"
              (map-to-string symbol-map))))))
 
+(deftest default-frequency-factory-test
+  (testing "Factory supports languages: English (en), Ukrainian (uk). If language code is unidentified, then it must have the 'en'."
+    (are [language-code expected-map-size]
+        (->> (default-frequency-factory language-code)
+             count
+             (= expected-map-size))
+      "en"           26
+      "uk"           34
+      "Maybe a code" 26)))
+