Solution for simple cypher

Author: Quentin Ménoret

simple-cipher/README.md

@@ -0,0 +1,145 @@
+# Simple Cipher
+
+Implement a simple shift cipher like Caesar and a more secure substitution cipher.
+
+## Step 1
+
+"If he had anything confidential to say, he wrote it in cipher, that is,
+by so changing the order of the letters of the alphabet, that not a word
+could be made out. If anyone wishes to decipher these, and get at their
+meaning, he must substitute the fourth letter of the alphabet, namely D,
+for A, and so with the others."
+—Suetonius, Life of Julius Caesar
+
+Ciphers are very straight-forward algorithms that allow us to render
+text less readable while still allowing easy deciphering. They are
+vulnerable to many forms of cryptoanalysis, but we are lucky that
+generally our little sisters are not cryptoanalysts.
+
+The Caesar Cipher was used for some messages from Julius Caesar that
+were sent afield. Now Caesar knew that the cipher wasn't very good, but
+he had one ally in that respect: almost nobody could read well. So even
+being a couple letters off was sufficient so that people couldn't
+recognize the few words that they did know.
+
+Your task is to create a simple shift cipher like the Caesar Cipher.
+This image is a great example of the Caesar Cipher:
+
+![Caesar Cipher][1]
+
+For example:
+
+Giving "iamapandabear" as input to the encode function returns the cipher "ldpdsdqgdehdu". Obscure enough to keep our message secret in transit.
+
+When "ldpdsdqgdehdu" is put into the decode function it would return
+the original "iamapandabear" letting your friend read your original
+message.
+
+## Step 2
+
+Shift ciphers are no fun though when your kid sister figures it out. Try
+amending the code to allow us to specify a key and use that for the
+shift distance. This is called a substitution cipher.
+
+Here's an example:
+
+Given the key "aaaaaaaaaaaaaaaaaa", encoding the string "iamapandabear"
+would return the original "iamapandabear".
+
+Given the key "ddddddddddddddddd", encoding our string "iamapandabear"
+would return the obscured "lpdsdqgdehdu"
+
+In the example above, we've set a = 0 for the key value. So when the
+plaintext is added to the key, we end up with the same message coming
+out. So "aaaa" is not an ideal key. But if we set the key to "dddd", we
+would get the same thing as the Caesar Cipher.
+
+## Step 3
+
+The weakest link in any cipher is the human being. Let's make your
+substitution cipher a little more fault tolerant by providing a source
+of randomness and ensuring that the key is not composed of numbers or
+capital letters.
+
+If someone doesn't submit a key at all, generate a truly random key of
+at least 100 characters in length, accessible via Cipher#key (the #
+syntax means instance variable)
+
+If the key submitted has capital letters or numbers, throw an
+ArgumentError with a message to that effect.
+
+## Extensions
+
+Shift ciphers work by making the text slightly odd, but are vulnerable
+to frequency analysis. Substitution ciphers help that, but are still
+very vulnerable when the key is short or if spaces are preserved. Later
+on you'll see one solution to this problem in the exercise
+"crypto-square".
+
+If you want to go farther in this field, the questions begin to be about
+how we can exchange keys in a secure way. Take a look at [Diffie-Hellman
+on Wikipedia][dh] for one of the first implementations of this scheme.
+
+[1]: https://upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Caesar_cipher_left_shift_of_3.svg/320px-Caesar_cipher_left_shift_of_3.svg.png
+[dh]: http://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange
+
+
+## Getting Started
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/haskell).
+
+## Running the tests
+
+To run the test suite, execute the following command:
+
+```bash
+stack test
+```
+
+#### If you get an error message like this...
+
+```
+No .cabal file found in directory
+```
+
+You are probably running an old stack version and need
+to upgrade it.
+
+#### Otherwise, if you get an error message like this...
+
+```
+No compiler found, expected minor version match with...
+Try running "stack setup" to install the correct GHC...
+```
+
+Just do as it says and it will download and install
+the correct compiler version:
+
+```bash
+stack setup
+```
+
+## Running *GHCi*
+
+If you want to play with your solution in GHCi, just run the command:
+
+```bash
+stack ghci
+```
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/xhaskell](https://github.com/exercism/xhaskell) repository on
+GitHub is the home for all of the Haskell exercises.
+
+If you have feedback about an exercise, or want to help implementing a new
+one, head over there and create an issue.  We'll do our best to help you!
+
+## Source
+
+Substitution Cipher at Wikipedia [http://en.wikipedia.org/wiki/Substitution_cipher](http://en.wikipedia.org/wiki/Substitution_cipher)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+

simple-cipher/package.yaml

@@ -0,0 +1,21 @@
+name: simple-cipher
+version: 0.1.0.2
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Cipher
+  source-dirs: src
+  dependencies:
+    - random
+  # - foo       # List here the packages you
+  # - bar       # want to use in your solution.
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - simple-cipher
+      - hspec

simple-cipher/simple-cipher.cabal

@@ -0,0 +1,31 @@
+-- This file has been generated from package.yaml by hpack version 0.15.0.
+--
+-- see: https://github.com/sol/hpack
+
+name:           simple-cipher
+version:        0.1.0.2
+build-type:     Simple
+cabal-version:  >= 1.10
+
+library
+  hs-source-dirs:
+      src
+  build-depends:
+      base
+    , random
+  exposed-modules:
+      Cipher
+  other-modules:
+      Paths_simple_cipher
+  default-language: Haskell2010
+
+test-suite test
+  type: exitcode-stdio-1.0
+  main-is: Tests.hs
+  hs-source-dirs:
+      test
+  build-depends:
+      base
+    , simple-cipher
+    , hspec
+  default-language: Haskell2010

simple-cipher/src/Cipher.hs

@@ -0,0 +1,38 @@
+module Cipher (caesarDecode, caesarEncode, caesarEncodeRandom) where
+
+import Data.Char (toLower, isLower)
+import System.Random
+
+caesarDecode :: String -> String -> String
+caesarDecode a b = map r $ zipLoop a b
+    where
+        r (x, y) = (toEnum $ fromEnum 'a' + diff x y) :: Char
+        diff x y = (26 + toPos y - toPos x) `rem` 26
+
+caesarEncode :: String -> String -> String
+caesarEncode a b = map r $ zipLoop a b
+    where
+        r (x, y) = (toEnum $ fromEnum 'a' + diff x y) :: Char
+        diff x y = (toPos x + toPos y) `rem` 26
+
+toPos :: Char -> Int
+toPos a = (fromEnum . toLower) a - 97
+
+zipLoop :: [a] -> [b] -> [(a, b)]
+zipLoop short long = r short long
+    where
+        r _ [] = []
+        r [] a = r short a
+        r (x:xs) (y:ys) = (x,y):r xs ys
+
+caesarEncodeRandom :: String -> IO (String, String)
+caesarEncodeRandom text = do
+    key <- generateStr 1000
+    return (key, caesarEncode key text)
+
+generateStr :: Int -> IO String
+generateStr 0   = return ""
+generateStr len = (:) <$> generateChar <*> generateStr (len - 1)
+    where
+        generateChar :: IO Char
+        generateChar = toEnum <$> getStdRandom (randomR (97, 122))

simple-cipher/stack.yaml

@@ -0,0 +1 @@
+resolver: lts-8.2

simple-cipher/test/Tests.hs

@@ -0,0 +1,55 @@
+import Test.Hspec        (Spec, it, shouldBe)
+import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
+
+import Cipher (caesarDecode, caesarEncode, caesarEncodeRandom)
+
+main :: IO ()
+main = hspecWith defaultConfig {configFastFail = True} specs
+
+specs :: Spec
+specs = do
+
+    it "no-op encode" $ do
+      caesarEncode         "a"  ['a'..'z'] `shouldBe` ['a'..'z']
+      caesarEncode (repeat 'a') ['a'..'z'] `shouldBe` ['a'..'z']
+
+    it "no-op decode" $ do
+      caesarDecode         "a"  ['a'..'z'] `shouldBe` ['a'..'z']
+      caesarDecode (repeat 'a') ['a'..'z'] `shouldBe` ['a'..'z']
+
+    it "reversible" $ do
+      let k0 = "alkjsdhflkjahsuid"
+          k1 = ['z','y'..'a']
+      caesarDecode k0 (caesarEncode k0 "asdf") `shouldBe` "asdf"
+      caesarDecode k1 (caesarEncode k1 "asdf") `shouldBe` "asdf"
+
+    it "known cipher" $ do
+      let k = ['a'..'j']
+          encode = caesarEncode k
+          decode = caesarDecode k
+      encode "aaaaaaaaaa"        `shouldBe` k
+      decode k                   `shouldBe` "aaaaaaaaaa"
+      decode (encode ['a'..'z']) `shouldBe` ['a'..'z']
+      encode "zzzzzzzzzz"        `shouldBe` 'z':['a'..'i']
+
+    it "double shift" $ do
+      let plaintext  = "iamapandabear"
+          ciphertext = "qayaeaagaciai"
+      caesarEncode plaintext plaintext `shouldBe` ciphertext
+
+    it "shift cipher" $ do
+      let encode = caesarEncode "d"
+          decode = caesarDecode "d"
+      encode "aaaaaaaaaa"        `shouldBe` "dddddddddd"
+      decode "dddddddddd"        `shouldBe` "aaaaaaaaaa"
+      encode ['a'..'j']          `shouldBe` ['d'..'m']
+      decode (encode ['a'..'j']) `shouldBe` ['a'..'j']
+
+    it "random tests" $ do
+      let plaintext = take 1000 (cycle ['a'..'z'])
+      p1 <- caesarEncodeRandom plaintext
+      uncurry caesarDecode p1 `shouldBe` plaintext
+      p2 <- caesarEncodeRandom plaintext
+      uncurry caesarDecode p2 `shouldBe` plaintext
+      -- There's a small chance this could fail, since it's random.
+      (p1 == p2) `shouldBe` False