Crypto.Classical.Types

Cipher

class Key k => Cipher k a | a -> k where

A Cipher must be able to encrypt and decrypt. The Cipher type determines the Key type.

Methods

encrypt :: k -> ByteString -> a ByteString

decrypt :: k -> ByteString -> a ByteString

Instances

Cipher EnigmaKey Enigma

When a machine operator presses a key, the Rotors rotate. A circuit is then completed as they hold the key down, and a bulb is lit. Here, we make sure to rotate the Rotors before encrypting the character. NOTE: Decryption is the same as encryption.

Defined in Crypto.Classical.Cipher.Enigma

Methods

encrypt :: EnigmaKey -> ByteString -> Enigma ByteString

decrypt :: EnigmaKey -> ByteString -> Enigma ByteString

Cipher [ℤ / 26] Stream

Defined in Crypto.Classical.Cipher.Stream

Methods

encrypt :: [ℤ / 26] -> ByteString -> Stream ByteString

decrypt :: [ℤ / 26] -> ByteString -> Stream ByteString

Cipher [ℤ / 26] Vigenère

Defined in Crypto.Classical.Cipher.Vigenere

Methods

encrypt :: [ℤ / 26] -> ByteString -> Vigenère ByteString

decrypt :: [ℤ / 26] -> ByteString -> Vigenère ByteString

Cipher (ℤ / 26, ℤ / 26) Affine

Defined in Crypto.Classical.Cipher.Affine

Methods

encrypt :: (ℤ / 26, ℤ / 26) -> ByteString -> Affine ByteString

decrypt :: (ℤ / 26, ℤ / 26) -> ByteString -> Affine ByteString

Cipher (Map Char Char) Substitution

Defined in Crypto.Classical.Cipher.Substitution

Methods

encrypt :: Map Char Char -> ByteString -> Substitution ByteString

decrypt :: Map Char Char -> ByteString -> Substitution ByteString

Cipher (ℤ / 26) Caesar

Defined in Crypto.Classical.Cipher.Caesar

Methods

encrypt :: (ℤ / 26) -> ByteString -> Caesar ByteString

decrypt :: (ℤ / 26) -> ByteString -> Caesar ByteString

Keys

class Key a where

Keys can appear in a number of different forms. E.g. a single number, a tuple, a mapping, etc. Each needs to be interpreted uniquely by a Cipher's encrypt and decrypt algorithms.

Methods

key :: CPRG g => g -> a

Randomly generate a Key.

Instances

Key EnigmaKey

Note that the randomly generated initial Rotor positions are not applied to the Rotors when the key is generated. They have to be applied before first use.

Defined in Crypto.Classical.Types

Methods

key :: CPRG g => g -> EnigmaKey

Key [ℤ / 26]

Key for Stream/Vigenère Cipher.

Defined in Crypto.Classical.Types

Methods

key :: CPRG g => g -> [ℤ / 26]

Key (ℤ / 26, ℤ / 26)

For Affine Ciphers. a must be coprime with 26, or else a^-1 won't exist and and we can't decrypt.

Defined in Crypto.Classical.Types

Methods

key :: CPRG g => g -> (ℤ / 26, ℤ / 26)

Key (Map Char Char)

Key for Substitution Cipher. The Key is the Mapping itself.

Defined in Crypto.Classical.Types

Methods

key :: CPRG g => g -> Map Char Char

Key (ℤ / 26)

Defined in Crypto.Classical.Types

Methods

key :: CPRG g => g -> ℤ / 26

Enigma Types

data EnigmaKey

Essentially the machine itself. It is made up of: 1. Three rotor choices from five, in a random placement. 2. Initial settings of those Rotors. 3. The Reflector model in use. 4. Plugboard settings (pairs of characters).

Constructors

EnigmaKey

Fields

• _rotors :: [Rotor]
• _settings :: String
• _reflector :: Reflector
• _plugboard :: Plugboard

Instances

Eq EnigmaKey

Defined in Crypto.Classical.Types

Methods

(==) :: EnigmaKey -> EnigmaKey -> Bool

(/=) :: EnigmaKey -> EnigmaKey -> Bool

Show EnigmaKey

Defined in Crypto.Classical.Types

Methods

showsPrec :: Int -> EnigmaKey -> ShowS

show :: EnigmaKey -> String

showList :: [EnigmaKey] -> ShowS

Key EnigmaKey

Note that the randomly generated initial Rotor positions are not applied to the Rotors when the key is generated. They have to be applied before first use.

Defined in Crypto.Classical.Types

Methods

key :: CPRG g => g -> EnigmaKey

Cipher EnigmaKey Enigma

When a machine operator presses a key, the Rotors rotate. A circuit is then completed as they hold the key down, and a bulb is lit. Here, we make sure to rotate the Rotors before encrypting the character. NOTE: Decryption is the same as encryption.

Defined in Crypto.Classical.Cipher.Enigma

Methods

encrypt :: EnigmaKey -> ByteString -> Enigma ByteString

decrypt :: EnigmaKey -> ByteString -> Enigma ByteString

data Rotor

A Rotor (German: Walze) is a wheel labelled A to Z, with internal wirings from each entry point to exit point. There is also a turnover point, upon which a Rotor would turn its left neighbour as well. Typically said turnover point is thought of in terms of letters (e.g. Q->R for Rotor I). Here, we represent the turnover point as a distance from A (or 0, the first entry point). As the Rotor rotates, this value decrements. When it rolls back to 25 (modular arithmetic), we rotate the next Rotor.

Our Rotors are letter-agnostic. That is, they only map numeric entry points to exit points. This allows us to simulate rotation very simply with Lenses.

Constructors

Rotor

Fields

• _name :: Text
• _turnover :: ℤ / 26
• _circuit :: Map (ℤ / 26) (ℤ / 26)

Instances

Eq Rotor

Defined in Crypto.Classical.Types

Methods

(==) :: Rotor -> Rotor -> Bool

(/=) :: Rotor -> Rotor -> Bool

Show Rotor

Defined in Crypto.Classical.Types

Methods

showsPrec :: Int -> Rotor -> ShowS

show :: Rotor -> String

showList :: [Rotor] -> ShowS

type Reflector = Map (ℤ / 26) (ℤ / 26)

A unmoving map, similar to the Rotors, which feeds the electrical current back into Rotors. This would never feed the left Rotor's letter back to itself, meaning a plaintext character would never encrypt to itself. This was a major weakness in scheme which allowed the Allies to make Known Plaintext Attacks against the machine.

type Plugboard = Map (ℤ / 26) (ℤ / 26)

A set of 10 pairs of connected letters which would map letters to other ones both before and after being put through the Rotors. The remaining six unpaired letters can be thought of mapping to themselves.

name :: Lens' Rotor Text

turnover :: Lens' Rotor ((/) ℤ 26)

circuit :: Lens' Rotor (Map ((/) ℤ 26) ((/) ℤ 26))

rotors :: Lens' EnigmaKey [Rotor]

settings :: Lens' EnigmaKey String

reflector :: Lens' EnigmaKey Reflector

plugboard :: Lens' EnigmaKey Plugboard

plugFrom :: [(Char, Char)] -> Plugboard

Given a list of letter pairs, generates a Plugboard. Any letters left out of the pair list will be mapped to themselves.