_ Ciphers are algorithms for performing encryption or
decryption–a series of well-defined steps that can be followed as
a procedure. Codes are usually a language; whole new words. Ciphers
are letter-by-letter changes. A stacked_ cipher is basically a
cipher applied to one or more ciphers. Stacked ciphers, as you'll
see, are very powerful. Most ciphers can be cracked by a skilled
cryptanalyst if the messages are long enough or numerous enough, but
stacking several simple ciphers together can make that job more
complicated than if they were to be cracked separately.
!! Steps !!
* Create the ciphers you'll be using. Skip this step if you'll be
using already existing ciphers, such as Caesar's cipher. When
creating ciphers for stacked codes, don't worry about making them
hard to decode. Even simple ciphers can go a long way when working
with rules.
* Apply the first cipher. For the purpose of this article, the
example uses the sentence "Hello World". Start with Caesar's
cipher.[1] "Hello World" would become *Ifmmp xpsme* if we switched
it one to the right.
* Double-check your work. It can be very frustrating to work hard on
your message, only to find out that it's wrong. A simple typo or
miscalculation can be disastrous. _Ifmmp xpsme_ can easily become
_fmnp xpsme_, which translates to *elmo world*. If you live in a
town that has a theme park called "Hello World" and a children's
playground called *Elmo World*, and your message is "Meet at...",
the result would be a mess-up! Check, double check, and triple
check if it's that important.
Apply the next cipher. For this example, use the substitution
cipher[2] on it. You can use any substitution you want, this
example uses:
Click for large version of table.
* Applying this cipher, you will get: *Wkhha qachv*. The benefit of
using stacked ciphers clearly shows up here. Anyone who tried to
decode this would have a very hard time finding a pattern, with
two ciphers applied.
* Double-check your latest work. As stressed above, double checking
is needed, _especially_ when dealing with stacked ciphers.
Repeat the last two steps until you've used all the ciphers you
want to use. Three ciphers stacked will probably be enough. More
than three will be too complicated for you, and especially your
friend, to decode, even with the key laying beside you. While more
than three is too many, less than three can be easy to decode.
Don't use substitution code or Caesar's code more than once. Try
another kind of code, such as a symbol code.
* _ Keypad of a phone. Note the letters under the numbers.
Use phone code now. Phone code relies on the keypad of a phone or
cellphone to do its work. If you look at a phone, you'll notice
that the letters in small print under the number start at 2. 2 =
abc, 3 = def, 4 = ghi and so on. To write in phone code, jot down
the number that corresponds to the correct letter, then add a dot
either to the left, on top, or to the right of the number. For
example, to write b_, write a 2 with a dot on top. To write _L_,
write a 5 with a dot to the right of it.
Go ahead and write the message, *Wkhha qachv*, in phone code. Note
that some numbers have 4 letters under them; for these, carry on the
same, but for the last letter on that number, put two dots to the
right. Look at the seven in the following image, you'll see two dots
for _s_.
* Your phone code should look like this: _ "Wkhha qachv" in
phone code.
* The stacked cipher can now be illustrated by the following image:
The stacked cipher.
* Add rules. Rules are what throw off a "spy" or nosy person the
most. With rules, you're not bound down by the normal ciphers that
can easily be cracked; and you can't just "guess" what certain
words are. An example rule would be: "Every other word, the
Caesar's cipher is applied by two." This means that every other
word, instead of A = B, it's A = C, B = D, and so on. If someone
found out what *wkhha* means, they wouldn't be able to apply it to
every *wkhha* in the code, because some would be different. The
next steps explain how to make and apply rules.
* Make the rule. Come up with something creative. Think of grammar,
and use rules such as "after each a_, the next letter is one up in
the alphabet." You could even go incrementally (each word goes up
one in the alphabet.) So "Hello World" would be _Ifmmp Yqtnf_,
instead of _Ifmmp Xpsme_. (The second word, "world", goes up two
in the alphabet instead of one.) Although going up incrementally
would be very hard in a code that is more than ten words long, it
is useful in messages less than ten messages long.
* Apply the rule. Applying rules gets tricky, especially if you make
them once you've finished writing the message in code. Once
applied, though, a rule will stump any spy who tries to read your
messages. Once you've applied your rule, double check your work.
* Make a chart of rules. Write out a list of the rules you have, and
give it to your friend. That way, you never have to send a message
in the same code again. (At the top, you can just write *Applied
Rule 1, 5, and 7,* then whoever you're communicating with can look
at his/her chart and decode with those rules.)
Make keys. Unless you expect your friend to decode each and every
message you send him or her without a key, create one. Never have
more than one copy per person, otherwise you increase the
likelihood that someone else will find the key. You can have preset
codes with cryptic names, too. For example, you could name the
stacked cipher just created above *CSP*. (*C*aesar's cipher,
*S*ubstitution cipher, *P*hone cipher.) If you apply rule 5 out of
all your rules to this code, then you can add _5_ to the name, so
it's *CSP5*. Most likely, a spy won't figure out the names. Just
send the code in this format:
!! Examples !!
!! C1N2 Stacked Cipher !!
This stacked cipher consists of: Caesar's cipher, Rule 1, Number code,
and Rule 2. The message to be encrypted here is: *Meet me at the
cafe*.
* Begin with Caesar's cipher. The result is: *Nffu nf bu uif dbgf*.
* Apply Rule 1. The rule reads as follows: _Every second letter, not
including spaces, shift up two, instead of one._ So, if you were
to encrypt "Meet", it wouldn't be *Nffu*, it would be *Ngfv*,
because you shift the second letter, _f_, and the last letter, _v_
up one more. The result is: *Ngfv ng bv ujf ebhf*.
* Apply number code. Number code is simple. Just replace each letter
with its corresponding position in the alphabet. So "a" is 1, "b"
is 2, "c" is 3, "d" is 4, "e" is 5, etc. Write it with dashes
between each letter: "abc" becomes 1-2-3. The result is:
_14-7-6-22 14-7 2-22 21-10-6 5-2-8-6_.
* Apply Rule 2. Rule 2 reads as follows: _Divide the number after
each 6 by two._ So if the message is *6-8-22-4*, it becomes
*6-4-22-4*. If it's *6-5-11-3*, it becomes *6-2.5-11-3*. Once the
rule is applied, the message becomes *14-7-6-_11_ 14-7 2-22
21-10-6 _2.5_-2-8-6*. (Optional): You could also amend the rule so
that if a 6 is at the very end of the message, the beginning
number is divided by two.
Congratulations! That is the finished code. All you have to write to
your friend is:
* Using: C1N2
* 14-7-6-11 14-7 2-22 21-10-6 2.5-2-8-6
!! Braille-Morse !!
An example based on Braille and Morse code. Taken individually, they
offer _zero_ security. They were invented to make communication (with
blind people and by telegraph) easier, not harder. But if combined,
anyone who intercepted the encrypted message might not see how to
crack it. In this example, we'll encrypt the phrase, "Meeting Monday
in Lincoln Park."
* Email this Article
* Edit
* Discuss
0 comments:
Post a Comment