# Thinking About Encryption, Part 54

Ragbaby – Art of the crib

Building on what I wrote about earlier on how creating CONs (cipher constructions) can be an art, I have a case in point. The Ragbaby cipher E-18, in the Jan.-Feb. 2019 issue of the ACA Cm newsletter was designed with what initially looks like a really short crib, and gives us almost nothing to work with, solving-wise. But there is a massive, HUGE hint built into the crib that allows for cracking it within 2-3 minutes.

Remember that for Ragbaby, we count the words in the plaintext, and add that to the letter position within the word. This gives us an “offset” for use in finding the corresponding cipher letter from the 24-letter keyed alphabet (we drop “J” and “X”). Say the key is “teacher” again, so the alphabet is:
``` ..........11111111112222 012345678901234567890123 TEACHRBDFGIKLMNOPQSUVWYZ```

If the message is (keeping word spacings and punctuation):
``` .1234.23..34567.. "Help Me, mommy."```

“H” has an offset of 1, and the next letter after H in the keyed alphabet is “R”. Note that we wrap if we reach the right edge of the alphabet, and that a letter with an offset of 24 wraps to itself. This gives us a ciphertext of:
``` "RCOV OH, PUSUR."```

I’m not going to use the exact CON from the Cm, to avoid looking like I’m taking credit for other people’s work, but I am going to use a similar construction to illustrate exactly what the author did. My CON is:
``` .................................1...11..111.1111.1111.111.111 12345 234 3456 456789 56 6789 7890 8901 9012 0123 1234 234 345 YMAZI IWL PYVH DPFZSI DW DGRC HVGN GUAQ HMQG BEMR OQHV MBK IYV.```
``` 11.111112.11112.11.112222222222333..122.22.22222..22.2222.22.2222 45 567890 67890 78 890123456789012. 901 01 12345. 23 3456 45 5678 GM FIDSZT VRLYS QQ VLIKHOLTWNRIWHL, FHA LL QMNKV. MP AEVW WQ ZYYB```
``` 2222.2223.2233.23.3333.33.333333 6789 7890 8901 90 0123 12 234567 TSVR YCRT UPCH AT RDKC GE QMZFYC.```

The crib is “by looks”. To place the crib, we want to find text in the message of the same lengths. I specifically picked my crib so that I don’t have to waste time weeding out the other 5-letter words that we’d otherwise have to test and eliminate. The match is at:
``` 22 22222 01 12345 LL QMNKV by looks```

Incidentally, the “k” in “looks” has an offset of 24, so it maps to itself. In fact, this gives the impression that we have even fewer letters to use for rebuilding the alphabet, but that’s a red herring. To crack Ragbaby, we usually want to find a letter that occurs more than once, and use that as the relative “zero-point” of our new alphabet. “L” would normally be a great candidate. We would then put “l” at 0, “b” 20 characters to the left, “y” 21 characters to the left, and “q” 21 characters to the right. As such:
``` 012345678901234567890123 l..yb................q..```

This almost looks like garbage, and we may wonder if the crib was placed wrong. However, for the most part the letter numbering in the crib is smaller than that in the CON (“b” < “L”), meaning that the letters mainly look like they are ascending relative to each other, which is what we’d expect for anything outside of the key. The vital exception is for “l” and “Q”. The offset is 21, meaning that “l” is 3 places to the right of “q” . If we pick “q” as offset 0, we get:
``` 012345678901234567890123 q..l..yb................```

Normally, “l” would never follow “q” UNLESS they were part of the keyword. We can logically expect “u” to follow “q”, and even if we didn’t have the “y”, we’d really want to test if “qu.l…..” is “quality”.

Using the alphabet of “qualitybcdefghkmnoprsvwz”, we get the plaintext:
``` .................................1...11..111.1111.1111.111.111 12345 234 3456 456789 56 6789 7890 8901 9012 0123 1234 234 345 YMAZI IWL PYVH DPFZSI DW DGRC HVGN GUAQ HMQG BEMR OQHV MBK IYV. thzrz arz manb thtngr in ltfz yhly innh ithq vzly ygqb lpq mny```
``` 11.111112.11112.11.112222222222333..122.22.22222..22.2222.22.2222 45 567890 67890 78 890123456789012. 901 01 12345. 23 3456 45 5678 GM FIDSZT VRLYS QQ VLIKHOLTWNRIWHL, FHA LL QMNKV. MP AEVW WQ ZYYB wq sgnaid tadfq by lccomplishmznyr not by looks or less wz will```
``` 2222.2223.2233.23.3333.33.333333 6789 7890 8901 90 0123 12 234567 TSVR YCRT UPCH AT RDKC GE QMZFYC. look likz vhay vz hayz ta nyhqpr```
``` qualitybcdefghkmnoprsvwz 012345678901234567890123```

Ok, so this is not exactly the right key, but there’s so much readable plaintext that we’ve got to be on the right track. Taking a few guesses, we can clean up what we have into: “accomplishments, not by looks. Or less we will look like”. Filling in more of the alphabet, we will eventually get to where we can place “e”. One option for this is “e” is “t” with an offset of 30 (30 – 24 = 6) to the left.
``` 012345678901234567890123 qualityb...............e```

Changing “e” to be our base letter, we can just shift everything 1 position to the right:
``` 012345678901234567890123 equalityb...............```

Using “equality” for the key, we get:

“There are many things in life that look like what they are not.
We should iudge by accomplishments, not by looks. Or less we will
look like what we hate in others.”

CON solved. The original author used his knowledge of the Ragbaby algorithm to create a CON that initially looks very hard, but built in an exploit with the choice of keyword and crib that lets the CON collapse in just a couple minutes for anyone that is familiar with this type (it took me about 10 minutes, most of which was spent with me thinking that I was doing something wrong.”) I applaud his skill and ingenuity.

# Wiggles, part 50

Just a little ongoing story to give you something to play with until the next blog post.

“UWEO’Z OERJLX WJA? WY ZWCQPM WEKY XCOOYL WYHY IB LCU.”
“UWB UYHY BCQ JL OWYHY? BCQ RLCU AEAE’Z XCJLX OC RJPP BCQ JG ZWY TEOTWYZ BCQ ZLYERJLX CQO EXEJL!”
“ZWY UCL’O TEOTW AY. ZWY UCL’O YKYL RLCU J’KY IYYL WYHY, QLPYZZ BCQ OYPP WYH.”
“MCL’O OWJLR ZWY UCL’O, ZWY RLCUZ YKYHBOWJLX EICQO OWY AYJFQ.”
OWEO PEZO UCHM MJML’O AERY E PCO CG ZYLZY JL DEVELYZY. J EZZQAYM OWY XJHP AYELO “AEFY,” IQO J UEZ CLPB XQYZZJLX GHCA TCLOYNO. JO AJXWO WEKY IYYL EL YLXPJZW PCEL UCHM, AJZEVVPJYM OC OWY OQLLYP J UEZ JL. OWY ZWCVVJLX EHTEMY JOZYPG JZ OWY “JTWJIEL XEJ”, CH “OWY LQAIYH 1 ZWCVVJLX TCAVPYN.” J MJML’O RLCU CG ELBOWJLX YPZY WYHY UJOW OWEO LEAY, YNTYVO GCH E WEJH ZEPCL TEPPYM “EAYJFJLXQ” (EAEFJLX).

# Cm History, 1941-1950

1941

Dec.
– The SQUIRE introduces a Mixed Sequence Playfair, where the keyed alphabet is entered in the square using Route Transposition. Page 109 has a good example cipher to play with.
– Along with Piccola, one other very high-profile member of the ACA to pass away in the previous year was Damonomad. During 1941, there was a committee tasked with finding some way to memorialize both of them. The final decision, as reported in this issue, was to print “Dedicated to Damonomad” under the section heading for Aristocrats, for every issue from here on out, and “Dedicated to Piccola” under the section heading for Cipher Exchange.

1942

Apr.
– Article by The SQUIRE on recovering a Playfair keyword.

June
– A new approach is provided for solving Playfair ciphers, using a contact table. Pretty powerful from what I can see.

Oct.
– The editor announces a new section called The Expert’s Corner. This initially consists of 3 unknowns – An Aristo, a cipher and a Foreign language crypt.
– More examples for breaking Playfair ciphers.

Dec.-Jan.
– The editor announces larger sections for Cipher Exchange (20 CONs) and Pats (19). Up to this point, the full text of the solutions for every CON was being printed. With this issue, they will only print the first sentence each.
– The ACA buys its first \$500 U.S. War Bond.
– S-Tuck introduces a method for solving Grilles using a tableau (writing the cipher out as a table).

1943

Feb.-Mar.
– Introduction of a Sigma Test for Vigenere keyword letters, by Contractus.
– Up to this point, the editors of the Cm would list people by name and give the stats for which crypts they solved. With this issue, they started running the SOLs table format that is still in use today.

Apr.-May
– First article on how to solve Quagmire III.

Oct.-Nov.
– S-Tuck’s Introduction of the Key Phrase cipher.

Apr.-May
– The use of trial squares for solving Playfair.
– S-Tuck’s article on solving Porta Auto-Key.
– The Editor for the Cipher Exchange column complains that people are sending in too many transposition ciphers and asks for other types instead.

1944

Aug.-Sept.
– Mention of David Kahn’s “Codes and Condensers” books.
– S-Tuck’s discussion on the Gronsfeld cipher.
– S-Tuck: How to deal with 5×5 keysquares.

Oct.-Nov.
– Membership fees now at \$1.50 per year.
– Example given in the Foreign Crypt Department on how to solve a Spanish CON.
– How to find the period of a Bifid cipher.

Dec.-Jan.
– Example showing how to solve an Italian CON.

1945

Apr.-May
– S-Tuck: Discussion on the Tri-numeral cipher.
– Analysis of Slidefair, created by Piccola and described in Elcy (Piccola’s book, Elementary Cryptography).
– Tonto: Analysis of Bifid.

June-July
– Confirmation of the use of K1-K3 keywords for Aristocrats.
– X.Gotky: Analysis of the Delastelle Bifid.

Oct.-Nov.
Sherlac and S-Tuck: Triangular Grilles.
– An introduction to Stebbinsonian Formulas A & B. “A” is similar to Fractionated Morse, in that the alphabet is used to represent dots, dashes and spaces, and the plaintext is converted to Morse before being enciphered by letters. Formula B is also similar, but uses a longer key sentence. Written by Dwight Stebbins.
– Note that during the early years of the ACA, many people kept trying to come up with their own encryption systems, and trying to get them printed in the Cm, claiming them to be “unbreakable.” Every so often, the Cm editor would try to discourage this practice, and tell people to play with these systems independently of the magazine.
– S-Tuck: Article on solving Aristos based on word prefixes.

Dec.-Jan.
– The cover of the Christmas issue has a Walls of Troy motif. Even so, “ornamentals” (illustrated ciphers) remain unknown.
– A description is given of the “Multiple Substitution Number cipher,” which later is renamed to “Homophonic.”

1946

Jan.
– S-Tuck: Introduction of Auto Key, Interrupted Key, and the modern version of Running Key. These are billed as variations of Vigenere, which includes tables for Variant, Beaufort, Gronsfeld and Porta.

Feb.-Mar.
– S-Tuck: Methods for solving Interrupted Key ciphers.

Apr.-May
– S-Tuck: One approach for finding the period for Bifid.

Aug.-Sept.
– Delac: Introduction of the Myszkowsky Transposition cipher.
– X.Gotky : A shortcut for lining up Porta alphabets. It’s fine for pencil and paper analysis, but can be replaced by IC.

Oct.-Nov.
– S-Tuck: Recovering the 5×5 key square for Bifid.
– Discussions start for raising membership fees from \$1.50 to \$2 due to rising printing costs.
– Sky: A guide to solving Latin CONs.

Dec.-Jan.
– Cherry Blossom gives his account of the birth of the ACA.
– S-Tuck discusses key recovery for 5×5 mixed squares.

1947

Feb.-Mar.
– X.Gotky: Bifids with literal indices only (enciphering without resorting to using number placeholders mid-step), part 1.
– The Foreign Crypt Department officially becomes Xenocrypts.

Apr.-May
– X.Gotky: Part 2, plus an exercise on solving a Bifid.

June-July
– An official announcement is made that the “ACA and You” handbook has been printed, and sales have mostly recovered the printing costs.
– Doctor Cryptogram: How to recover numeric keys from transposition and Gronsfeld ciphers.
– Start of the Armchair Cryptanalyst department, which consists of mini-mystery stories involving ciphers.

Oct.-Nov.
– Red E. Raser: Impressions on Quagmire III.
– Glendale: How to attack the Phillips cipher.

1948

Feb.-Mar.
– Tonto: The Theory of Substitution as applied to Quagmire ciphers.
– Clear Skies: Use of a slide to solve Nihilist Number Substitution ciphers.

Apr.-May
– Phil: A method for differentiating between Vigenere, Beaufort and Variant ciphers.

June-July
– Ab Struse : One of the earliest articles on the solving of a Baconian cipher.

Aug.-Sept.
– Ishcabibel: Straddling Homophonic Bilinear substitution cipher, part 1.

Oct.-Nov.
– Ishcabibel: Part 2.
– Fiddle’s slide for Nihilist Number Substitution.
– Red E. Raser: Discussion of the Portax Cipher, part 1.

Dec.-Jan.
– Red E. Raser: Part 2.

1949

Feb.-Mar.
– Tonto: Applying the Theory of Substitutions to Quagmire IV.

Apr.-May
– Sai-Chess: Solving Foursquare, part 1.

June-July
– Sai-Chess: Part 1.
– S-Tuck: First principles of Playfair.

Aug.-Sept.
– Delac: The Nicodemus Cipher, which is Vigenere followed by Columnar Transposition.

Oct.-Nov.
– Ab Struse: Breaking the Porta Auto Key cipher.
– Helcrypt: Nullifying the Null Cipher, a discussion of methods for creating Null cipher CONs.
– Up until this point, cryptarithms have had multiple solutions. Pressure is now being applied by the department editor for people to make puzzles with one unique solution.
– Most of the more difficult crypts now have hints with Caesar-shifted cribs.
– There’s an editor request to determine the popularity of a Cryptocatechnics department in the Cm for various phases of cryptography.

Dec.-Jan.
– Fiddle: Solving Foursquare using the probable word method, part 1.

1950

Feb.-Mar.
– Fiddle: Part 2.
– Delac: Solving Slidefair.
– S-Tuck: Solving Porta.

Apr.-May
– Fiddle introduces his Fractionated Morse cipher. X.Gotky endorses it as a new type for use by the ACA.
– B.Natural: The Phillips Cipher with Mixed Square.
– Sourdough suggests a new method for devising Aristocrat key alphabets – write the keyword vertically, and follow each letter on the row with the consecutive letters up to the next one in the key. This approach is not in current use today. (A later issue of the Cm has a complaint letter from one member protesting the use of this kind of alphabet as being no different than no key at all.)

VWX
ABCD
RS
IJKLMNOPQ
EFGH
TU
YZ

ABCDEFGHIJKLMNOPQRSTUVWXYZ- plain
ZVWXABCDRSIJKLMNOPQEFGHTUY- cipher

June-July
– Delac suggests the use of a slide for the Delastelle Tableau.
– A major rewrite to the ACA Constitution is proposed (and later adopted).
– An announcement is made that many of the members, including the editor, are doing the Phillips cipher incorrectly.
– S-Tuck: Another article on finding the period of Bifids, for odd periods.

Aug.-Sept.
– B. Natural: A simplified version of X.Gotky’s method for solving Bifids.

Oct.-Nov.
– S-Tuck: Symmetry of letter positions in Quagmire frames.
– Every so often, the Cm would run short biographies or background summaries of the ACA’s more prolific, or visible members. In this issue, there was a write-up on Tonto (Spanish for “Stupid”). In it, the author mentions that Tonto had acted with Dorothy McGuire for the American troops in Europe during WW II, in the play “Dear Ruth.” It took a lot of digging, but I finally tracked down his real name as William A. Lee.
– Also in the write-up on Tonto was the mention that he had gotten interested in cryptography from a cryptogram from the New York World in 1928, in a column run by magician Harry Houdini.
– Tonto: Bifid Recoveries (the Candela Method).
– In a short piece called “Historical Oddities,” there’s a mention of a cipher written by Christopher Wren in 1714 that was to be used as proof to the Royal Society that he’d developed three instruments for measuring longitude at sea.

“Sir Christopher Wren’s Cypher, describing three instruments
proper for discovering the Longitude at Sea, delivered
to the Society November 30, 1714 – (7) by Mr. Wren:
Qzvcvayinixdncvocwedcnmalnabecirtewngramhhccaw.
Zeiyeinoiebivtxesciocpsdedmnanhsefprpiwhdraehhxcif.
Exzkavebimoxrfcslceedhwmgnniveomrewwerrcshepiip– Vera Copia”.
“Edm Halley”.

[I can’t find anything further on this cipher, but there is a follow-up in a later issue of the Cm giving an almost unreadable translation. I’ve written an email to the Royal Society asking about this, but I’m not expecting an answer back. Either way, I don’t know if this cipher was made up as a joke by one of the ACA members, or if it is indeed real.]

Dec.-Jan.
– Russian is added as one of the accepted languages in the Xenocrypts department. An article is run describing the language and providing letter frequencies.

# Thinking About Encryption, Part 53

Condi

I wanted to have something to work on during a break at work, so I went through the ACA’s list of approved ciphers for their Cm newsletter. I have a preference for transposition ciphers, but I was also kind of interested in a simple substitution type that wouldn’t take that much effort to learn. Condi looked promising, so that’s the one I picked next.

Condi (short for CONsecutive DIgraphs) is a very recent addition to the ACA list, having been first introduced in the Cm in the Sept.-Oct. 2011 issue by G4EGG. The Cm archives only go up to Nov.-Dec. 2015, and in that range, there are only 4-5 CONs total featuring the Condi type. And of those, all of them have been given in the Analyst’s Corner (reserved for non-standard ciphers, or those that break the guidelines somehow), rather than in the regular Cipher Exchange section. So, for that period, it’s not been that popular a cipher-type. I only have issues from July 2018 to Jan. 2019 on hand right now, and none of those include a Condi.

On first glance, it seems very straight-forward. You start by picking a keyword, and use that to create the regular key alphabet. Say, “CREAMCHEESE”:
``` .........11111111112222222 12345678901234567890123456 CREAMHSBDFGIJKLNOPQTUVWXYZ```

Next, you need a “starting number,” between 1 and 25. This number is used to create the first half of the first digraph (2-letter pair). Of course, it helps to have a plaintext message. Word breaks and punctuation can be retained.

This is a test message.

Now, take the first letter of the message, and locate it in the alphabet (T = position 20). Then, add the starting number to that position to get the associated cipher letter. If the starter is 5, then t = 20 + 5 = 25 = Y.

Replace the starter value with the position value for T (20), and repeat the process with the next plaintext letter, H . H = 6 + 20 = 26 = Z. Use the position value for H (6), and add that to the next letter (i = 12) to get 18 = P. And continue, each time using the position in the alphabet of the letter to the left to get the cipher value of the current letter.

YZPQ QQ G XWFC YBFKGLK.

Note that if the sum exceeds 26, you just wrap around to the left.

To decipher the message, start from the first letter of the sentence and just subtract the offset instead of adding it.

Solving a Condi CON can be either very difficult or very easy. The easy approach is to go through a dictionary, one word at a time, and use that to test for the key. This is fine for one-word keys that are in English, and are not proper names. I haven’t adapted my VBscript to include a permutating incrementer, but that’s only good for short keys (no more than 8 letters long, or so).

Now, if you use the dictionary approach, you still need to deal with that starter number between 1 and 25. This could imply having to test all 25 numbers for every single word in the dictionary, which would really slow things down. The way to get around this is to take the dictionary word, create the keyed alphabet for it, then encrypt the crib you have, if any, using that keyed alphabet, and finally search the message for the existence of the encrypted crib. So far, all the Condi CONs I’ve seen do include a crib.

The main weakness of the Condi type is that the starter only really affects the first letter of the message. After that, the cipher text is dependent only on the letters in the message themselves. Therefore, if you can place the crib, even if it’s only one letter, and you have the correct key alphabet, then you can print out the plaintext message. So, say we do have the correct keyword (running through the dictionary, we reached CREAMCHEESE), and we want to know if it is right. If the crib is “TEST”,

Drop the first letter of the word “TEST”, and encrypt the remaining 3 letters using the CREAMHSBDFGIJKLNOPQTUVWXYZ alphabet:

WFC

If you have the right keyword, then the encrypted crib (WFC) will exist in the CON. If it does, just use the keyed alphabet you’ve created to decipher the ciphermessage. You’ll still have to find the starter number to decipher the very first letter of the plaintext, but that’s a minor point at this stage. To recover the starter from ?his, we can assume that “?his” is “this” and just subtract T from W (25 – 20 = 5). Or, run the entire CON in a loop, with the starter from 1 to 25, and print out the one deciphered message that contains the plaintext crib (i.e. – “test”).

Ok, what if we use the dictionary approach and that fails? Of the 5 Condi CONs I’ve seen in the archives, including the examples used in articles on solving Condi, most have used keys made up of multiple words, and one key was 14 letters long, making a permutating incrementer useless. In this case, we have to resort to the “hard” approach, which is using the relative positions of the letters from the crib to reconstruct the keyed alphabet.

With the message:``` K NDYX QZGAP KZQOAG FP PCNM ARB DWSI VNVL UBFYXNENG, MEV J QYB'O PLK QQ GMO.```

And the crib: travelled

Placement of the crib is a combination of matching the word length, and looking for patterns. With Condi, adding two letters together gives the same total regardless of the order. That is, “e” + “l” = “l” + “e”. So, we want to find a ciphertext word that has the same letter at positions 6 and 8. “travelled” is 9 letters, and there is only one cipher word of that length. Plus, positions 6 and 8 are both “n”. We have our match.
``` UBFYXNENG travelled```

Now, we don’t know the value of L from the last letter of the previous word, so we can’t associate “t” with “U”. But, we are good for the rest of “ravelled”. Recall that to encipher the text, we add the alphabet position of the letter to the left in the plaintext to the alphabet position of the current letter. I.e. = t (20) + e (3) = W (23) in the above example.

Interestingly, the second word “NDYX” shares two of the letters (YX) with “UBFYXNENG”, meaning NDYX = “??VE”. And there is a one-letter word just before it. The sentence can start with “I ??VE” or “A ??VE”. The most common opening for this combination of letters should be “I HAVE”.

This means, in recreating our keyed alphabet, that:
``` n = i + h d = h + a y = a + v x = v + e b = t + r f = r + a n = e + l e = l + l n = l + e g = e + d```
``` e = 2 * l n = 3 * l```

There is a clue in the “e = 2 * l,” and “n = 3 * l” relationships. If we assume that “l” and “n” are not in the keyword, then they’re most likely in the upper half of the alphabet (and “e” should almost always be less than 13, unless it’s at the end of a massively long key). If so, then we’re looking at wrapping. That is, if we take “l” to be 20, then “e” = 20 * 2 = 40 = (40 – 26) = 14. n = 20 * 3 = 60 = (60 – 56) = 4. However, with simply adding two numbers between 1 and 26, we should never exceed 52. Therefore we’d expect “l” to be between 14 and 17. That would give us possible values of “e” as 2, 4, 6 and 8. And “n” of 16, 19, 22 and 25. Note, though, that normally in the string “lmno”, “l” and “n” can’t be separated by more than 1 or 2 positions (if they are not part of the key). This forces “e” to be in position 2 in the keyed alphabet, “l” to be 14, “n” to be 16, and “m” to most likely be in the middle at 15.

With “x = v + e”, if “vwxyz” are not in the key, then they’re at the end of the alphabet. Because “x = v + 2”, we can say that “w” is between “v” and “x” (vwx). Then, with “y = a + v”, we have 2 cases: “y is in the key, or it’s not.” If it’s not in the key, “y = v + 3″, and v + 3 = a + v,” or “a” = 3. If “y” is in the key, then “a” has to be less than “l”, and we’re going to get conflicts. Assume that “y” is not in the key.
``` -ea----------lmn-----vwxyz```

Looking at “d = h + a” and “g = e + d” gives us “g = h + 5” or “h = g – 5”. Obviously the two letters are not next to each other, and “h” actually appears before g, so it must be part of the key. Then, “h = d – 3” and “d = g – 2”. This implies something like “h–d-g”. We already know where “e” goes, so the gap between “d” and “g” probably contains “f.” “h–dfg.” Going to “f = r + a,” “r = f – 3,” and “hr-dfg.” Follow this with “n = i + h,” or “i = 16 – h.” “i” can’t equal 1, 2 or 3, and if it was 4, then “h” would be 12 and “f” would be 16 (we already know “n” is 16). The only real legal options are for “i” to between 9 and 12, but this just proves that “i” is not part of the key, and must follow “g” in our substring: “hr-dfgi”. If “i – h = 6,” and “n = i + h” with “n” = 16, we now know “16 = h + 6 + h,” or “h” = 5.
``` -ea-hr-dfgi--lmn-----vwxyz```

The gap between “i” and “l” can be filled with “j” and “k.” “-ea-hr-dfgijklmn.” Then use “b = t + r.” Notice now that “b” is either part of the key, and will therefore be in position 1 or 4, or not part of the key and be in position 7. BUT, “t” and “r” must both be smaller than “b,” and we know “r” = 6, and that “b” can’t be in the key and ergo = 7, and “t” = 1.
``` tea-hrbdfgijklmn-----vwxyz```

“c” is part of the key, and must be equal to 4. Finally, we have “teachrbdfgijklmn”, meaning that our key is “teacher,” and the full alphabet is:
``` teachrbdfgijklmnopqsuvwxyz```

All that’s left is to extract the starting number. # = k – i = 13 – 11 = 2. The full plaintext is:

“I have often wanted to take the road less travelled, but I don’t own an SUV.”

Ending note: Yes, I know “traveled” is only supposed to have one “l”. But, if this is how the word was spelled when the message was written, this is what we need to use to solve the message. Once you’re extracted the plaintext, you can always run spellcheck on it to clean it up if you want.

Summary:
1) Condi is a substitution cipher that uses a keyed alphabet, and a starting number.
2) Taking the first letter of the plaintext, find its position in the alphabet.
3) Add the starting number to this position to get the position of the matching cipher letter.
4) Next, use the position of the old plaintext letter as the offset for the next plaintext letter, and repeat the process.
5) Deciphering is the reverse process.
6) Solving Condi is easy if the key is a single English word that’s in your dictionary. If so, just run through the dictionary and try to solve the CON with the keyed alphabet you create each time.
7) Otherwise, you need to place the crib in the ciphertext, and then build a table of relative offsets for each letter.
This is the hard step.
8) Once enough of the key has been recovered, you can build the entire alphabet, which then gives you the plaintext and the starting number.
9) Condi is much harder than I ever would have expected, or liked, but if you have a crib, it should be breakable.

# Wiggles, part 49

Just a little ongoing story to give you something to play with until the next blog post.

D SRUFEV VKSH ICE BIRDNB, RHV LKUUKSEV ICE BINRDACI CRUUSRM IK R BEZKHV VKKN. ICDB KHE SRB ZUKBEV, XGI CRV R BDQDURN OGBC-OGBC UKZF QEZCRHDBQ RB ICE KHE RI ICE XRN. D IGNHEV KLL QM LURBCUDACI, RHV OGBCEV ICE VKKN AEHIUM. ICE QEZCRHDBQ ZUDZFEV, RHV D WGDEIUM KOEHEV ICE VKKN. NDACI DH LNKHI KL QE SRB R XDA NKKQ, RUQKBI R ZKOM KL ICE XRN XGI SDICKGI ICE BIRAE, ANEEH NKKQ SRUUB, KN IRXUEB RHV ZCRDNB. DI SRB XNDACIUM UDI, SDIC LUGKNEBZEHI UDACIDHA KH ICE ZEDUDHA, RHV XKTEB BIRZFEV RNKGHV ICE SRUUB RHV DH ICE QDVVUE KL ICE LUKKN. D ZKGUVH’I BEE RHMKHE, CKSEYEN R ORDN KL YKDZEB NERZCEV QE ONEIIM ZUERNUM. KHE SRB ICE XKM’B, RHV CE BIDUU BEEQEV IK XE URGACDHA KYEN BKQEICDHA. ICE KICEN BKGHVEV UDFE R MKGHA ADNU.

# Thinking About Encryption, Part 52

Two-Square
6×6 Two-Square

Hmm. #52 of this series looking at cipher types and how the ACA uses them. At one entry per week, that means I’ve been at this for something over 3 days, with no one ever leaving comments here. Maybe that means something.

I’ve written about Four-Square before, and I was really thinking that Two-Square would be a natural follow-up, in that it’s in the same family (along with Three-Square), and that the fewer number of squares would make it easier to crack.

In Four-Square, you have four 5×5 squares, labelled PT1, PT2, CT2 and CT2. PT1 and PT2 are both filled in with unkeyed alphabets (skipping “J”), and CT1 and CT2 both have keyed alphabets that can be written in rows or columns. You take the plaintext message in pairs of letters, and locate them in the PT1 and PT2 tables to form the opposite corners of a rectangle. The two ciphertext letters are taken from the other corners as CT1 then CT2. If the keys are “KEY” (CT1) and “WORD” (CT2), we get (top from left – PT1 and CT1; bottom from left – CT2 and PT1):
``` ABCDE | KEYAB FGHIK | CDFGH LMNOP | ILMNO QRSTU | PQRST VWXYZ | UVWXZ ------------- WBHNU | ABCDE OCIPV | FGHIK REKQX | LMNOP DFLSY | QRSTU AGMTZ | VWXYZ```

If the plaintext message starts with “THIS”, then “TH” becomes “RP” and “IS” becomes “FS” (taking CT1 then CT2).

Cracking Four-Square requires creating a filter based on the letter patterns of the crib, and matching the filter up with a section of the cipher message that has similar letter patterns. One thing that generally helps make this process a little easier is that the keyed alphabets are usually predictable in that the last 1-2 rows (or columns) of letters tend to come from the set “QRSTUVWXYZ”, assuming that “RST” are not in the keyword.

Ok, Two-Square is similar in that both squares use keyed 25-letter alphabets. Where it gets crazy-hard is that the alphabets can be entered into the squares in any order allowed by the Route Transposition Cipher. Recall that Route uses a rectangular box and the message can be written in rows, columns, alternating rows or columns, diagonals, alternating diagonals, or spirals, and that the rectangle can be horizontally and/or vertically flipped. The text is then pulled off in whatever way you want, but that last step is not important here for Two-Square. So, assuming that the keys are “KEY” and “WORD” again, but that we’ll fill in square 1 with alternating rows and square 2 in a spiral:
``` KEYAB | WORDA HGFDC | NPQSB ILMNO | MYZTC TSRQP | LXVUE UVWXZ | KIHGF```

Now, “TH” “IS” becomes “VU” and “TH”. The plaintext pairs are placed as square 1 then square 2, and taken off as square 2 then square 1. If they are on the same row, such as “IT”, then they are simply reversed (i.g. – “TI”).

This latter point, of the letters inverting if they’re on the same row is one of Two-Square’s biggest weaknesses, since it can be expected to occur perhaps 20% of the time (depending on the plaintext message).

Decrypting a message is just the reverse process. Take your key words, use them to build up the key alphabets. Write the alphabets into the two squares as required. Then take the message in two-letter pairs, placing them in square 2, square 1 order, and reading off the plaintext as square 1, square 2.

Solving Two-Square, if you have a crib, is a matter of writing the crib out as pairs (twice, once for each possible shift of the first letter), and looking for repeating letter pairs. If the crib is “THISCRIBISTHICK”:
``` "TH IS CR IB IS TH IC K?" "?T HI SC RI BI ST HI CK"```

In the first line, with 0 offset, “TH” appears at relative positions 0 and 10, and “IS” at 2 and 8. If the ciphertext has repetitions at similar spacings, that’s probably where the crib goes. Otherwise, look at the second line, with 1 offset, and “HI” appearing at relative positions 1 and 11.

As additional confirmation, or if the crib lacks this kind of pattern, look for places where the letters are flipped (i.e. – “CR” and “RC”, or “CI” and “IC”.
``` TS HY KW SS VW LM RC LU VL BA CI ML KA .. .. .. .. TH IS CR IB IS TH IC K```

Ok, this was the easy part. Next, we want to recreate the key alphabet squares. Say we have a cipher message that reads:
``` HI WY EK EE FW CD BQ FC OF PW TT BN EC HI WY FE UO EC GY IR EX DS CW OD SF BO OD XF TM SO FC YR```

And, we’re told that the crib is: “found a friend”. First, we want to place the crib.
``` FO UN DA FR IE ND or: ?F OU ND AF RI EN D?```

While there are no repeat patterns in either string, there are two reversed pairs that match up with the second string (“?F OU ND AF RI EN D?”):
``` HI WY EK EE FW CD BQ FC OF PW TT BN EC HI WY FE .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .F```
``` UO EC GY IR EX DS CW OD SF BO OD XF TM SO FC YR OU ND AF RI EN D. .. .. .. .. .. .. .. .. .. ..```

OU = UO and RI = IR. Promisingly, we also have FE = ?F, but we can leave that lead for later. Right now, we’re looking for pair combinations that have the most letters in common with the other pairs throughout the crib. The first really good candidate is EC = ND. We start by creating a little grid, with P1 (plaintext letter 1) on the left, P2 on the right one line down, C1 (ciphertext letter 1) on the right directly above P2, and C2 on the left, directly below P1, as follows:
``` N | E C | D```

If we follow the rules for encryption, ND creates a rectangle with EC at the opposing corners. The next pair should be EX = EN. Here, the letters EN don’t align with anything we have in the table, so we put them on a new row and a new column. But for EX, the “E” matches the “E” on the right side of the divider, so P1 will be on the same row as C1 E, C2 will be below P1, and P2 will be on the same line as C2, directly under C1. Like this:
``` EN | E .C | D X. | N```

If we look at DS = D?, and compare that with EX = EN, we don’t really know what the unknown character “?” could be. But for FE = ?F, it’s guaranteed that we have a mirror flip. In order for P1 to be F and C2 to be the same letter, P2 and C1 also have to be the same, meaning that FE = EF.
``` EN | EF .C | D X. | N```

This is as far as we can go with the table, so let’s see if we can add to the plaintext.
``` HI WY EK EE FW CD BQ FC OF PW TT BN EC HI WY FE .. .. .. EE .. .. .. .. .. .. .. .. ND .. .. EF```
``` UO EC GY IR EX DS CW OD SF BO OD XF TM SO FC YR OU ND AF RI EN D. .. .. .. .. .. .. .. .. .. ..```

Obviously, I wrote this message, so I can claim some kind of magic knowledge and wave my hands here. But, that “ND” does show up in “FOUND” as well as “FRIEND”, or it could be part of “AND”. However, if we look at “EC HI WY FE”, there’s a chance that “HI” is a mirror flip, which could give us “IH ?? EF”. “I HAVE FOUND A FRIEND” is not too outrageous a leap, so let’s try it.
``` HI WY EK EE FW CD BQ FC OF PW TT BN EC HI WY FE .. .. .. EE .. .. .. .. .. .. .. .. ND IH AV EF```
``` UO EC GY IR EX DS CW OD SF BO OD XF TM SO FC YR OU ND AF RI EN D. .. .. .. .. .. .. .. .. .. ..```

Unfortunately, it doesn’t give us anything to work with table-wise. “BN EC” = “?A ND” is a deadend, too. There’s nothing to lose by trying to plug in “FRIEND”.
``` HI WY EK EE FW CD BQ FC OF PW TT BN EC HI WY FE .. .. .. EE .. .. .. .. .. .. FR IE ND IH AV EF```
``` UO EC GY IR EX DS CW OD SF BO OD XF TM SO FC YR OU ND AF RI EN D. .. .. .. .. .. .. .. .. .. ..```

This at least gives us BN = IE, and that fits in with what we already have in the table.
``` .EN | EF ..C | D .X. | N ..I | BH```
``` HI WY EK EE FW CD BQ FC OF PW TT BN EC HI WY FE IH AV E. EE .. .. .. .. .. .. FR IE ND IH AV EF```
``` UO EC GY IR EX DS CW OD SF BO OD XF TM SO FC YR OU ND AF RI EN D. .. .. .. .. .. .. .. .. .. ..```

And, we just repeat the process. Since my goal is to recreate the table, I’ll just fill in the rest of the plaintext.
``` HI WY EK EE FW CD BQ FC OF PW TT BN EC HI WY FE IH AV EB EE NL OO KI NG FO RA FR IE ND IH AV EF```
``` UO EC GY IR EX DS CW OD SF BO OD XF TM SO FC YR OU ND AF RI EN DI NA DO GT HE DO GW AS HU NG RY```
``` YEN | EF A.C | DG .X. | N .KI | BH ..W | .LA .Q. | I ..R | ..P```

Running from IH = HI to AF = GY, I get the above table. Note that are 7 rows, but there are a couple gaps in two of the rows that could be merged down. Specifically, rows 5 and 7 could merge into either rows 3 or 6. However, the next solved letter pair, RI = IR, is going to force the merger of row 7 into 6.
``` YEN | EF A.C | DG .X. | N .KI | BH ..W | .LA .QR | I.P```

And that means row 5 merges into 3.
``` YEN | EF A.C | DG .XW | NLA .KI | BH .QR | I.P```

Going through the entire CON, I get the below assignments.
``` .OYEN | EFC.U.V FDA.C | DGO.T.W ...XW | NLA GHMKI | BH..S.X .S.QR | I.P..Y T.... | ....R```

It looks like, based on the right-hand column of the right-hand side that Square 2 is in columns. However, the left-hand column of Square 2 is running the opposite direction. So, maybe Square 2 was filled in alternating columns. It’s too early to say anything much about Square 1. But, Square 2 columns 6 and 7 can be merged, and the rows reordered.
``` .OYEN | EFCUV FDA.C | DGOTW GHMKI | BH.SX T.... | ...R .S.QR | I.P.Y ...XW | NLA```

Rows 4 and 5 can be merged. We can guess that “QZ” can go at the right end of the last row.
``` .OYEN | EFCUV FDA.C | DGOTW GHMKI | BH.SX TS.QR | I.PRY ...XW | NLAQZ```

Square 2 columns 4 and 5 are in the correct locations, and it looks like columns 1 and 2 are also matched (B, D, E, F, G, H). Column 3 seems to be out of place, so let’s move that to column 1 and see what happens.
``` .OYEN | CEFUV FDA.C | ODGTW GHMKI | .BHSX TS.QR | PI.RY ...XW | ANLQZ```

The letters missing from Square 2 are J, K and M. Two-Square doesn’t use J, and anagraming the letters COPANIMK might give COMPANI-something (actually, COMPANION). Fill those in. Then, looking at rows 2 and 3 of Square 1 shows that that’s been filled in alternating rows.
``` LONEY | CEFUV FDCBA | ODGTW GHIKM | MBHSX TSRQP | PIKRY UVWXZ | ANLQZ```

The keys are “LONELY” and “COMPANION.”

===============

Closely related to the above cipher-type is 6×6 Two-Square. The unkeyed alphabet for 6×6 is “a1b2c3d4e5f6g7h8i9j0klmnopqrstuvwxyz”.

This took me a while to figure out, but when you write in the keyword, you do so in letter+digit pairs. That is, if you want a keyed alphabet using the word “Derby,” in rows, you get:
``` D4E5RB 2YA1C3 F6G7H8 I9J0KL MNOPQS TUVWXZ```

The larger table does make it a little harder to recover the plaintext from the cipher, but the letter+digit pairs are an almost immediate giveaway for how the keyed alphabets were entered in the squares.

I went through 15 year’s worth of Cm newsletter archives (2001-2015), with about 30 Two-Square, and five 6×6 Two Square, ciphers. The regular CONs showed a fairly even mix of routes (rows, columns, diagonals, spirals, alternations and mirror flips). The 6×6’s were largely on-by-rows and on-by-columns. But, out of 90 total issues, Two-Square isn’t one of the more popular, or consistent cipher types. I’ve written an encipher script, and a print-out script when given the solution keys. But, I haven’t bothered tackling a full solver yet. I’ve tried using Bion’s Two-Square gadget, but that’s clunky when I need to have several extra scratchpad rows and columns to work with. Instead, I’m still at the pencil and paper point. We’ll see if I ever get to writing up something a little more useful.

Summary:
1) Two-Square is a two-alphabet substitution cipher-type, in the same family as Three- and Four-Square.
2) Both squares use 25-letter keyed alphabets (minus the J), filled in any way legal within the Route Transposition cipher.
3) The plaintext is taken in pairs. The first letter goes into square 1, and the second into square 2, to form the opposite corners of a rectangle. The cipher pair is read off as square 2/square 1 from the other two corners.
4) If the plaintext pair is on the same row, just flip the order for the cipher pair (i.e. – “RI” = “IR”).
5) Decrypt the cipher by reversing the process.
6) Solving Two-Square involves placing a crib, if any, by looking for pair repetitions in the plaintext crib, and the shifted plaintext crib, then aligning those repetitions with repetitions of the same spacing in the ciphertext. If there are no repetitions in the crib, then look for letter pair inversions (i.e. – “RI”/”IR”).
7) Use the crib-to-ciphertext match-ups to reconstruct the squares.
8) When adding new letters to the squares, put them on new rows or columns. When you have enough information to confirm that two rows or columns are actually the same, merge the entire row or column.
9) Use alphabet ordering to identify the route used to fill the table. If enough information exists, you can use the reconstructed table to further solve the plaintext.
10) 6×6 Two-Square uses the alphabet: “a1b2c3d4e5f6g7h8i9j0klmnopqrstuvwxyz”.
11) The letter+digit pairs (a-1, b-2…) can be used to fill in the keyed squares, which is a useful clue for reconstructing the squares later.
12) For me, Two-Square is actually harder to solve than Four-Square. And, I think Four-Square is difficult.

# Wiggles, part 48

Just a little ongoing story to give you something to play with until the next blog post.

DUT FTETMD KRE KSWFDM ETST ZTDDWFZ URSCTS DY XRNT YAD WF DUT MRFC, LAD W ERM ZATMMWFZ DUTO MDWPP UTRCTC MYADU. W ZYD WFDY R VSYAVU, ZWFZTSPO MDAVN XO SWZUD URFC WFDY XO MUWSD GYS R MPWFZ, RFC NTKD ZYWFZ. EWDUWF R XWFADT YS DEY, W VYAPC MTT DUT TFC YG DUT DAFFTP. WD DTSXWFRDTC WF R VRJT-WF, EWDU YFT KRDU SAFFWFZ DY XO PTGD, WF DUT MRXT CWSTVDWYF RM DUT SYADT GSYX DUT LRS. YCCPO, WFMDTRC YG R CSYK GSYX DUT DYK YG DUT KWKT DY R PYETS GPYYS, DUWM KRDU URC EYYCTF MDRWSM PTRCWFZ CYEF DY R GWFWMUTC LSWVN-PWFTC URPPERO. GASDUTS, DUTST ERM R CYYS DURD YKTFTC RERO GSYX DUT DAFFTP, RFC XO MWCT YG DUT CYYS URC LTTF GWFWMUTC DY STMTXLPT DUT MASSYAFCWFZ MRFC ERPPM. FY CYALD RLYAD WD, DUWM KRSD ERM CTMWZFTC WFDTFDWYFRPPO, RFC KSYLRLPO CWC FYD XTTD QRKRFTMT LAWPCWFZ VYCTM.

# Thinking About Encryption, Part 51

Approaching St. Cyr

The Jan.- Feb. 2019 issue of the ACA Cm newsletter had a CON using the St. Cyr cipher-type. St. Cyr isn’t one of the standard ACA types, so the CON was listed in the Analyst’s Corner (which features ciphers that either don’t follow the guidelines, or aren’t one of the approved types). Fortunately, there was a note to refer to the Oct.-Nov. 1953 Cm from the archives. There, one of the earlier ACA members had written up a good article introducing the St. Cyr type.

What’s important to note up front is that if you do a net search on “St. Cyr cipher,” you’re going to find a few articles on how to make a St. Cyr slide. In effect, the slides are a simple strip of paper within a guide frame. The slide will have the letters A-Z repeated on them to create a short cycle. The guide will also have A-Z printed at the bottom. Together they form a Caesar shift encrypter. If you were instead to put the two alphabets on a pair of rotating disks, you’d have a Caesar shift encoder wheel, or ring. Which means that the St. Cyr slide and the secret encoder rings you used to get in boxes of sugar cereals and Cracker Jacks are fundamentally the same.

However, that’s not really what the St. Cyr cipher is about. Instead, we’re really talking about the Vigenere cipher again. As a refresher, the Vigenere cipher uses a table of Caesar-shifted rows in combination with a keyword. The keyword is written over the plaintext message, repeating as necessary, and each key letter acts as an index to one of the rows of the table. The cipher text letter is taken where the column indicated by the plaintext letter intersects with the cipher letter row. The main weakness to Vigenere is that the use of a keyword makes the ciphertext periodic, and if you can determine the period, you can crack the cipher as just groups of Caesar shifts.

St. Cyr is the French military academy established in 1802 by order of Napoleon Bonaparte. The St. Cyr cipher was taught at this academy, which is where it got its name. The St. Cyr slide can be used to encipher and decipher messages, but at St. Cyr’s heart is the Vigenere table (which can also include the Beaufort and Variant tables). The difference from Vigenere is the practice of using the keyletters on whole plaintext words. This breaks up the periodicity of the Vigenere cipher, but renders it vulnerable to a much simpler attack.

For example, say we use the keyword “HUMAN”, and the plaintext “to err is inevitable, to get caught at it is not.”

With Vigenere, we’d use:
``` HUMANHUMANHUMANHUMANHUMANHUMANHUMANHU toerrisinevitabletogetcaughtatitisnot```

ciphertext:``` AIQREPMUNRCCFAOSYFOTLNOAHNBFAGPNUSAVN```

But, with St. Cyr, it’s
``` HH UUU MM AAAAAAAAAA NN HHH UUUUUU MM AA NN HHH to err is inevitable to get caught at it is not```

ciphertext:``` AVYLLUEINEVITABLEGBNLAWUOABNMFITVFUVA```

Encryption and decryption would follow the same steps as with Vigenere, but using the “stutter key” as shown above.

Breaking St. Cyr is insanely easy with software. Just print out the text 26 times, once each with the incremented Caesar-shifted row.
``` A = AVYLLUEINEVITABLEGBNLAWUOABNMFITVFUVA B = ZUXKKTDHMDUHSZAKDFAMKZVTNZAMLEHSUETUZ C = YTWJJSCGLCTGRYZJCEZLJYUSMYZLKDGRTDSTY D = XSVIIRBFKBSFQXYIBDYKIXTRLXYKJCFQSCRSX E = WRUHHQAEJAREPWXHACXJHWSQKWXJIBEPRBQRW F = VQTGGPZDIZQDOVWGZBWIGVRPJVWIHADOQAPQV G = UPSFFOYCHYPCNUVFYAVHFUQOIUVHGZCNPZOPU H = TOREENXBGXOBMTUEXZUGETPNHTUGFYBMOYNOT I = SNQDDMWAFWNALSTDWYTFDSOMGSTFEXALNXMNS J = RMPCCLVZEVMZKRSCVXSECRNLFRSEDWZKMWLMR K = QLOBBKUYDULYJQRBUWRDBQMKEQRDCVYJLVKLQ L = PKNAAJTXCTKXIPQATVQCAPLJDPQCBUXIKUJKP M = OJMZZISWBSJWHOPZSUPBZOKICOPBATWHJTIJO N = NILYYHRVARIVGNOYRTOAYNJHBNOAZSVGISHIN O = MHKXXGQUZQHUFMNXQSNZXMIGAMNZYRUFHRGHM P = LGJWWFPTYPGTELMWPRMYWLHFZLMYXQTEGQFGL Q = KFIVVEOSXOFSDKLVOQLXVKGEYKLXWPSDFPEFK R = JEHUUDNRWNERCJKUNPKWUJFDXJKWVORCEODEJ S = IDGTTCMQVMDQBIJTMOJVTIECWIJVUNQBDNCDI T = HCFSSBLPULCPAHISLNIUSHDBVHIUTMPACMBCH U = GBERRAKOTKBOZGHRKMHTRGCAUGHTSLOZBLABG V = FADQQZJNSJANYFGQJLGSQFBZTFGSRKNYAKZAF W = EZCPPYIMRIZMXEFPIKFRPEAYSEFRQJMXZJYZE X = DYBOOXHLQHYLWDEOHJEQODZXRDEQPILWYIXYD Y = CXANNWGKPGXKVCDNGIDPNCYWQCDPOHKVXHWXC Z = BWZMMVFJOFWJUBCMFHCOMBXVPBCONGJUWGVWB```

Look for the rows with readable plaintext, and switch from row to row at the end of each plaintext word. Because the keyword is still going to be short compared to the plaintext message, it will cycle, so we just cycle on the output lines as well.
``` A = AV YLL UE INEVITABLE GB NLA WUOABN MF IT VF UVA H = TO REE NX BGXOBMTUEX ZU GET PNHTUG FY BM OY NOT M = OJ MZZ IS WBSJWHOPZS UP BZO KICOPB AT WH JT IJO N = NI LYY HR VARIVGNOYR TO AYN JHBNOA ZS VG IS HIN U = GB ERR AK OTKBOZGHRK MH TRG CAUGHT SL OZ BL ABG```

Rearranging the lines to put the words in order will then expose the key.
``` H = TO --- -- ---------- -- GET ------ -- -- -- NOT U = -- ERR -- ---------- -- --- CAUGHT -- -- -- --- M = -- --- IS ---------- -- --- ------ AT -- -- --- A = -- --- -- INEVITABLE -- --- ------ -- IT -- --- N = -- --- -- ---------- TO --- ------ -- -- IS ---```

Summary:
1) St. Cyr is a polyalphabetic substitution cipher that uses the Vigenere tables, but one keyword letter enciphers one full plaintext word.
2) It is not secure, and is actually easier to break in software than Vigenere or any of its variants.
3) You REALLY want to avoid keywords that include the letter “A”, which translates to a Caesar-shift of 0.
4) St. Cyr can be hardened by using the Variant or Beauford tables, and by mixing things up with any of the regular transposition types.

# Wiggles, part 47

Just a little ongoing story to give you something to play with until the next blog post.

JEFXXB KAGMCVB, G YGY PFX XZ R CGIY ZQ X-GIXFETFMXGZI, OGXU R JRGE ZQ TGYF JRXUT HERIMUGIP ZQQ VGCF XUF ZIF QZE XUF HRE. HAX, XUF JRO JEGIXT G QZVVZOFY TFFWFY XZ HF MZIXGIAGIP TXERGPUX RUFRY. RIZXUFE 5-6 WFXFET, G EFRMUFY RI REFR OGXU R VGXXVF WZEF UFRY EZZW, OUFEF G MZAVY TGX AJEGPUX RIY MERYVF WB REW OUGVF G MRAPUX WB HEFRXU. G AIHAXXZIFY XUF QEZIX ZQ WB TUGEX XZ PFX FIZAPU WRXFEGRV VZZTF XZ OGJF TZWF ZQ XUF TRIY ZQQ WB QRMF RIY ZAX ZQ WB URGE. G TOAIP XUF QVRTUVGPUX REZAIY RPRGI, TUZOGIP XURX G ORT TXGVV GI R XAIIFV RHZSF XUF YERGIRPF JGJF, TAEEZAIYFY HB TRIY ORVVT RIY MFGVGIP. G ORTI’X TAEF, HAX GX QFVX VGCF G MZAVY TFITF TXEFFX XERQQGM. GX ORT PFXXGIP MVZTF XZ 10:30, TZ WZTX ZQ XUF SFUGMVFT OZAVY HF HATFT, XRLGT RIY YFVGSFEB XEAMCT IZO. IZX MZITXRIX IZGTF, HAX TZWF VZO EAWHVGIP XURX PZX VZAYFE XUFI KAGFXFE. G WATX HF IFREGIP XUF FYPF ZQ XUF REMRYF.

• ## Follow TSOJ in email

Enter your email address to follow this blog and receive notifications of new posts by email.

Join 37 other followers

• ## Blog Stats

• 70,675 hits