Tom Gauld science-like strips


Cartoonist Tom Gauld also likes science, and beats it over the head with a club to show his affections. You can find more by him at You’re All Just Jealous of My Jetpack.

Turing Test

Time Travel Experiment

Satellite

Moon and Comet

Graphene

Dark Energy

Adventures of Schrodie the Cat

Advertisements

Thinking About Encryption, Part 5


I’ve mentioned that there are various ways to harden the random substitution cipher. One specific method is known as the Vigenere Cipher. It is named after Blaise de Vigenere (1523 – 1596), although it was originally described by Giovan Battista Bellaso (1505-?). The basic idea is to create a table of Caesar ciphers, each shifted one more place than the line above.


(Choosing to use the Vigenere cipher in En/De.)

ABCDEFGHIJKLMNOPQRSTUVWXYZ
BCDEFGHIJKLMNOPQRSTUVWXYZA
CDEFGHIJKLMNOPQRSTUVWXYZAB
DEFGHIJKLMNOPQRSTUVWXYZABC
EFGHIJKLMNOPQRSTUVWXYZABCD
FGHIJKLMNOPQRSTUVWXYZABCDE
GHIJKLMNOPQRSTUVWXYZABCDEF
HIJKLMNOPQRSTUVWXYZABCDEFG
IJKLMNOPQRSTUVWXYZABCDEFGH
JKLMNOPQRSTUVWXYZABCDEFGHI
KLMNOPQRSTUVWXYZABCDEFGHIJ
LMNOPQRSTUVWXYZABCDEFGHIJK
MNOPQRSTUVWXYZABCDEFGHIJKL
NOPQRSTUVWXYZABCDEFGHIJKLM
OPQRSTUVWXYZABCDEFGHIJKLMN
PQRSTUVWXYZABCDEFGHIJKLMNO
QRSTUVWXYZABCDEFGHIJKLMNOP
RSTUVWXYZABCDEFGHIJKLMNOPQ
STUVWXYZABCDEFGHIJKLMNOPQR
TUVWXYZABCDEFGHIJKLMNOPQRS
UVWXYZABCDEFGHIJKLMNOPQRST
VWXYZABCDEFGHIJKLMNOPQRSTU
WXYZABCDEFGHIJKLMNOPQRSTUV
XYZABCDEFGHIJKLMNOPQRSTUVW
YZABCDEFGHIJKLMNOPQRSTUVWX
ZABCDEFGHIJKLMNOPQRSTUVWXY

Actually, Simon Singh’s The Code Book starts the table one line down, with “ABCDEFGHIJKLMNOPQRSTUVWXYZ” on the bottom row of the table, but it really doesn’t matter, because row positions aren’t important. You pick the row such that the first letter of the row matches a given letter of your keyword.

So, ok, keywords. You give the recipient of your encrypted message the key that you use to encipher it. This keyword will contain only upper case letters, with no spaces, punctuation, digits or duplicated letters.


(Using “JULY AUGUST” as the Vigenere key phrase.)

As an example, let’s pick “JULY AUGUST”, and then remove the space, and extra “U”s. That gives us “JULYAGST”. We will cycle through this key as we go through our plain text.

Let’s use “THIS IS A VIGENERE CIPHER”.

The first letter of our JULYAGST key is “J”, and the first letter we want to encrypt is “T”. So, go along the top of the above table to “T”, and then down the column to the line that starts with “J”, where we find that our cipher text letter is “C”.

The next plain text character is “H”, and the keyword letter is “U”. Going down the “H” column to the “U” line, we get “B”. We continue in this way until we reach the ninth plain text character, “I”. We’ve gotten to the end of the keyword, so we just start over again with the “J” line.

Our final encrypted message is: CBTQIYSORAPLEXWVRJSCR.


(Encrypted text.)

To decipher the message, use the selected keyword again. Pick the row that starts with the given key letter (i.e. – “J”), go along that row until you get to the desired cipher message letter (“C”), and then follow the column up to the “ABCDE” line to obtain the plain text letter (“T”).

The real strength of this cipher is that it flattens out the frequency distribution of the plain text message, making frequency analysis a lot harder. “R” appears three times in the cipher text, twice for “I” and once for “R”. “E” shows up 4 times in the plain text, but in the cipher text it’s treated as separate instances of “P”, “E”, “W” and “C”.

The Vigenere cipher isn’t perfect. For a long time, it was considered too difficult to use by hand, and its main weakness is in the cyclical nature of the key used. Breaking Vigenere depends first on establishing the key length. The so-called Kasiski examination works assuming that by chance, certain words will be repeated in cycles that are a factor of the keyword apart. That is, if “the” appears twice in the plaintext 25 letters apart, and the keyword is 5 letters long, then “the” will be enciphered the same way both times. Taking the factors of 25 only gives us “5”, which makes the guess easier to make. Once we have the key length, we can apply frequency analysis to groups of letters (1, 6, 11, 16, etc. in group 1; 2, 7, 12, 17, etc. in group 2, and so on). Vigenere is harder to break than a simpler Caesar cipher, but it’s not that bad with a PC.

Say the plain text is: “One of the cars in the store is a red car in the store”, and the keyword is “tank.”
The cipher text would be (spaces added for readability):
HNRYY TUOVA ECBNG RXSGY KEVCT RRNVA ESGTU OLTBB X

“TUO” appears twice (which is what I wanted), 28 letters apart. The factors of 28 are 2, 4 and 7. 2 is too short to make a good key, but 4 and 7 are reasonable possibilities. With a longer plaintext message, we might get more repetitions, making it easier to narrow the keyword length further.

The thing is, though, Vigenere is absolutely painless to use on a PC. And, if you pick a longer key, with shorter plain text messages, it is much harder to crack.

Summary:
The Vigenere is a polyalphabetic substitution cipher.
It consists of a table made of Caesar shifted ciphers.
It uses a keyword to select which row (alphabet) of the (poly) table to use for each character of the plain text.
It’s very hard to break, but it’s not invulnerable.
It’s easy to use as a software app.

Wiggles, part 2


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

FNE WCFIQFCVS OQW AQXE OVUWE XIUCSH FNE EQULB 90’W, CS FNE BEQUW LEQXCSH IM FV ONQF’W SVO GQLLEX “FNE EGVSVACG KIKKLE,” ONES EDEUB GCFB PVISX CFWELP QPLVVX OCFN ISKIUSEX KQSZ GUEXCF, QSX OEUE LVVZCSH PVU OQBW FV WMESX CF. FNCW UEWILFEX CS NISXUEXW VP XVVAEX GVSWFUIGFCVS MUVYEGFW – WNVMMCSH AQLLW, QAIWEAESF MQUZW, QSX QUESQW – FNQF AQB VU AQB SVF NQDE KEES PCSCWNEX, KIF NQDE WCSGE KEES QKQSXVSEX KEGQIWE FNE XEAQSX PVU FNEA NQX SEDEU EJCWFEX. AVWF VP FNE MUVYEGF OEUE WIMMVWEX FV KE PLQHWNCMW FV WNVOGQWE FNE QUEQ’W OEQLFN QSX/VU QFFUQGFCVSW. SVO, FNEB’UE UIWFCSH, UVFFCSH NILZW FNQF QUE FVV EJMESWCDE FV EDES FEQU XVOS FV AQZE OQB PVU MQUZCSH LVFW CS FNCW SEO OQDE VP GVSWFUIGFCVS.

Hatayama Cast Marble Puzzle


Because I keep taking my puzzles to my English classes to show the students, I have gotten kind of (an undeserved) reputation for being able to solve 3D metal puzzles. A couple weeks ago, one woman brought in the Hatayama Cast Marble puzzle and said that one of her sons had bought it and taken it apart. No one in the family could put it back together again, so she’d wanted to challenge me to reverse solve it. It’s a bit small, but very heavy and well-built, about 2″ square and maybe 1″ deep.

I figured it out after about an hour, but I did have to cheat. The solution, as with most of the 5 star level puzzles from Hatayama, is very elegant. I can now take it apart and reassemble it in under a minute. As with the other puzzles, too, there’s a right way, and a whole bunch of less right ways, to put it together. That part has taken me whole days to figure out. I can’t wait to return it to the student and see what happens.

Thinking About Encryption, Part 4


I’m going to talk about the references I’m using for En/De, and for these blog entries, and I’ll add an elaboration to the random substitution cipher algorithm at the end.

One year ago, I received Simon Singh’s The Code Book for Christmas, and it’s been a major incentive for my learning Free Pascal and wanting to write my own encryption program. The Code Book came out in 1999, so it is a bit dated, but it does have a lot of historical background behind a number of the ciphers he discusses, and he does cover most of the biggies (Caesar, Vigenere, Beale, ADFGVX, Enigma and RSA). He also goes into great detail on how to break Caesar, Vigenere and Enigma. Simon includes enough examples for how to use the algorithms as to help me get over the more confusing parts of the descriptions. So, this book is near the top of my list, and I am rereading it now to figure out what I’d forgotten.

Next, as may be guessed from my last few blog entries, wikipedia is very useful, both in terms of identifying ciphers I want to include in En/De, as well as for describing approaches to cracking them.
Ciphers
Bigram
Letter frequency
Frequency analysis
Index of coincidence
Topics of Cryptography
Vigenere cipher
Kasiski examination
Most common words in English

The above list is good enough for the moment, and I’ll add to it as I feel like.

As for other websites… well, I admit to a certain hesitation to check out most of the sites that come up on a yahoo search simply because they may intimidate me into giving up on En/De before I even start. But, I will include Practical Cryptography here, because they have a good list of ciphers, and I’ll probably use it in deciding which ciphers to tackle next in my program.

As for the elaboration mentioned at the top of this blog entry – I was going through the Singh book, and Simon talks about an inconvenience involving the random substitution cipher.

In essence, random cipher keys need to be written down. Especially when you’re working with something like a one-time pad. This means you have to get the key to your recipient, and they can either lose it, or it can be intercepted by a third party. For a random substitution cipher, the key is a random arrangement of the upper case letters A-Z, and few people can simply commit that to memory to avoid having to write it down.

The work-around is to use a simple key word or phrase, which can in turn be used to generate the full table.


(Generating a pseudo-random substitution table.)

For example, say we choose “july august”. First, we convert the letters to upper case, and then strip out the spaces, any punctuation, and all subsequent duplicated letters. That gives us:

JULYAGST

We then continue with the rest of the letters, starting with the next letter after the key, and again dropping duplicate letters already in the key.

JULYAGSTVWXZBCDEFHIKMNOPQR


(Our new key table.)

This gives us a substitution pattern of A=J, B=U, C=L, D=Y, etc. If we want a new table, just pick a new key phrase. Simple suggestions could be movie, song, TV show or book titles.

Keep in mind, though, that you’re still dealing with a simple substitution cipher, and these can easily be broken through frequency analysis, as described in the last entry.

Wiggles, part 1


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

SWBWQ UL W NGUYA BTWJG. TUVVTG QIIKL WQA JYWQQUGL TUVVGY VHG JUVUGL, WQA WTTGML WQA VDQQGTL YDQ AGGB UQVI VHG LHWAINL. ZWJK ADYUQE VHG VIKDEWNW LHIEWQWVG (1600’L VI WZIDV 1850), YIWAL NGYG LBGJUFUJWTTM AGLUEQGA VI JDYXG ZWJK IDV IF VHG VINQL LI VHWV UQXWAUQE WYCUGL NIDTA ZG DQWZTG VI LUCBTM CWYJH LVYWUEHV UQVI VHG JWLVTG WV VHG JUVM’L JGQVGY. VHUL CWKGL QWXUEWVUIQ HWYA FIY CIAGYQ VIDYULVL, ZGJWDLG, NHGQ MID’YG NWTKUQE WTIQE W LVYGGV FIY W JIDBTG HIDYL, MID FUQA MIDYLGTF EIUQE VHG IBBILUVG AUYGJVUIQ FYIC NHGQ MID LVWYVGA. VHUQEL WYG W ZUV ZGVVGY QIN, UQ VHWV VHG JUVM BTWQQGYL BTINGA VHYIDEH W TIV IF VHG QGUEHZIYHIIAL VI CWKG YIIC FIY CWSIY VHIYIDEHFWYGL, LI VHGYG WYG LICG LVYGGVL VHWV EI LVYWUEHV VHYIDEH. ZDV, VHWV SDLV JYGWVGA W NHITG ZDQJH CIYG JYWPM AGWA GQAL, WQA HIDLGL ZDUTV UQ LVYWQEG LHWBGL VI FUV UQVI VUQM NGAEGL IF YGWT GLVWVG.

Thinking About Encryption, Part 3


When we change one letter for another, we “substitute” it. As such, the word “substitution” refers to an entire class of ciphers. Within this class, we can either change one letter at a time (A=C, B=J, C=F…), known as a simple substitution cipher, or larger groups of letters together, referred to as a polygraphic cipher. Then, if the substitution remains constant for the entire plain text message, it’s called monoalphabetic. Conversely, if the substitution changes (A=C, D or K at different locations of the message), it’s a polyalphabetic cipher, roughly speaking.


(Selecting the Quip-type cipher.)

Building on the Caesar cipher, the next step up is the “random substitution cipher.” In its simplest English form, we only deal with the upper case letters (A-Z), with no spaces or punctuation. This actually brings us to two different cases. In the first, we just get an unbroken block of random-looking upper case letters (LEPVPVOVPAHDXVJRVLPLJLPZIBPHEXTQPLEIZVHOBXV = THISISASIMPLESUBSTITUTIONCIPHERWITHNOSPACES). In the second, we get the CryptoQuip and Crypto Quote-type puzzles often found in the comics pages of newspapers (SBMF MF Y FMQPAU FILFSMSISMDN WMPBUR, EMSB FPYWUF YNT PINWSIYSMDN. = THIS IS A SIMPLE SUBSTITUTION CIPHER, WITH SPACES AND PUNCTUATION.)

In general, the longer the plain text message is, or the more often a particular key is used, the easier the cipher becomes to crack. The reverse also holds true – it’s much harder, or even impossible, to crack a cipher message that is too short, and where the key is used once and only once. As an example, try deciphering JTYLC. You can’t, but to the recipient that has the correct key, the decrypted plain text could be anything from a contact name to a coded instruction to take a particular action.

The point here is that if you’re solving cipher puzzles as a hobbyist, you want, and even need, longer cipher texts. Or, for CryptoQuips, you need the punctuation and spaces to help identify individual words.


(Using En/De to generate a random substitution table.)

Regardless, the process for applying the algorithm to encipher plain text, and decipher the cipher text, is the same as for the Caesar cipher. The only difference is that the cipher alphabet is randomized, and must be shared with the recipient of the message.

ABCDEFGHIJKLMNOPQRSTUVWXYZ: Plain alphabet
LCUMNPDJKHVORFQIAXBEGYZSTW: Cipher alphabet

THIS IS A CIPHER.
EJKB KB L UKIJNX.


(Enciphered “THIS IS A TEST.”)

Just go through the plain text message one letter at a time, and replace it with the corresponding letter from the cipher alphabet. T=E, H=J, I=K, S=B. To reverse the process, flip the plain and cipher alphabets and walk through the cipher message one letter at a time as before.

LCUMNPDJKHVORFQIAXBEGYZSTW: Cipher alphabet
ABCDEFGHIJKLMNOPQRSTUVWXYZ: Plain alphabet

Many people already know how to crack a simple random substitution cipher, but I’ll repeat the details here for reference.

To start with, most human written languages are made up of letters (ignoring Chinese ideograms and Japanese kanji), and some of these letters appear more frequently in sentences than the others do. These frequency values can be used as a “signature” to identify the language of the plain text message (assuming you have a large enough sample size to work with). For English, the most common letters are, in descending order: etaoin shurdlcu

The actual percentages can be found here in the wiki entry.

Historically, encrypted messages minus spaces and punctuation would be transmitted (via telegraph or other means) in fixed group sizes (such as in groups of 5) to reduce problems with overlooking letters, or getting them mixed up. So, the above example cipher would become:

LEPVP VOVPA HDXVJ RVLPL JLPZI BPHEX TQPLE IZVHO BXVVV

where the spaces have no particular meaning, and the message gets padded at the end to make the length a multiple of 5.

To crack this message, the first step is to count the individual letters.

P-7
V-7
L-5
E-3
etc.

From this chart, it might be reasonable to guess that P and V might be “e” or “t” in the plain text, and just start by plugging in e, t, a, i, o and s systematically for P, V, L and E and see what you get back out.

Next, count the number of 2-letter pairs that show up more than once:

LE-2
VP-2
XV-2
LP-2
PL-2

Two-letter pairs are called bigrams, and the most common ones in English are: “th”, “he”, “in”, “er” and “an”. Knowing that our plain text started with “THIS”, it might be a little disappointing to see that “L” (=T) is the third-most common letter used, where we might expect it to actually be the second-most, but the “LE” and “LP” bigrams do show that this frequency analysis can be helpful in zeroing in on the correct answer anyway.

Then, we’d want to count the three-letter triplets, the trigrams that show up more than once in the plain text. Unfortunately, our starting message was too short, and none of our trigrams here occur more than once each. If there were any, then the most common English trigrams are “the”, “and”, “tha”, “ent” and “ing”.

Naturally, we can also count 4-letter groupings (“then”, “this”, “will”) and 5-letter groupings (“other”, “ould”, “ather”). The longer the plain text message, the easier it becomes to crack. We can also look for identical pairs (“ll” and “ss”), or 4-letter combinations that start and end with the same letter (“that”, and “says”).

With the quip word puzzles, the author retains the punctuation and spacing from the plain text, which makes life much, much easier for us, even with shorter messages.

RLGX JWJ XLA OGBBUX EGZ RLAY WX RGE XUVJ XLABA RGE YU NUBA SUUJ WY XLA LUFEA? – “DBGDCABE!”

The first step would be to look for trigrams. XLA appears twice by itself and once within XLABA, while RGE appears twice. Assuming that XLA = “the”, and that XLABA can be either “there” or “these” almost solves the puzzle by itself.

As we get into more complicated ciphers, the importance of letter and word frequencies will become increasingly visible.

How can we harden the simple random substitution (or “quip”) cipher?

Well, we can stick to shorter plain text messages, reverse the plain text string (as we did in the Caesar cipher), expand the cipher alphabet, and employ one-time pads.

In the case of expanding the alphabet, we can include lower case letters, digits, spaces and punctuation (A-Z, a-z, 0-9, ” “, and ,;:[]{}=~|). In this way, even if we have a simple plain text message (“1 brown fox Jumped over the 2 lazy dogs?”), having the word spacing break up by making ” “=”b” (space = b), would slightly confuse the cryptologist (“did the encrypter maintain the word spacings or not?”) Although, this may just slow them down a bit if they’re expecting something like this.

One-time pads, though, would be almost impossible to overcome. The idea is to write a large number of keys (or random letter substitutions) on separate sheets of a pad of paper. The sender and the receiver both have a copy of the pad. The sender uses the key on the top sheet of the pad to encipher the message, and then destroys that sheet. The receiver decrypts the incoming message using the key on the top sheet of their pad, and then destroys that sheet as well. If the messages are kept short, it is virtually impossible for a third party to amass enough data to perform a reliable frequency analysis on whatever messages they do intercept. Historically, the reason why one-time pads were never widely adopted is that they require a lot of work to print up and distribute to everyone in the field that’s supposed to be able to read the encrypted messages. And, if a copy of the pad fell into the hands of the enemy, then they’d be able to read the intercepted messages as easily as if they’d never been encrypted.

But, with modern computers, it’s trivial to generate 200-300 keys or random substitution tables for entire ASCII character sets, and pass them around on CDs, USB drives or memory sticks. Strictly for legal purposes, of course.

In summary:
The simple random substitution cipher is just that.
It uses a random assignment of cipher letters to the plain text alphabet.
In the simplest form, the plain text only contains upper case letters.
For the newspaper puzzles, spaces and punctuation are retained.
This cipher can be easily broken, if the message is long enough, through letter frequency analysis.
Each human-written language has its own “frequency signature.”
The most common letters in the English language are “etaoin shurdlcu”.
This cipher can be hardened by keeping messages short, using the entire ASCII table for the cipher alphabet, and by using one-time pads.

Thinking About Encryption, Part 2



(En/De plain text entry screen.)

I’ll start out with the easiest and most well-known one – the Caesar Cipher; AKA, the Captain Midnight Decoder Ring code.

The Caesar cipher is a simple substitution algorithm where each letter is shifted a fixed number of positions along the alphabet. It gets its name from Julius Caesar, who is said to have used it for protecting military messages. Below, the upper line is for the plain text letters, and the lower line is what we read to get the cipher text.

Say we use a shift of 5:

ABCDEFGHIJKLMNOPQRSTUVWXYZ: Plain
FGHIJKLMNOPQRSTUVWXYZABCDE: Cipher

In other words, A=F, B=G, C=H, etc.
If our plain text message reads “THIS IS A SUBSTITUTION CIPHER”, the cipher result will be:

YMNX NX F XZGXYNYZYNTS HNUMJW

To reverse the process, we can either use the lower line for the cipher letters, and read the plain text off the upper line, or we can flip the lines and start from “A” for the cipher line, as follows:

ABCDEFGHIJKLMNOPQRSTUVWXYZ: Cipher
VWXYZABCDEFGHIJKLMNOPQRSTU: Plain

This gives us:

THIS IS A SUBSTITUTION CIPHER

again.


(En/De option selection screen.)

One thing this flipping demonstrates is that the Caesar cipher has a big weakness – flipping the key and reapplying the cipher causes your plain text to come back out. “A=F” relates to “A=V”.

You can pick a shift of 3, and apply the cipher to the plain text more than once:

WKLV LV D VXEVWLWXWLRQ FLSKHU: Once
ZNOY OY G YAHYZOZAZOUT IOVNKX: Twice
CQRB RB J BDKBCRCDCRXW LRYQNA: Three times

But this is really the same as applying a shift of 9 one time.

We can “harden” the Caesar cipher a little several different ways. First would be to “flip” the coder ring (i.e. – the lower cipher alphabet line) to go from Z to A.

ABCDEFGHIJKLMNOPQRSTUVWXYZ: Plain
ZYXWVUTSRQPONMLKJIHGFEDCBA: Cipher (w/ no shift)

The second step would be to reverse the plain text before enciphering (or reverse the cipher text afterward).

REHPIC NOITUTITSBUS A SI SIHT

LYVNUA POUJIJUJKBIK C KU KUVJ (reversed text, flipped ring, shift of 3)

By combining the two methods, we go from 25 possible encryption outputs (not counting A=A), to 4*26-1, or 103 possible outputs (normal unflipped, normal flipped, reversed normal, and reversed flipped).


(The cipher text after applying the options to the algorithm.)

Now, as we look at the various ciphers used throughout history, there are going to be a couple obvious factors for why they were considered adequate at the time, but not any more. In the case of the Caesar cipher, most of Rome’s enemies couldn’t read Latin. Shifting the letters a bit made the resulting message look like it was in a completely different language. The Romans themselves would figure things out very quickly, and in the case of Caesar sending messages to his generals, he WANTED them to read the cipher texts. But, if there were trained spies in the Roman ranks, or if one of Caesar’s Roman enemies wanted to spoil his plans, then this cipher isn’t all that secure.

But, still, if you’re trying to crack a cipher with pencil and paper, having to go through 25 different shifts is going to take time. And, by applying reversed text and a flipped cipher alphabet, that bumps you up to a maximum of 103 trials to see which algorithm and shift value is needed to read the message again. Doing this by hand, on paper, is going to be very time consuming.


(En/De brute force approach to cracking the Caesar cipher.)

However, with modern PCs we can easily apply the cipher algorithm to the cipher text to test every possible combination one at a time and still retrieve the original plain text message in less than a second. Two additional steps can make things even easier. First is to only apply the algorithm to the first 10-30 letters of the message, then when you know which key to apply by visually checking the output, run the algorithm on the entire message with that key (i.e. – normal, flipped ring, shift 6 places).

The other step is to create an array of common 3- and 4- letter words (e.g. – “the”, “this”, “and”, “will”, “for”, “she”, “her”, “was”), and count how often they show up in each combination of letter shifts. While it is possible that a random-looking permutation of letters might include “the” or “to”, only the correctly deciphered text will have the maximum number of hits on the words in the array. Using this array can allow the program to automagically identify a “best-fit” key, or even predict whether the Caesar cipher was used at all to encrypt the plain text. En-De already allows for testing shortened strings for speed, and I’ve just added the short word array test as I write this entry.

A couple other minor points to cover: The simplest form of the algorithm consists of only upper case letters (A-Z), no spaces and no punctuation or digits. And, any attempt to make the letter substitutions look really random just means that there’s more reason to attack the cipher via letter frequencies, which I’ll get into next time, instead of using the brute-force approach.

I also want to mention ROT-13 while I’m at this. I expect that most computer users are at least aware of ROT-13 as a name, while a lot of people have actually used it to hide, or reveal, video game, TV show and movie spoilers. ROT-13 is just another name for the Caesar cipher with a shift of 13 (A=N, B=O, C=P, etc.)

As mentioned above, there are other things we can do to further harden the Caesar cipher, but I’ll get into them later.

The main points to remember now are:
Caesar is a substitution cipher.
It consists of shifting each letter a fixed amount along the alphabet.
It’s used only on upper case letters.
It can be hardened in different ways.
It’s easy to crack as-is via bruteforce.
Almost everyone knows how to use, and break, it.

Subaru Telescope Papercraft


It’s been a while since I made any papercrafts, and I started jonesing for something while I was in the middle of a short break in a contract translation clean-up project. So, I went to the Canon papercrafts site and downloaded the PDF for the Subaru telescope.  The 300:1 scale model is based on the Subaru on Mauna Kea, in Hawai’i. I had some sheets of 0.15 mm and 0.22 mm paper left over from previous projects, and I debated over which to use for the telescope. 0.15 is a little stiffer than regular printer paper, but has the benefit of being easier to fold. 0.22 is getting closer to card stock and stands up better to stress, but is more likely to leave white lines all over given the thickness of the paper compared to the sizes of some of the model details. In the end, I settled on 0.15 mm, but it might have been smarter if I’d printed the PDF twice, once on each set of sheets, and then cherry-picked the correct stiffness depending on the section of the model I was working on.

I didn’t time myself, but I think I spent at least 15 hours over the course of 3 days building this thing. The most time-consuming activities were for cutting out all the pieces, and then gluing the circular walls to the round flats. The instructions suggested gluing one tab from the walls to the disks at a time, then letting it dry before going to the next tab. This is important for keeping the walls vertically straight, and for ensuring that the end of the wall strips will meet up evenly at the end. But, that was boring, and actually it’s kind of difficult to get the paper to curve right to follow the edges of the disks that way. So, I’d glue 3-5 tabs at a time, depending on the sizes of the tabs, and that worked out ok. The toughest sections to work on were the tiny buildings, and the mounting legs for the telescope stage. My hands kept sweating, making the paper soggy, and causing it to not hold the crease lines. Even so, I think the model turned out better than it had any right to.

The finished model is about 6″ tall, and a little under 7″ at its longest. The big shutters do slide open and closed, but the paper for the guide fingers is thin enough that it can bind up, so I just want to leave the shutters open all the time. The top half of the building comes off to reveal the telescope inside, and the scope and main dome can rotate 360 degrees. The telescope can also rotate up and down, but again, the paper is thin enough that I don’t want to handle the scope so much that something tears. If I were to build this papercraft again, I’d want to go at least one grade thicker on the paper.

But, overall, I’m glad I got this out of my system. I’ll show it off to some of my students, and then decide what to do with it long-term. Recommended to astronomy buffs with a lot of patience and dry hands.

Happy Birthday Emil Berliner (May 20)




(From the Google Doodles)