Merge branch 'dev' into 'main'

Add a simple experimental analyzer for Simple substitution ciphers

See merge request KKlochko/cipher-analytical-machine!3

CHANGELOG.md

@@ -7,6 +7,140 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.15] - 2023-11-26
+
+### Changed
+- Update the CHANGELOG.
+- Update the version.
+- Update the README.
+
+## [0.9.14] - 2023-11-26
+
+### Added
+- Add analyzer for the simple substitution cipher.
+- Add the analyzer options and their actions for the simple substiotution.
+
+## [0.9.13] - 2023-11-26
+
+### Fixed
+- Fix the test name.
+
+## [0.9.12] - 2023-11-20
+
+### Changed
+- Update the CHANGELOG.
+- Update the version.
+- Update the README.
+
+## [0.9.11] - 2023-11-14
+
+### Added
+- Add the function that return all key combinations for a possible key vector.
+
+### Changed
+- Rename the function from get-possible-keys to get-all-combinations-for-blocks.
+
+## [0.9.10] - 2023-11-13
+
+### Added
+- Add a function to get all permutations for a block.
+
+## [0.9.9] - 2023-11-12
+
+### Added
+- Add a function to convert a count map to a reversed map.
+- Add a function to get the ordered sequence that can form a key.
+
+## [0.9.8] - 2023-11-11
+
+### Added
+- Add functions to get possible keys.
+
+## [0.9.7] - 2023-11-03
+
+### Added
+- Add the default frequency factory.
+
+## [0.9.6] - 2023-11-01
+
+### Added
+- Add int-string? to check if a string is a number.
+- Add key? to check if a string is a gamma key.
+- Add key validation for Caesar and Gamma ciphers.
+
+### Changed
+- Rename unsigned-int? to unsigned-int-string?
+
+## [0.9.5] - 2023-10-31
+## [0.9.5] - 2023-10-31
+
+### Added
+- Add the option for the gamma cipher.
+
+## [0.9.4] - 2023-10-31
+
+### Fixed
+- Fix the key parsing in the gamma actions.
+
+## [0.9.3] - 2023-10-31
+
+### Added
+- Add the action of encryption for the gamma cipher.
+- Add the action of decryption for the gamma cipher.
+
+## [0.9.2] - 2023-10-29
+
+### Added
+- Add a function to encrypt a message with the gamma cipher.
+- Add a function to decrypt a message with the gamma cipher.
+
+## [0.9.1] - 2023-10-28
+
+### Changed
+- Refactor the simple substitute to use the decrypt-by-table function. 
+
+## [0.9.0] - 2023-10-27
+
+### Added
+- Add the gamma generator.
+- Add the functions to encrypt and decrypt with the gamma cipher.
+
+## [0.8.5] - 2023-10-25
+
+### Added
+- Add the main for the cli module.
+
+## [0.8.4] - 2023-10-24
+
+### Changed
+- Update the simple substitution cipher to split the decrypt-message.
+
+## [0.8.3] - 2023-10-24
+
+### Added
+- Add functions to make a frequency map.
+
+## [0.8.2] - 2023-10-23
+
+### Added
+- Add a function to invert the table in a decoded json.
+- Add the parser to parse the string as an integer if it's needed.
+- Add the simple substitution cipher.
+
+## [0.8.1] - 2023-10-22
+
+### Added
+- Add a generator for the sorted substitution table.
+- Add the parsers to parse keys.
+
+### Changed
+- Update the simple substitution cipher to split the functions.
+
+## [0.8.0] - 2023-10-21
+
+### Added
+- Add the simple substitution cipher.
+
 ## [0.7.2] - 2023-10-21
 
 ### Changed
@@ -177,7 +311,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Project initialization.
 
-[Unreleased]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.7.2...main?from_project_id=50218541&straight=false
+[Unreleased]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.15...main?from_project_id=50218541&straight=false
+[0.9.15]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.14...0.0.9.15?from_project_id=50218541&straight=false
+[0.9.14]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.13...0.0.9.14?from_project_id=50218541&straight=false
+[0.9.13]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.12...0.0.9.13?from_project_id=50218541&straight=false
+[0.9.12]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.11...0.0.9.12?from_project_id=50218541&straight=false
+[0.9.11]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.10...0.0.9.11?from_project_id=50218541&straight=false
+[0.9.10]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.9...0.9.10?from_project_id=50218541&straight=false
+[0.9.9]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.8...0.9.9?from_project_id=50218541&straight=false
+[0.9.8]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.7...0.9.8?from_project_id=50218541&straight=false
+[0.9.7]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.6...0.9.7?from_project_id=50218541&straight=false
+[0.9.6]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.5...0.9.6?from_project_id=50218541&straight=false
+[0.9.5]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.4...0.9.5?from_project_id=50218541&straight=false
+[0.9.4]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.3...0.9.4?from_project_id=50218541&straight=false
+[0.9.3]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.2...0.9.3?from_project_id=50218541&straight=false
+[0.9.2]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.1...0.9.2?from_project_id=50218541&straight=false
+[0.9.1]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.9.0...0.9.1?from_project_id=50218541&straight=false
+[0.9.0]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.8.5...0.9.0?from_project_id=50218541&straight=false
+[0.8.5]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.8.4...0.8.5?from_project_id=50218541&straight=false
+[0.8.4]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.8.3...0.8.4?from_project_id=50218541&straight=false
+[0.8.3]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.8.2...0.8.3?from_project_id=50218541&straight=false
+[0.8.2]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.8.1...0.8.2?from_project_id=50218541&straight=false
+[0.8.1]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.8.0...0.8.1?from_project_id=50218541&straight=false
+[0.8.0]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.7.2...0.8.0?from_project_id=50218541&straight=false
 [0.7.2]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.7.1...0.7.2?from_project_id=50218541&straight=false
 [0.7.1]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.7.0...0.7.1?from_project_id=50218541&straight=false
 [0.7.0]: https://gitlab.com/KKlochko/cipher-analytical-machine/-/compare/0.6.3...0.7.0?from_project_id=50218541&straight=false

README.md

@@ -12,7 +12,7 @@ You need install java, before run the application.
 Run the application with a command:
 
     $ java -jar cipher-analytical-machine-VERSION-standalone.jar [args]
-    $ java -jar cipher-analytical-machine-0.7.2-standalone.jar [args]
+    $ java -jar cipher-analytical-machine-0.9.15-standalone.jar [args]
 
 ## License
 

project.clj

@@ -1,4 +1,4 @@
-(defproject cipher-analytical-machine "0.7.2"
+(defproject cipher-analytical-machine "0.9.15"
   :description "A program helps to learn how ciphers works."
   :url "https://gitlab.com/KKlochko/cipher-analytical-machine"
   :license {:name "LGPL"

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

@@ -1,22 +1,78 @@
 (ns cipher-analytical-machine.analyzers.simple-substitution
   (:require [clojure.string :as cs]
             [clojure.math.combinatorics :as comb]
+            [cipher-analytical-machine.symbols.frequencies :as frequencies]
             [cipher-analytical-machine.ciphers.simple-substitution :as ss]
             [cipher-analytical-machine.analyzers.analyzers :as analyzers]
+            [cipher-analytical-machine.analyzers.analyzers :as ca]
             [cipher-analytical-machine.analyzers.caesar :as caesar])
   (:gen-class))
 
 (defn get-possible-key-vector
-  "Conver 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]]."
+  "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-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\" ...)."
+(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-all-permutation-for-block
+  "Return a vector for all possible blocks that can be made from a vector of symbols."
+  [symbols]
+  (->> (comb/permutations symbols)
+       (map cs/join)
+       (into [])))
+
+(defn get-all-combinations-for-blocks
+  "Return the all combination of blocks in a possible key vector. For example, if you have a map: {\\a [\\a \"bf\" \\c] \\b [\"bf\" \\c] \\c [\\a \\c]}, then the vector is [[\\a \"bf\" \\c] [\"bf\" \\c] [\\a \\c]] and keys (\"abfa\" \"abfc\" ...)."
   [possible-key-vector]
   (->> (apply comb/cartesian-product possible-key-vector)
        (map cs/join)))
 
+(defn get-possible-key-combinations
+  "Return possible keys for a possible key vector. For example, if you have a map: {\\a [\\a \\b \\c] \\e [\\f \\g] \\c [\\a \\c]}, then the keys are (\"abcefg\" \"abcegf\" ...)."
+  [possible-key-vector]
+  (->> (map get-all-permutation-for-block possible-key-vector)
+       (get-all-combinations-for-blocks)))
+
+(defn get-possible-keys
+  "Return keys for a cipher text. A key is a map {\\a \\e, ...} to decrypt a text."
+  [cipher-text frequency-table]
+  (let [freq-symbol-str (frequencies/map-to-string frequency-table) ; "etaoinsrhldcumfpgwybvkxjqz"
+        char-map (-> (analyzers/count-characters cipher-text)
+                     (analyzers/reverse-count-characters))]
+    (map (fn [comb] (zipmap comb freq-symbol-str))
+         (-> (get-possible-key-vector-from-reversed-count-map char-map)
+             (get-possible-key-combinations)))))
+
+
+(defn get-plain-data
+  "Return the plain data (score, text, key) from a ciphertext (a string of character). The function is case-insensitive."
+  [cipher-text letter-frequencies]
+  (let [cipher-text (cs/lower-case cipher-text)
+        keys (get-possible-keys cipher-text letter-frequencies)]
+    (->> (map (fn [key] [(ss/decrypt-message-by-symbol-table key cipher-text) key]) keys)
+         (map (fn [[text key]] [(ca/chi-squared-statistic text letter-frequencies) text key]))
+         )))
+
+(defn get-plaintext-and-key
+  "Return the possible plaintext from a ciphertext that encoded with numbers. The function is case-insensitive."
+  [cipher-text letter-frequencies]
+  (let [maybe-key   (->> (frequencies/map-to-string letter-frequencies)
+                         (ss/generate-sorted-substitution-table))
+        cipher-text (->> (cs/split cipher-text #",")
+                         (map #(Integer/parseInt %))
+                         (ss/decrypt-message-by-symbol-table maybe-key))]
+
+    (->> (get-plain-data cipher-text letter-frequencies)
+         (map (fn [el] (drop 1 el)) ))))
+

src/cipher_analytical_machine/cli/actions/cracking.clj

@@ -1,6 +1,7 @@
 (ns cipher-analytical-machine.cli.actions.cracking
   (:require
    [cipher-analytical-machine.analyzers.caesar :as caesar-analyzers]
+   [cipher-analytical-machine.analyzers.simple-substitution :as ss-analyzers]
    [cipher-analytical-machine.symbols.frequencies :as symbol-frequencies])
   (:gen-class))
 
@@ -18,10 +19,27 @@
       :else
       (caesar-analyzers/get-plaintext message symbols frequencies))))
 
+(defn cracking-simple-substitution-with-caesar
+  [options arguments]
+  (let [analyzer (:analyzer options)
+        message (:message options)
+        symbols (:symbols options)
+        frequencies (-> (get options :language "en")
+                        (symbol-frequencies/default-frequency-factory))]
+    (cond
+      (= analyzer "Chi^2")
+      (ss-analyzers/get-plaintext-and-key message frequencies)
+
+      :else
+      (ss-analyzers/get-plaintext-and-key message frequencies))))
+
 (defn cracking-actions
   [options arguments action-type]
   (let [cipher (:cipher options)]
     (cond
       (= cipher "Caesar")
-      (cracking-caesar options arguments))))
+      (cracking-caesar options arguments)
+
+      (= cipher "Simple substitution and Caesar")
+      (cracking-simple-substitution-with-caesar options arguments))))
 

src/cipher_analytical_machine/cli/options.clj

@@ -32,7 +32,8 @@
   (option-values-as-row "Ciphers" cipher-options))
 
 (def analyzers-options
-  {"Caesar" #{"Chi^2"}})
+  {"Caesar" #{"Chi^2" "Frequency"}
+   "Simple substitution and Caesar" #{"Chi^2" "Frequency"}})
 
 (defn get-available-analyzers-options-as-string
   "Return the formatted string of analyzers options."

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

@@ -13,11 +13,38 @@
       {\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-keys-test
-  (testing "The keys must be the all combinations"
+(deftest get-possible-key-vector-from-reversed-count-map-test
+  (testing "The block order must be in descending order"
+    (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-all-permutation-for-block-test
+  (testing "It must return all permutations"
+    (are [symbols expected-permutations]
+        (= expected-permutations (get-all-permutation-for-block symbols))
+      [\a \b]    ["ab" "ba"]
+      [\a \b \c] ["abc" "acb" "bac" "bca" "cab" "cba"])))
+
+(deftest get-all-combinations-for-blocks-test
+  (testing "The keys must be the all combinations of blocks"
     (are [possible-keys-vector expected-keys]
-        (= expected-keys (get-possible-keys possible-keys-vector))
+        (= expected-keys (get-all-combinations-for-blocks 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"))))
 
+(deftest get-possible-key-combinations-test
+  (testing "The keys must be the all combinations, but the blocks must create a permutations which will be joined as a combination"
+    (are [possible-keys-vector expected-keys]
+        (= expected-keys (get-possible-key-combinations possible-keys-vector))
+      [[\a \b] [\f] [\e \c] [\g]] '("abfecg" "abfceg" "bafecg" "bafceg")
+      [[\a \b] [\a \c]] '("abac" "abca" "baac" "baca")
+      [[\a \b \c] [\a \c] [\b \c]] '("abcacbc" "abcaccb" "abccabc" "abccacb"
+                                     "acbacbc" "acbaccb" "acbcabc" "acbcacb"
+                                     "bacacbc" "bacaccb" "baccabc" "baccacb"
+                                     "bcaacbc" "bcaaccb" "bcacabc" "bcacacb"
+                                     "cabacbc" "cabaccb" "cabcabc" "cabcacb"
+                                     "cbaacbc" "cbaaccb" "cbacabc" "cbacacb"))))
+

test/cipher_analytical_machine/symbols/frequencies_test.clj

@@ -3,7 +3,7 @@
    [clojure.test :refer :all]
    [cipher-analytical-machine.symbols.frequencies :refer :all]))
 
-(deftest calculate-char-index-test
+(deftest map-to-string-test
   (let [symbol-map english-letter-frequencies]
     (testing "The map must be converted to 'etaoinsrhldcumfpgwybvkxjqz'"
       (is (= "etaoinsrhldcumfpgwybvkxjqz"