After using Python in some small projects, my attention turned to a much more attractive language, Haskell. Haskell is a functional programming language with non-strict (“lazy”) semantics and strong static typing. It is relatively new (1990) and surprisingly well-defined, despite being created by a committee. The most popular Haskell compiler & interpreter, GHC (the Glasgow Haskell Compiler), is open-source software, available for Windows, Mac and Linux platforms.

The language is named after Haskell Brooks Curry, whose work in mathematical logic serves as a foundation for functional languages. Haskell and other functional languages are based on the lambda calculus which, according to the Church–Turing thesis, is as powerful as the Turing machine (that serves as a paradigm for imperative languages like C, C++, Java and others) for expressing computable functions.

Learning how to program in Haskell has been a rewarding experience for me. At some point, it reminded myself of a famous quote by Benjamin Whorf, “language shapes the way we think and determines what we can think about.” I will comment on my learning experience in Haskell in another post. For the moment, I would like to comment about the RC4 cryptographic algorithm and its implementation in Haskell. RC4 is a remarkably simple algorithm (already coded in Python in another post), and thus the obvious choice as the first cryptographic algorithm to be coded in a new programming language.

As the next box shows [1], it is possible to code the RC4 algorithm in less than ten lines of Haskell. The resulting code, although totally functional (no pun intended), definitely does not meet software quality standards, but does really show Haskell conciseness.

```
module Crypto.RC4 where
import Data.Char;import Data.Array
prga=prga' 0 0 where prga' i j s=let{i'=succ i`mod`256;j'=(s!i'+j)`mod`256;
s' = swap i' j' s;t = s'!((s!i'+s!j') `mod` 256)} in chr t : prga' i' j' s'
ksa k = ksa' 0 0 $ array (0,255) [(i,i)|i<-[0..255]] where {ksa' 256 _ s=s;
ksa' i j s = let {i'= i `mod` length k; j' = (j+s!i+ord(k!!i')) `mod` 256}
in ksa' (succ i) j' (swap j' i s)}
swap i j s = if i /= j then s // [(i, s ! j), (j, s ! i)] else s
```

**The RC4 stream cipher algorithm**

RC4, a variable key-size stream cipher with byte-oriented operations, is the most widely used stream cipher algorithm. It was designed by Ronald Rivest in 1987 for RSA Data Security (now RSA Security, a division of EMC²). RC4, also known as ARC4 [2], was kept as a trade secret until 1994, when it was posted anonymously to the cypherpunks mailing list.

RC4 creates a finite-state machine that uses a state array of 256 bytes. Initially, this array is set to the identity permutation (see pseudo-code below). The next step is performed by the Key Scheduling Algorithm (KSA), which traverses the state array swapping its elements based on the key, which size can be defined anywhere in the range of 40 to 2,048 bits [3]. As soon as KSA finishes its job, the key can be discarded since its contribution has been incorporated into the state array.

The state array is then ready for the Pseudo-Random Generation Algorithm (PRGA) to generate the stream cipher that will be *xor’d* with the plaintext (encryption) or with the ciphertext (decryption). Every time a byte is produced, the state array is permuted once more [4].

```
############ RC4 pseudo-code (extracted from Wikipedia) ############
# RC4 array state initialization
for i from 0 to 255
S[i] := i
endfor
# Key Scheduling Algorithm (KSA)
j := 0
for i from 0 to 255
j := (j + S[i] + key[i mod keylength]) mod 256
swap values of S[i] and S[j]
endfor
# Pseudo-Random Generation Algorithm (PRGA)
i := 0
j := 0
while GeneratingOutput:
i := (i + 1) mod 256
j := (j + S[i]) mod 256
swap values of S[i] and S[j]
K := S[(S[i] + S[j]) mod 256]
output K
endwhile
```

**RC4 implementation in Haskell**

In the expanded version (see box below), the following aspects were changed:

- An extra module,
`Data.Bits`

, was imported to support the`xor`

operation required by the`encrypt`

function, absent in the first program, since it is not related to the RC4 algorithm itself (its task is just to combine the keystream generated by any stream cipher with the cleartext or ciphertext digits). - Only external objects (functions, types, data and value constructors) effectively used were imported from modules
`Data.Char, Data.Array`

and`Data.Bits`

. - All top-level functions declared were assigned type signatures (those lines containing the double-colon operator). Although the Haskell compiler can (most of time) infer types automatically, it is strongly recommended to state them explicitly to assist the compiler in generating a more efficient code and to provide a better documentation.
- Curly braces and semi-colons were substituted for indentation to structure code (unlike Python, indentation is not compulsory in Haskell).
- A short descriptive comment was added to the four top-level functions (
`encrypt, prga, ksa`

and`swap`

).

```
-------------------------------------------------------------
--
-- Author: Joao H de A Franco (jhafranco@acm.org)
--
-- Description: RC4 implementation in Haskell
--
-- Date: 2013-Feb-22
--
-- License: Attribution-NonCommercial-ShareAlike 3.0 Unported
-- (CC BY-NC-SA 3.0)
--
-------------------------------------------------------------
module Crypto.RC4 (encrypt) where
import Data.Array (Array, array, (//), (!))
import Data.Char (chr, ord)
import Data.Bits (xor)
type ArrayRC4 = Array Int Int
type Index = Int
type Key = String
type Stream = String
-- Encrypt (or decrypt) using RC4 keystream
encrypt :: Key -> String -> String
encrypt k c = map chr $ zipWith xor (map ord (stream k)) (map ord c)
where stream = prga . ksa
-- Pseudo-random generation algorithm (PRGA)
prga :: ArrayRC4 -> Stream
prga = prga' 0 0
where prga' i j s = let i' = succ i `mod` 256
j' = (s ! i' + j) `mod` 256
s' = swap i' j' s
t = s' ! ((s ! i' + s ! j') `mod` 256)
in chr t : prga' i' j' s'
-- Key Scheduling Algorithm (KSA)
ksa :: Key -> ArrayRC4
ksa k = ksa' 0 0 $ array (0,255) [(i,i) | <- [0..255]]
where ksa' 256 _ s = s
ksa' i j s = let i' = i `mod` length k
j' = (j + s ! i + ord (k !! i')) `mod` 256
in ksa' (succ i) j' (swap j' i s)
-- Swap the values of S[i] and S[j]
swap :: Index -> Index -> ArrayRC4 -> ArrayRC4
swap i j s = if i /= j then s // [(i, s ! j), (j, s ! i)] else s
```

Let’s go over the code. Initially, the state array is created and set to the identity permutation, which is done by the expression (listed inside `ksa`

body)

`array (0,255) [(i,i) | i<- [0..255]]`

which creates a value of the type `ArrayRC4`

(which is a synonym for `Array Int Int`

) with the help of the `array`

function imported from the `Data.Array`

module. This function requires two parameters: the array bounds and the array contents. The array bounds (the lowest and highest indices in the array) are expressed as the Haskell tuple `(0,255)`

, while its contents are specified by a list of tuples of the form *(index, value)*: `[(0,0),(1,1),(2,2)...(255,255)]`

, that can be expressed much more concisely as a list comprehension: `[(i,i)|<-[0..255]]`

.

Being Haskell a strong static typed language, every expression to be computed must have a well defined type during compilation time. Since indices and elements change places in both functions, `ksa`

and `prga`

, their types must be exactly the same, `Int`

in this case. Although we haven’t explicitly declared the type of the array state, the Haskell compiler will infer it from the type declarations `ksa :: Key -> ArrayRC4`

(which states that the function `ksa`

produces an output of type `ArrayRC4`

) and `ksa' 256 _ s = s`

(which requires that `ksa'`

last parameter to be of type `ArrayRC4`

).

**The swap function**

```
-- Swap values of S[i] and S[j]
swap :: Index -> Index -> ArrayRC4 -> ArrayRC4
swap i j s = if i /= j then s // [(i, s ! j), (j, s ! i)] else s
```

The `swap`

function accepts two indices (of type `Index`

, a synonym for `Int`

) and the state array (of type `ArrayRC4`

) as inputs and produces a new, updated state array after swapping the contents of the two specified array elements. Arrays of type `Data.Array.Array`

(the only array type supported by Haskell 98) are, like any other pure functional data structures, *immutables*, so once created they cannot be changed, only queried. In order to do its job, `swap`

uses the incremental array update infix operator, `//`

, imported from the `Data.Array`

module. For example, an array `a`

with an element `i`

updated to value `v`

is written `a//[(i,v)]`

.

This array update is not very efficient (both in terms of time and memory), as a new copy of the array must be carried out before any changes can be applied. On the other hand, those arrays can be used in pure functional code [6]. The second operator imported from the `Data.Array`

module is the array subscripting infix operator `!`

(as an example, the expression `a!i`

returns the value at index `i`

of an array `a`

).

**The ksa function**

```
-- Key Scheduling Algorithm (KSA)
ksa :: Key -> ArrayRC4
ksa k = ksa' 0 0 $ array (0,255) [(i,i) | <- [0..255]]
where ksa' 256 _ s = s
ksa' i j s = let i' = i `mod` length k
j' = (j + s ! i + ord (k !! i')) `mod` 256
in ksa' (succ i) j' (swap j' i s)
```

The `ksa`

function accepts a key (of type `Key`

, a synonym for `String`

) as input and outputs the state array (of type `ArrayRC4`

). Since there is no “loop” construction in Haskell, recursion is used instead. The `ksa`

function just set the initial parameters for an auxiliary, recursive function, `ksa'`

, that does the hard work, visiting every single element of the array state. Its parameters are `i`

(first index and counter), `j`

(second index) and `s`

(the state array). The stop condition (otherwise the recursion will never stop) is met, via Haskell’s pattern match, when `i`

is equal to 256.

Two additional comments:

- List subscripting is done by the infix operator
`!!`

, made available by the`Prelude`

module (a standard module imported by default into all Haskell modules). - If a function (or constructor) takes two or more arguments, like
`mod`

, it can be used in infix form by enclosing its name in backtick characters (``mod``

).

**The prga function**

```
-- Pseudo-random generation algorithm (PRGA)
prga :: ArrayRC4 -> Stream
prga = prga' 0 0
where prga' i j s = let i' = succ i `mod` 256
j' = (s ! i' + j) `mod` 256
s' = swap i' j' s
t = chr $ s' ! ((s ! i' + s ! j') `mod` 256)
in t : prga' i' j' s'
```

The `prga`

function accepts the initialized state array (of type `ArrayRC4`

) as input and outputs the keystream (of type `Stream`

, a synonym for `String`

), represented in Haskell by a list of characters of (potentially) infinite length. This is no problem for non-strict languages like Haskell, Miranda and Clean. In particular, Haskell, and also Miranda, adopt the approach known as “lazy evaluation” (or “call-by-need”): an expression is evaluated only when its value is required.

**The encrypt function**

```
-- Encrypt (or decrypt) using RC4 keystream
encrypt :: Key -> String -> String
encrypt k c = map chr $ zipWith xor (map ord (stream k)) (map ord c)
where stream k' = prga (ksa k')
```

The `encrypt`

function defines the encryption/decryption service interface: it accepts the key (of type `Key`

) and the plaintext/ciphertext (of type `String`

) and returns the ciphertext/plaintext (also of type `String`

). It is interesting to examine how the expression below is evaluated.

`-- zipWith xor (map ord (stream k)) (map ord c)`

The `zipWith`

function (exported by the Prelude module) accepts a binary function and two lists and produces a third list which elements are calculated applying the function to the elements occurring at the same position in both lists (in this particular case, the binary function is `xor`

, and the three lists are of type `[Int]`

). If the first two lists are of different length, the longer one is truncated to make them of the same size.

The first list, the keystream (represented as a list of integers), has potentially infinite length, while the second one, the cleartext/ciphertext (also represented as a list of integers), has finite length. Haskell’s lazy evaluation of this expression will demand from the `prga`

function a keystream exactly as long as that of the cleartext or ciphertext being encrypted (decrypted).

**The Main module**

Since RC4 is a proprietary algorithm, there are no official test suite for validating RC4 implementations [5]. A quick check can be performed, however, using the unofficial test vectors available at Wikipedia.

The program below executes the three tests described at Wikipedia and a fourth that checks whether the `encrypt`

function is an involution (a function that it is own inverse) testing a single point of its domain. The keys and plaintext shown in the code are ASCII while the keystream and ciphertext are in hexadecimal.

```
-------------------------------------------------------------
--
-- Author: Joao H de A Franco (jhafranco@acm.org)
--
-- Description: Test module for RC4 implementation in Haskell
--
-- Date: 2013-Feb-22
--
-- License: Attribution-NonCommercial-ShareAlike 3.0 Unported
-- (CC BY-NC-SA 3.0)
--
-------------------------------------------------------------
module Main where
import Crypto.RC4 (encrypt)
import Numeric (showHex)
import Data.Char (ord)
-- The first threee test-vectors are from Wikipedia
-- (http://en.wikipedia.org/wiki/RC4#Test_vectors)
main :: IO ()
main = do
-- Test #1 ----------------------------------------
let t1 = encrypt "Key" "Plaintext"
check (convert t1 == "bbf316e8d940af0ad3") 1
-- Test #2 ----------------------------------------
let t2 = encrypt "Wiki" "pedia"
check (convert t2 == "1021bf0420") 2
-- Test #3 ----------------------------------------
let t3 = encrypt "Secret" "Attack at dawn"
check (convert t3 == "45a01f645fc35b383552544b9bf5") 3
-- Test #4 ----------------------------------------
let t4 = encrypt "bla-bla-bla" "Do you want to know a secret?"
let t4' = encrypt "bla-bla-bla" t4
check (t4' == "Do you want to know a secret?") 4
check :: Bool -> Int -> IO ()
check f t = putStrLn $ "Test " ++ show t ++ if f then ": ok" else ": nok"
convert :: String -> String
convert = concatMap (showHex' . ord)
where showHex' x = let y = showHex x ""
in if length y == 1 then '0' : y else y
```

**Comments**

The `main`

function (in the `Main`

module) can be evaluated using GHCi (GHC’s interactive environment), in which Haskell expressions can be interactively evaluated and programs can be interpreted. The output is shown below:

```
GHCi, version 7.4.2: http://www.haskell.org/ghc/
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Loading package array-0.4.0.0 ... linking ... done.
[2 of 2] Compiling Main (/home/jhaf/workspace/RC4a/src/Main.hs, interpreted)
Ok, modules loaded: Main, Crypto.RC4
*Main> main
Test 1: ok
Test 2: ok
Test 3: ok
Test 4: ok
```

Note 1 – You will see no syntax highlighting in all boxes showing Haskell code because it is not a programming language supported by WordPress.com. Although Haskell is not particularly popular — it is in position #33 in the TIOBE Programming Community Index — other languages ranked worse than Haskell in the TIOBE index (Scala, Erlang, F#, Clojure, VB and Powershell) are indeed supported by WordPress.com.

Note 2 – The name RC4 is a trademark of RSA Security. For this reason, RC4 is often referred to as ARCFOUR or ARC4 (alleged RC4) to avoid trademark problems. RSA Security has never officially released the algorithm.

Note 3 – Until 2000, when the U.S. government relaxed export regulations on cryptography, only encryption software with keys up to 40 bits could be exported by U.S. companies. While this lower limit is just a convention, the upper one is real: if the key is greater than 2,048 bits (which happens to be 8 x 256), the excess bytes will be just dropped by the KSA.

Note 4 – An interesting RC4 tutorial with animation is available at Marc Loiseau’s blog).

Note 5 – Haskell libraries with other, more complex, implementations of arrays – but which have far more features – are available, some of which are mutable and/or strict.

Note 6 – As RSA was the sole primary vendor of cryptographic kits that include implementations of RC4, which was not an approved algorithm for use by the U.S. government, there was no (strong) demand for a test suite for validating RC4 implementations.