Git for beginners 4b: Working with remote branches
Moving code around with branches
Using a spreadsheet for Caesar ciphers.
You don't always need to use a programming language for cryptography. In this post, I describe how to use a spreadsheet to encipher and deciper with a Caesar cipher.
You can follow along with a copy of the spreadsheet on Google Drive. You'll find this post makes a lot more sense if you can see how all the bits fit together in the spreadsheet, as well as being able to see the results of the formulas used. Make your own copy of it if you want to encipher and decipher your own messages.
Describing how the spreadsheet works is tricky, as you can't just quote snippets of program code and discuss them. I've broken the spreadsheet down into regions (see the diagram below) and will go through them, region by region, describing how it all fits together.
At the top of the spreadsheet, in cells B2 to B6, is the "dashboard" summarising the cipher breaking.
=AA47
).=AA48
).To use the spreadsheet, you put your message in cell B2 and the key in cell B4. The spreadsheet will then encipher the message and put the result in cell B7 and decipher the message with the result in cell B6. That way, you don't have to tell the spreadsheet whether you want the message enciphered or decipered: it does both for you.
During the processing, the spreadsheet uses uppercase for ciphertext letters and lowercase for plaintext letters. That means that case isn't preserved in the generated plaintext and ciphertext.
Just a copy of the alphabet.
Simply all the shifts for the Caesar cipher, 0–25.
Each cell in this block says what each plaintext letter would be, with the Caesar shift given in the corresponding row in A16:A41.
A  B  C  D  …  Z  AA  

10  a  b  c  …  y  z  
\( \vdots \)  
16  0  =B10 
=C10 
=C10 
…  =Z10 
=AA10 
17  1  =C16 
=D16 
=E16 
…  =AA16 
=B16 
18  2  =C17 
=D17 
=E17 
…  =AA17 
=B17 
\( \vdots \)  \( \vdots \)  \( \vdots \)  \( \vdots \)  \( \vdots \)  \( \vdots \)  \( \vdots \)  \( \vdots \) 
41  25  =C40 
=D40 
=E40 
…  =AA40 
=B40 
Cells B16 to AA16 just contain the formulas =B10
to =AA10
: a Caesar shift of 0 gives the original alphabet.
Cells B17 to Z17 each contain the formula =C16
to =AA16
: in other words, the content of the cell one above and to the right. Cell AA17 contains the formula =B16
. Together, these formulas rotate the row above one space to the left, with the leftmost cell of the block moving to the right.
Cut and paste row B17:AA17 into the remaining rows of the block, B18:AA41. You'll end up with all the shifts of the alphabet, with row 41 containing z a b c … w x y
.
Now we know how to do convert plaintext to ciphertext letters for all shifts, we can do the enciphering and deciphering for the shift given in cell B4.
Each column in the shifted plaintext block shows how a single plaintext letter is transformed with different shifts. Going down column B, you can see how a
is transformed into a
, b
, c
, … as the Caesar shift changes from 0, 1, 2, …
We treat the shifted plaintext block as a large lookup table, giving us the ciphertext letters we need. The LOOKUP
function does the lookups for us.
  B  C  D  …  AA 
::::::::::::::
 44  =UPPER(LOOKUP($B$4, $A$16:$A$41, B16:B41))
 =UPPER(LOOKUP($B$4, $A$16:$A$41, C16:C41))
 =UPPER(LOOKUP($B$4, $A$16:$A$41, D16:D41))
 …  =UPPER(LOOKUP($B$4, $A$16:$A$41, AA16:AA41))

 45 =B10
 =C10
 =D10
 …  =AA10

LOOKUP
can be used in a couple of ways. The way I'm using it here has this signature:
LOOKUP(search_key, search_range, result_range)
The function looks for the search_key
in the search_range
(either a row or a column). If it finds the key, it moves along the result_range
the same number of steps and returns the value it finds there. The result_range
can be either a row or a column, but need not be the same shape as the search range
.
In this case, the search_key
is the identified Caesar shift, found in cell B4. The search_range
is the list of possible shifts in the cells A16:A41. The result_range
depends on the plaintext letter we're after. It's the column under the appropriate plaintext letter from the alphabet block. For a
, the result_range
is B16:B41. For b
, the result range is C16:C41, and so on, up until AA16:AA41 for the column corresponding to z
.
Therefore, we can say the formula LOOKUP($B$4, $A$16:$A$41, B16:B41)
will give the ciphertext letter corresponding to plaintext a
for the Caesar shift we're using.
As we're using uppercase letters for ciphertext, we wrap the result in a call to UPPER()
to convert the ciphertext letter to uppercase.
That explains row 44: it's the ciphertext letters for each . Row 45 is just those plaintext letters, copied down from B10:AA10.
Now for rows 47 and 48.
B  C  D  …  AA  

47  =SUBSTITUTE(UPPER($B$2), B44, B45) 
=SUBSTITUTE(B47, C44, C45) 
=SUBSTITUTE(C47, D44, D45) 
…  =SUBSTITUTE(Z47, AA44, AA45) 
48  =SUBSTITUTE(LOWER($B$2), B45, B44) 
=SUBSTITUTE(B47, C45, C45) 
=SUBSTITUTE(C47, D45, D44) 
…  =SUBSTITUTE(Z47, AA45, AA44) 
The SUBSTITUTE(where, search, replace)
command looks in where
for text search
and replaces it with replace
. When enciphering, we use it to substitute platinext letters with ciphertext letters. When deciphering, we replace ciphertext letters with plaintext.
Cells B44:AA44 and B45:AA45 together show how each ciphertext letter relates to a plaintext letter. The cells in B47:AA47 do the conversion from ciphertext to plaintext. With a shift of 21, B44:B45 will say that ciphertext V
corresponds to plaintext a
.
The formula in B47 converts all the V
s in the message into a
s. The formula in C47 takes the result of in B47 and then converts all the W
s into b
s. D47 takes the result in C47 and converts all the X
s into c
s, and so on until AA47 converts all the U
s into z
s. The result in AA47 is the final, extracted plaintext, and that result is copied up to the dashboard by cell B6.
This is why the use of case to distinguish plaintext and ciphertext is important. With a shift of 21, ciphertext v
converts to plaintext a
, and ciphertext a
converts to plaintext f
. If we just did those two conversions one after the other, the final plaintext would have no a
s but a whole bunch of f
s. However, if we use case, we can distinguish between the conversions V
to a
and A
to f
. That's why where's a call to UPPER
in cell B47: it ensures that what we're treating as ciphertext is all uppercase.
In the same way, the cells B48:AA48 convert the message into ciphertext.
The two results, AA47 and AA48, a copied back up to the dashboard.
And that's the result! That's how you can use a spreadsheet to implement Caesar ciphers.
There's no particular reason why you can't extend this approach to other ciphers, such as the affine cipher. But there is a practical limit to do with the number of keys. The Caesar cipher has 25 possible keys. The affine cipher has 12 × 26 × 2 = 624 possible keys. That would mean that the spreadsheet would need 624 rows in the large blocks, as you still need one row for each possible key.
I've not got around to building a spreadsheet that large, but there's no reason why you couldn't.
Post cover image by NordWood Themes.