From: Bob [mailto:[email protected]]
Sent: Sunday, February 1, 2015 12:48 PM
To: Alice
Subject: Interloper Subversion
We have information from División de Inteligencia Externa
indicating our operations could be in danger of discovery
and compromise via corporate espionage. A perpetrator has
yet to be found. However, we have located an agent having
Dreary Jeans' file. DIE has confirmed the annihilation of
the family is now a volatile affair and will provide some
much needed distractions when possible. Their timeline is
indicating a terminal solution by the time of this coming
spring equinox. Please be advised that the attachment may
require the disk jockey's parentheses prior to retrieval.
Attached: payload.me
hVWEw6hQu4ocNJ3! wMst9lJW, dvR8e5ymcU, JDE pbpoAI HK0C9 UYi q67BRJUV Ybs gicf2
48 7joA O6Zqfi qKkE SrS. IYL3 blO2NC6 7HQ gkfxo5AcL Rp y jExSZQ, upT YD f8l fy
a E5FH Ke ZpgFx5nqcdz5, E3u IWh7xE5tE K4j3 Hn2P 90 Yad75q? xkZ6Qz RIm KG7 CLP!
mLD, Gzi7a 79 qAPi gU 22vwhh ASr BGa HhR Yc 0Ya0 n0mc. rt ND3 eeTgnG EB p23EO,
sgQW kXq sqd9 QYUXfn0c 8O Pr92a4uR. ev Bt Rp5R://At7.cx6.MB3/p8LEf3 aGo 2wl n9
rX3 XCTx1dLCm jase7 nuu Fw tbgPTMU. bVM2s CO a6O qFJSQd PM9ThgZg 3tb C Ybr93x.
SQzF-GMBM-ElAe-0yd7
cpBG-KimE-Yss8-aec0
Ep6eq-HZ5Kn-EeHlL-rmIjU
E-mail: Show
From: Alice [mailto:[email protected]]
Sent: Friday, March 20, 2015 12:52 PM
To: Bob
Subject: Biological Experiment
I heard about the errors División de Inteligencia Externa
has been taking the blame for and am sorry for all of the
agony your side has had to endure. You all were fortunate
that the contagion was designed to incapacitate people on
release and not to kill them. DIE would have lived to act
on their acronym but died in the process had the accident
been with a more potent strain. All that is behind us now
the incident has cleared, and the committee of seven will
be expecting no further delays. Your deadline will be due
in one week without exception. Finish Dreary Jeans' case!
E-mail: Show
To Whom It May Concern:
The following is a tutorial on the processes involved
in ME. We will cover creation of the encoding and
decoding multidimensional arrays along with the use of
them in the encryption and decryption processes
respectively. Once understood, the basis for developing
a more space efficient method can then be developed.
Make Encoding Grid
------------------
For our example, we will use the following key:
iOUeaouEAI
uEaIUieOAo
IoUEaAOeiu
The first line forms a one-dimensional template, and
the second line instructs us to create a two-
dimensional template where the beginning of each line
starts with the given letter. This is accomplished by
rotating the original template to match a given
character. Thus, we should end up with the following
two-dimensional template:
uEAIiOUeao
EAIiOUeaou
aouEAIiOUe
IiOUeaouEA
UeaouEAIiO
iOUeaouEAI
eaouEAIiOU
OUeaouEAIi
AIiOUeaouE
ouEAIiOUea
Notice that this grid has two properties related to
Sudoku. First, every character is unique on a row.
Second, the same holds true for each column. It was for
this reason that the key was once called a Sudoku key,
and the property will be very important when developing
a decoding algorithm.
Now that we have created a two-dimensional template
based on the one-dimensional template given in the
first line of the key, we may now interpret the third
line in the key. This tells us to form a new three-
dimensional template where each stacked two-dimensional
template is rotated to begin with the given letter. As
a result, we come up with the following data structure:
0 1 2 3 4
IiOUeaouEA ouEAIiOUea UeaouEAIiO EAIiOUeaou aouEAIiOUe
iOUeaouEAI uEAIiOUeao eaouEAIiOU AIiOUeaouE ouEAIiOUea
EAIiOUeaou eaouEAIiOU iOUeaouEAI ouEAIiOUea UeaouEAIiO
UeaouEAIiO AIiOUeaouE ouEAIiOUea iOUeaouEAI EAIiOUeaou
ouEAIiOUea OUeaouEAIi AIiOUeaouE eaouEAIiOU iOUeaouEAI
eaouEAIiOU IiOUeaouEA uEAIiOUeao OUeaouEAIi AIiOUeaouE
uEAIiOUeao UeaouEAIiO IiOUeaouEA aouEAIiOUe OUeaouEAIi
aouEAIiOUe iOUeaouEAI EAIiOUeaou UeaouEAIiO IiOUeaouEA
OUeaouEAIi EAIiOUeaou aouEAIiOUe IiOUeaouEA uEAIiOUeao
AIiOUeaouE aouEAIiOUe OUeaouEAIi uEAIiOUeao eaouEAIiOU
5 6 7 8 9
AIiOUeaouE OUeaouEAIi eaouEAIiOU iOUeaouEAI uEAIiOUeao
IiOUeaouEA UeaouEAIiO aouEAIiOUe OUeaouEAIi EAIiOUeaou
uEAIiOUeao IiOUeaouEA OUeaouEAIi AIiOUeaouE aouEAIiOUe
OUeaouEAIi aouEAIiOUe uEAIiOUeao eaouEAIiOU IiOUeaouEA
aouEAIiOUe EAIiOUeaou IiOUeaouEA uEAIiOUeao UeaouEAIiO
UeaouEAIiO ouEAIiOUea EAIiOUeaou aouEAIiOUe iOUeaouEAI
ouEAIiOUea AIiOUeaouE iOUeaouEAI EAIiOUeaou eaouEAIiOU
eaouEAIiOU uEAIiOUeao AIiOUeaouE ouEAIiOUea OUeaouEAIi
iOUeaouEAI eaouEAIiOU ouEAIiOUea UeaouEAIiO AIiOUeaouE
EAIiOUeaou iOUeaouEAI UeaouEAIiO IiOUeaouEA ouEAIiOUea
The numbers are to denote the individual levels of this
data structure. Notice that part nine is exactly the
same as the previous template. Since that template
starts with a "u" and the last instruction in the third
line of the key in a "u", the original template is used
without modification. From here on, positions in the
three-dimensional data structure will be given as
(Part,Row,Column) with all numbers being zero based.
To understand how the encoding grid was created, it may
help to look at (9,0,1) and then compare this to
(3,0,0). "E" is the fourth character in line three of
the key instructions, so this would explain (3,0,0).
Now if you compare part nine to part 3, you should
notice that each line is rotated by one character to
the left. Our original one-dimensional template is
undergoing rotation transformations on every line.
Encrypt
-------
Now that we have a grid with which to encode our data,
let us define our initialization vector (usually called
a primer in this context but once known as a boot
strap) as the following:
EU
Our plaintext for encryption will be Genesis 1:1, and
we will only encrypt letters of interest to us, the
vowels referenced in the key. So the first letter that
happens to be vowel is "I" from the word "In" (the
first word in the verse). We then append this letter to
the IV to form EUI. Let us rewrite that at (E,U,I).
Now we have something that looks like a coordinate, but
since there are no numbers, it cannot be used to access
our three-dimensional grid. Recall the first line of
the key, our one-dimensional template. This contains
all of the characters that we will process. Let us
perform a sorting operation on the template to get a
well-defined order on our characters.
iOUeaouEAI -> AEIOUaeiou
We will now use the indexes of the sorted string to
rewrite our three-dimensional coordinate. (E,U,I)
becomes (1,4,2) when we replace the characters with the
proper index positions. If you use this coordinate to
access the three-dimensional grid, you will find the
letter "e" which will replace the "I" found in the
first word.
The first character of our plaintext has been
transformed into ciphertext, but there are still plenty
of other characters to process. The string "n th"
follows the "I" but does not contain any vowels and so
will be written without any transformations. The "e" in
"the" is a vowel and will require encryption, though.
We need to create a new index to access our three-
dimensional grid for the next ciphertext character. To
do this, we will take (E,U,I), append the "e" we found,
and drop the beginning "E" to maintain a length of
three (the number of dimensions to our grid). Thus our
new coordinate is (U,I,e). Written with indexes, this
becomes (4,2,6).
When we access our grid using (4,2,6), we find the
vowel "A" which will replace our "e" found in the
plaintext. So far, we have constructed the string "en
thA" as the beginning of the ciphertext. From here, the
rest of the replacements will be expressed in an
abbreviated form from beginning to end. The format is
plaintext character -> character coordinate -> index
coordinate -> ciphertext character.
I -> (E,U,I) -> (1,4,2) -> e
e -> (U,I,e) -> (4,2,6) -> A
e -> (I,e,e) -> (2,6,6) -> o
i -> (e,e,i) -> (6,6,7) -> o
i -> (e,i,i) -> (6,7,7) -> e
o -> (i,i,o) -> (7,7,8) -> u
e -> (i,o,e) -> (7,8,6) -> O
a -> (o,e,a) -> (8,6,5) -> U
e -> (e,a,e) -> (6,5,6) -> O
e -> (a,e,e) -> (5,6,6) -> O
e -> (e,e,e) -> (6,6,6) -> a
a -> (e,e,a) -> (6,6,5) -> e
e -> (e,a,e) -> (6,5,6) -> O
a -> (a,e,a) -> (5,6,5) -> i
e -> (e,a,e) -> (6,5,6) -> O
e -> (a,e,e) -> (5,6,6) -> O
a -> (e,e,a) -> (6,6,5) -> e
That is a complete summary of how encryption works in
ME. Each of the plaintext characters are replaced with
ciphertext characters, and the remaining plaintext
characters are not changed since they were of no
interest to us. Of course, there is the option to
encrypt these other characters with another pass
through the encryption process using another key and
primer. Our final ciphertext is the following:
en thA bogonneng Gud crOUtOd thO haevOn ind thO Oerth.
Make Decoding Grid
------------------
The first thing you want to do to create a decoding
grid is to create an encoding grid. Then recall the
sorted template (AEIOUaeiou) we made up in the encrypt
stage. We will call this our base. Now for every row in
our three-dimensional grid, we are going to run the
follow set of operations on them. Our first old row is
"IiOUeaouEA", and "__________" will denote an empty new
row.
The first character in our old row is "I" and has an
index of 2 in our base. So we are going to replace the
third underscore in our new row. We will place it with
the first character in our base. So our new row becomes
"__A_______". The next old character is "i" with an
index of 7. We will replace the eighth character in our
new row with the second character (E) from our base so
it becomes "__A____E__".
If we continue this process of using the base index of
the next character in our old row to change that
position in our new row to be the next character in the
base, then we will end up with the string "uoAIOaUEei".
If we continue this process until all rows in our
three-dimensional grid are transformed, we will create
a new grid with the following definition:
0 1 2 3 4
uoAIOaUEei OIUeiuoaAE eaiuAIEoOU EAIUaieOou UOaioAueEI
oiuEIUOAae IEOaeoiUuA aUeouEAiIO AuEOUeaIio OIUeiuoaAE
EAIUaieOou aUeouEAiIO oiuEIUOAae OIUeiuoaAE eaiuAIEoOU
eaiuAIEoOU AuEOUeaIio OIUeiuoaAE oiuEIUOAae EAIUaieOou
OIUeiuoaAE ieoAEOIuUa AuEOUeaIio aUeouEAiIO oiuEIUOAae
aUeouEAiIO uoAIOaUEei IEOaeoiUuA ieoAEOIuUa AuEOUeaIio
IEOaeoiUuA eaiuAIEoOU uoAIOaUEei UOaioAueEI ieoAEOIuUa
UOaioAueEI oiuEIUOAae EAIUaieOou eaiuAIEoOU uoAIOaUEei
ieoAEOIuUa EAIUaieOou UOaioAueEI uoAIOaUEei IEOaeoiUuA
AuEOUeaIio UOaioAueEI ieoAEOIuUa IEOaeoiUuA aUeouEAiIO
5 6 7 8 9
AuEOUeaIio ieoAEOIuUa aUeouEAiIO oiuEIUOAae IEOaeoiUuA
uoAIOaUEei eaiuAIEoOU UOaioAueEI ieoAEOIuUa EAIUaieOou
IEOaeoiUuA uoAIOaUEei ieoAEOIuUa AuEOUeaIio UOaioAueEI
ieoAEOIuUa UOaioAueEI IEOaeoiUuA aUeouEAiIO uoAIOaUEei
UOaioAueEI EAIUaieOou uoAIOaUEei IEOaeoiUuA eaiuAIEoOU
eaiuAIEoOU OIUeiuoaAE EAIUaieOou UOaioAueEI oiuEIUOAae
OIUeiuoaAE AuEOUeaIio oiuEIUOAae EAIUaieOou aUeouEAiIO
aUeouEAiIO IEOaeoiUuA AuEOUeaIio OIUeiuoaAE ieoAEOIuUa
oiuEIUOAae aUeouEAiIO OIUeiuoaAE eaiuAIEoOU AuEOUeaIio
EAIUaieOou oiuEIUOAae eaiuAIEoOU uoAIOaUEei OIUeiuoaAE
This is the same three-dimensional grid created up in
the "make encoding grid" phase, but each row has had
the previously defined transformation run on it. The
characters at (0,0,X) are the same "uoAIOaUEei" that we
found before. This new three-dimensional grid can now
be used to decrypt our ciphertext back into plaintext.
Decrypt
-------
Just as with encrypting, we need to form a coordinate
with which to reference our three-dimensional grid. We
take our primer again which primes the process and
generate the coordinate (E,U,_). The last position will
be the first character of interest in our ciphertext.
In this case, "e" will replace the underscore to
produce (E,U,e).
Again, this character based coordinate needs to have
the vowels replaced with numbers. We reference the base
(the sorted one-dimensional template used previously)
and determine that the coordinate should be (1,4,6).
Not surprisingly, we discover this position in our
decoding grid to be "I" which is the first letter in
the word "In."
We may pass over the characters "n th" as we did when
encrypting since they are uninteresting to us. Now we
need to decode the "A" following the "th." The
character coordinate needs to be modified such that the
"e" is replaced with "I" since that is its decoded
value to become (E,U,I). Next, the "A" should be
appended and the "E" dropped to maintain our three
dimensions.
With the coordinate now reading as (U,I,A), we may now
transform those vowels into the index positions from
our base. From there, we get the coordinate (4,2,0).
When we use this to access the characters in our
decoding grid, we find the letter "e" so that "thA"
becomes "the" as expected. Our next coordinate will
become (I,e,o) with a numerical value of (2,6,8).
All transformations will be listed as was done for the
encryption section. Do not forget that the last decoded
letter will replace its position in the coordinate
before the next letter is appended and the first letter
dropped. This will allow a consistency that will
allowed continued decryption. The following log's
format is ciphertext character -> character coordinate
-> index coordinate -> plaintext character.
e -> (E,U,e) -> (1,4,6) -> I
A -> (U,I,A) -> (4,2,0) -> e
o -> (I,e,o) -> (2,6,8) -> e
o -> (e,e,o) -> (6,6,8) -> i
e -> (e,i,e) -> (6,7,6) -> i
u -> (i,i,u) -> (7,7,9) -> o
O -> (i,o,O) -> (7,8,3) -> e
U -> (o,e,U) -> (8,6,4) -> a
O -> (e,a,O) -> (6,5,3) -> e
O -> (a,e,O) -> (5,6,3) -> e
a -> (e,e,a) -> (6,6,5) -> e
e -> (e,e,e) -> (6,6,6) -> a
O -> (e,a,O) -> (6,5,3) -> e
i -> (a,e,i) -> (5,6,7) -> a
O -> (e,a,O) -> (6,5,3) -> e
O -> (a,e,O) -> (5,6,3) -> e
e -> (e,e,e) -> (6,6,6) -> a
While the process does not require a computer, using
one to automate this process can be very helpful.
Another problem one might encounter is the space
requirements required by the grid constructed from a
large key. Grids take up space equivalent to A raised
to the power of B where A is the count of unique
characters to encrypt and B is the length of the Markov
chain used to index the grid.
As a result, taking the transformations of the key into
a grid should be redesigned so that the encoding and
decoding grids are not needed at all. Otherwise if you
had 100 characters of interest and wanted to use Markov
chains of length 10 (requiring a primer of length 9),
you would need to construct a grid having over 86
Exabytes of data. The final result of our decryption is
as follows:
In the beginning God created the heaven and the earth.
Conclusion
----------
While this tutorial covered the first plaintext and
ciphertext pair, the second is left as an exercise for
the reader. This tutorial may also be considered to be
a work in progress. If you can improve it, please do so
and pass it on to the rest of your team. Though it
would probably be difficult to discover the results,
finding out how Merlin would respond to this would be
particularly interesting to me.
A Concerned Individual,
Velociraptor
Letter: Show