C[omp]ute

From: andrew cooke <andrew@...>

Date: Wed, 13 Nov 2013 21:34:38 -0300

The RC5 cipher is actually a whole family of related algorithms.  It has a
variable number of rounds, variable key length and, strangest of all, can work
with different sized words.

So there's an 8 bit RC5, a 16 bit RC5, a 32 bit RC5, and a 64 bit RC5.  Those
are common because they match common hardware, but there's nothing stopping
you have a 23 bit RC5 if you really want.

(By the way, the paper defining all this is very clear - see
http://people.csail.mit.edu/rivest/Rivest-rc5.pdf)


So how do you write an implementation without repeating yourself?  Well, of
course, a "real" implementation would be hand-coded C and assembly for speed.
But I wanted a version I could hack (in particular, remove or modify
rotations) so I needed to write my own.  And it turns out that Julia makes it
incredibly easy to implement the common (8,16,32,64) sizes "all at once".

Here, for example, is the encryption for a block (two words):

  function encrypt{W<:Unsigned}(s::State{W}, a::W, b::W)
      a::W = a + s.s[1]
      b::W = b + s.s[2]
      for i = 1:s.r
	  a = rotatel(s.w, a $ b, b) + s.s[2i+1]
	  b = rotatel(s.w, a $ b, a) + s.s[2i+2]
      end
      a, b
  end

The W there can be Uint8, Uint16, Uint32 or Uint64 - and whichever it is, the
code will do the right thing.

For another example, here's the structure that defines the cipher state:

  immutable type State{W<:Unsigned}
      w::Type{W}
      r::Uint8
      k::Array{Uint8}
      s::Array{W}
  end

Note how simple it is to parameterize things by type, and even to store a type
in the structure for easy reference later (as I write this it strikes me that
maybe that should also be available through introspection - I need to check).

More code (some bits are just a little bit uglier) here -
https://github.com/andrewcooke/BlockCipherSelfStudy.jl/blob/master/src/RC5.jl

Andrew