Redoing Caesar to make it more robust

Recall the procedures we defined in the last worksheet:

>

caesarb := proc(letter, key) #This procedure changes one letter with a ceasar code      local temp, temp2;      temp := letter:    if temp > 64 then       if temp < 91 then          temp := 65 + ((temp - 65 + key) mod 26):      fi:fi:    if temp > 96 then       if temp < 123 then          temp := 97 + ((temp - 97 + key) mod 26):      fi:fi:    temp:   end: encodecaesarb := proc(message, key) #This procedure uses ceasarb to uncode a string      local temp:       #first convert the message to numerical equivalents     temp[1] := convert(message, bytes):       #then add the key to each letter to scrable the letters     temp[2] := map(caesarb, temp[1], key):       #then convert back to the ASCII code     convert(temp[2], bytes);   end: breakcaesarb := proc(message) #This procedure uses encodeceasarb to try all the keys on a given message.      local temp, key;    for key from 1 to 25 do       temp := encodecaesarb(message, - key):       print(`The key of `||key,` produces - `,temp);       od;    end:

We would like to modify them so that we can use another monoalphabetic cipher rather than the simple Caesar cipher.  To do that we would like the addition of the key mod 26 to be pulled out into a separate procedure.  We first give the procedure that we would feed the whole message into.

>

monoalph := proc(letter, rule, key) #This procedure changes one letter with a monoalphabetic cipher named rule      local temp, temp2;      temp := letter:    if letter > 64 then       if letter < 91 then          temp := 65 + rule(temp - 65, key):      fi:fi:    if letter > 96 then       if letter < 123 then          temp := 97 + rule(temp - 97, key):      fi:fi:    temp:   end: encodemonoalph := proc(message, rule, key) #This procedure uses monoalph to uncode a string      local temp:       #first convert the message to numerical equivalents     temp[1] := convert(message, bytes):       #then uses monalph to scrable the letters     temp[2] := map(monoalph, temp[1], rule, key):       #then convert back to the ASCII code     convert(temp[2], bytes):   end:

Now we produce the rule for the Caesar cipher.

(In producing our coding rules we send a to 0, b to 1, and so on, up to z to 25.)

>	caesarrule := (letter, key) -> ((letter + key) mod 26): #This procedure is the rule used for the Caesar cipher.

The test of the code is obviously that it correctly encodes and decodes a message.

>	mess[1] := encodemonoalph(message1, caesarrule, 5); mess[2] := encodemonoalph(mess[1], caesarrule, -5);

Notice that if the encoding key is 5 we can use -5 as a decoding key.

General monoalphabetic ciphers

The advantage of the modified approach is that we can set a new cipher by defining a new coding rule.  One of the simplest rules is one that permutes the letters.  The key is then a vector of length 26 whose entries are the numbers from 0 through 25 in some order.  Rules of this sort permute the 26 letters

>	permutationRule := (letter, key) -> key[letter+1];

Consider the following key which causes the permutationRule to switch pairs of letters.  (A goes to B and B goes to A, C goes to D and D goes to C, etc.)

>	pairkey := [1,0,3,2,5,4,7,6,9,8,11,10,13,12,15,14,17,16,19,18,21,20,23,22,25,24]; code1 := encodemonoalph(message1,permutationRule,pairkey);

This key has the feature that the key to encode is the same as the key to decode.

>	code2 := encodemonoalph(code1, permutationRule, pairkey);