Guest User

Justice and Fairness - Hint 36

a guest
Mar 27th, 2015
55
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. To Whom It May Concern:
  2.  
  3. The following is a tutorial on the processes involved
  4. in ME. We will cover creation of the encoding and
  5. decoding multidimensional arrays along with the use of
  6. them in the encryption and decryption processes
  7. respectively. Once understood, the basis for developing
  8. a more space efficient method can then be developed.
  9.  
  10. Make Encoding Grid
  11. ------------------
  12.  
  13. For our example, we will use the following key:
  14.  
  15. iOUeaouEAI
  16. uEaIUieOAo
  17. IoUEaAOeiu
  18.  
  19. The first line forms a one-dimensional template, and
  20. the second line instructs us to create a two-
  21. dimensional template where the beginning of each line
  22. starts with the given letter. This is accomplished by
  23. rotating the original template to match a given
  24. character. Thus, we should end up with the following
  25. two-dimensional template:
  26.  
  27. uEAIiOUeao
  28. EAIiOUeaou
  29. aouEAIiOUe
  30. IiOUeaouEA
  31. UeaouEAIiO
  32. iOUeaouEAI
  33. eaouEAIiOU
  34. OUeaouEAIi
  35. AIiOUeaouE
  36. ouEAIiOUea
  37.  
  38. Notice that this grid has two properties related to
  39. Sudoku. First, every character is unique on a row.
  40. Second, the same holds true for each column. It was for
  41. this reason that the key was once called a Sudoku key,
  42. and the property will be very important when developing
  43. a decoding algorithm.
  44.  
  45. Now that we have created a two-dimensional template
  46. based on the one-dimensional template given in the
  47. first line of the key, we may now interpret the third
  48. line in the key. This tells us to form a new three-
  49. dimensional template where each stacked two-dimensional
  50. template is rotated to begin with the given letter. As
  51. a result, we come up with the following data structure:
  52.  
  53. 0 1 2 3 4
  54. IiOUeaouEA ouEAIiOUea UeaouEAIiO EAIiOUeaou aouEAIiOUe
  55. iOUeaouEAI uEAIiOUeao eaouEAIiOU AIiOUeaouE ouEAIiOUea
  56. EAIiOUeaou eaouEAIiOU iOUeaouEAI ouEAIiOUea UeaouEAIiO
  57. UeaouEAIiO AIiOUeaouE ouEAIiOUea iOUeaouEAI EAIiOUeaou
  58. ouEAIiOUea OUeaouEAIi AIiOUeaouE eaouEAIiOU iOUeaouEAI
  59. eaouEAIiOU IiOUeaouEA uEAIiOUeao OUeaouEAIi AIiOUeaouE
  60. uEAIiOUeao UeaouEAIiO IiOUeaouEA aouEAIiOUe OUeaouEAIi
  61. aouEAIiOUe iOUeaouEAI EAIiOUeaou UeaouEAIiO IiOUeaouEA
  62. OUeaouEAIi EAIiOUeaou aouEAIiOUe IiOUeaouEA uEAIiOUeao
  63. AIiOUeaouE aouEAIiOUe OUeaouEAIi uEAIiOUeao eaouEAIiOU
  64. 5 6 7 8 9
  65. AIiOUeaouE OUeaouEAIi eaouEAIiOU iOUeaouEAI uEAIiOUeao
  66. IiOUeaouEA UeaouEAIiO aouEAIiOUe OUeaouEAIi EAIiOUeaou
  67. uEAIiOUeao IiOUeaouEA OUeaouEAIi AIiOUeaouE aouEAIiOUe
  68. OUeaouEAIi aouEAIiOUe uEAIiOUeao eaouEAIiOU IiOUeaouEA
  69. aouEAIiOUe EAIiOUeaou IiOUeaouEA uEAIiOUeao UeaouEAIiO
  70. UeaouEAIiO ouEAIiOUea EAIiOUeaou aouEAIiOUe iOUeaouEAI
  71. ouEAIiOUea AIiOUeaouE iOUeaouEAI EAIiOUeaou eaouEAIiOU
  72. eaouEAIiOU uEAIiOUeao AIiOUeaouE ouEAIiOUea OUeaouEAIi
  73. iOUeaouEAI eaouEAIiOU ouEAIiOUea UeaouEAIiO AIiOUeaouE
  74. EAIiOUeaou iOUeaouEAI UeaouEAIiO IiOUeaouEA ouEAIiOUea
  75.  
  76. The numbers are to denote the individual levels of this
  77. data structure. Notice that part nine is exactly the
  78. same as the previous template. Since that template
  79. starts with a "u" and the last instruction in the third
  80. line of the key in a "u", the original template is used
  81. without modification. From here on, positions in the
  82. three-dimensional data structure will be given as
  83. (Part,Row,Column) with all numbers being zero based.
  84.  
  85. To understand how the encoding grid was created, it may
  86. help to look at (9,0,1) and then compare this to
  87. (3,0,0). "E" is the fourth character in line three of
  88. the key instructions, so this would explain (3,0,0).
  89. Now if you compare part nine to part 3, you should
  90. notice that each line is rotated by one character to
  91. the left. Our original one-dimensional template is
  92. undergoing rotation transformations on every line.
  93.  
  94. Encrypt
  95. -------
  96.  
  97. Now that we have a grid with which to encode our data,
  98. let us define our initialization vector (usually called
  99. a primer in this context but once known as a boot
  100. strap) as the following:
  101.  
  102. EU
  103.  
  104. Our plaintext for encryption will be Genesis 1:1, and
  105. we will only encrypt letters of interest to us, the
  106. vowels referenced in the key. So the first letter that
  107. happens to be vowel is "I" from the word "In" (the
  108. first word in the verse). We then append this letter to
  109. the IV to form EUI. Let us rewrite that at (E,U,I).
  110.  
  111. Now we have something that looks like a coordinate, but
  112. since there are no numbers, it cannot be used to access
  113. our three-dimensional grid. Recall the first line of
  114. the key, our one-dimensional template. This contains
  115. all of the characters that we will process. Let us
  116. perform a sorting operation on the template to get a
  117. well-defined order on our characters.
  118.  
  119. iOUeaouEAI -> AEIOUaeiou
  120.  
  121. We will now use the indexes of the sorted string to
  122. rewrite our three-dimensional coordinate. (E,U,I)
  123. becomes (1,4,2) when we replace the characters with the
  124. proper index positions. If you use this coordinate to
  125. access the three-dimensional grid, you will find the
  126. letter "e" which will replace the "I" found in the
  127. first word.
  128.  
  129. The first character of our plaintext has been
  130. transformed into ciphertext, but there are still plenty
  131. of other characters to process. The string "n th"
  132. follows the "I" but does not contain any vowels and so
  133. will be written without any transformations. The "e" in
  134. "the" is a vowel and will require encryption, though.
  135.  
  136. We need to create a new index to access our three-
  137. dimensional grid for the next ciphertext character. To
  138. do this, we will take (E,U,I), append the "e" we found,
  139. and drop the beginning "E" to maintain a length of
  140. three (the number of dimensions to our grid). Thus our
  141. new coordinate is (U,I,e). Written with indexes, this
  142. becomes (4,2,6).
  143.  
  144. When we access our grid using (4,2,6), we find the
  145. vowel "A" which will replace our "e" found in the
  146. plaintext. So far, we have constructed the string "en
  147. thA" as the beginning of the ciphertext. From here, the
  148. rest of the replacements will be expressed in an
  149. abbreviated form from beginning to end. The format is
  150. plaintext character -> character coordinate -> index
  151. coordinate -> ciphertext character.
  152.  
  153. I -> (E,U,I) -> (1,4,2) -> e
  154. e -> (U,I,e) -> (4,2,6) -> A
  155. e -> (I,e,e) -> (2,6,6) -> o
  156. i -> (e,e,i) -> (6,6,7) -> o
  157. i -> (e,i,i) -> (6,7,7) -> e
  158. o -> (i,i,o) -> (7,7,8) -> u
  159. e -> (i,o,e) -> (7,8,6) -> O
  160. a -> (o,e,a) -> (8,6,5) -> U
  161. e -> (e,a,e) -> (6,5,6) -> O
  162. e -> (a,e,e) -> (5,6,6) -> O
  163. e -> (e,e,e) -> (6,6,6) -> a
  164. a -> (e,e,a) -> (6,6,5) -> e
  165. e -> (e,a,e) -> (6,5,6) -> O
  166. a -> (a,e,a) -> (5,6,5) -> i
  167. e -> (e,a,e) -> (6,5,6) -> O
  168. e -> (a,e,e) -> (5,6,6) -> O
  169. a -> (e,e,a) -> (6,6,5) -> e
  170.  
  171. That is a complete summary of how encryption works in
  172. ME. Each of the plaintext characters are replaced with
  173. ciphertext characters, and the remaining plaintext
  174. characters are not changed since they were of no
  175. interest to us. Of course, there is the option to
  176. encrypt these other characters with another pass
  177. through the encryption process using another key and
  178. primer. Our final ciphertext is the following:
  179.  
  180. en thA bogonneng Gud crOUtOd thO haevOn ind thO Oerth.
  181.  
  182. Make Decoding Grid
  183. ------------------
  184.  
  185. The first thing you want to do to create a decoding
  186. grid is to create an encoding grid. Then recall the
  187. sorted template (AEIOUaeiou) we made up in the encrypt
  188. stage. We will call this our base. Now for every row in
  189. our three-dimensional grid, we are going to run the
  190. follow set of operations on them. Our first old row is
  191. "IiOUeaouEA", and "__________" will denote an empty new
  192. row.
  193.  
  194. The first character in our old row is "I" and has an
  195. index of 2 in our base. So we are going to replace the
  196. third underscore in our new row. We will place it with
  197. the first character in our base. So our new row becomes
  198. "__A_______". The next old character is "i" with an
  199. index of 7. We will replace the eighth character in our
  200. new row with the second character (E) from our base so
  201. it becomes "__A____E__".
  202.  
  203. If we continue this process of using the base index of
  204. the next character in our old row to change that
  205. position in our new row to be the next character in the
  206. base, then we will end up with the string "uoAIOaUEei".
  207. If we continue this process until all rows in our
  208. three-dimensional grid are transformed, we will create
  209. a new grid with the following definition:
  210.  
  211. 0 1 2 3 4
  212. uoAIOaUEei OIUeiuoaAE eaiuAIEoOU EAIUaieOou UOaioAueEI
  213. oiuEIUOAae IEOaeoiUuA aUeouEAiIO AuEOUeaIio OIUeiuoaAE
  214. EAIUaieOou aUeouEAiIO oiuEIUOAae OIUeiuoaAE eaiuAIEoOU
  215. eaiuAIEoOU AuEOUeaIio OIUeiuoaAE oiuEIUOAae EAIUaieOou
  216. OIUeiuoaAE ieoAEOIuUa AuEOUeaIio aUeouEAiIO oiuEIUOAae
  217. aUeouEAiIO uoAIOaUEei IEOaeoiUuA ieoAEOIuUa AuEOUeaIio
  218. IEOaeoiUuA eaiuAIEoOU uoAIOaUEei UOaioAueEI ieoAEOIuUa
  219. UOaioAueEI oiuEIUOAae EAIUaieOou eaiuAIEoOU uoAIOaUEei
  220. ieoAEOIuUa EAIUaieOou UOaioAueEI uoAIOaUEei IEOaeoiUuA
  221. AuEOUeaIio UOaioAueEI ieoAEOIuUa IEOaeoiUuA aUeouEAiIO
  222. 5 6 7 8 9
  223. AuEOUeaIio ieoAEOIuUa aUeouEAiIO oiuEIUOAae IEOaeoiUuA
  224. uoAIOaUEei eaiuAIEoOU UOaioAueEI ieoAEOIuUa EAIUaieOou
  225. IEOaeoiUuA uoAIOaUEei ieoAEOIuUa AuEOUeaIio UOaioAueEI
  226. ieoAEOIuUa UOaioAueEI IEOaeoiUuA aUeouEAiIO uoAIOaUEei
  227. UOaioAueEI EAIUaieOou uoAIOaUEei IEOaeoiUuA eaiuAIEoOU
  228. eaiuAIEoOU OIUeiuoaAE EAIUaieOou UOaioAueEI oiuEIUOAae
  229. OIUeiuoaAE AuEOUeaIio oiuEIUOAae EAIUaieOou aUeouEAiIO
  230. aUeouEAiIO IEOaeoiUuA AuEOUeaIio OIUeiuoaAE ieoAEOIuUa
  231. oiuEIUOAae aUeouEAiIO OIUeiuoaAE eaiuAIEoOU AuEOUeaIio
  232. EAIUaieOou oiuEIUOAae eaiuAIEoOU uoAIOaUEei OIUeiuoaAE
  233.  
  234. This is the same three-dimensional grid created up in
  235. the "make encoding grid" phase, but each row has had
  236. the previously defined transformation run on it. The
  237. characters at (0,0,X) are the same "uoAIOaUEei" that we
  238. found before. This new three-dimensional grid can now
  239. be used to decrypt our ciphertext back into plaintext.
  240.  
  241. Decrypt
  242. -------
  243.  
  244. Just as with encrypting, we need to form a coordinate
  245. with which to reference our three-dimensional grid. We
  246. take our primer again which primes the process and
  247. generate the coordinate (E,U,_). The last position will
  248. be the first character of interest in our ciphertext.
  249. In this case, "e" will replace the underscore to
  250. produce (E,U,e).
  251.  
  252. Again, this character based coordinate needs to have
  253. the vowels replaced with numbers. We reference the base
  254. (the sorted one-dimensional template used previously)
  255. and determine that the coordinate should be (1,4,6).
  256. Not surprisingly, we discover this position in our
  257. decoding grid to be "I" which is the first letter in
  258. the word "In."
  259.  
  260. We may pass over the characters "n th" as we did when
  261. encrypting since they are uninteresting to us. Now we
  262. need to decode the "A" following the "th." The
  263. character coordinate needs to be modified such that the
  264. "e" is replaced with "I" since that is its decoded
  265. value to become (E,U,I). Next, the "A" should be
  266. appended and the "E" dropped to maintain our three
  267. dimensions.
  268.  
  269. With the coordinate now reading as (U,I,A), we may now
  270. transform those vowels into the index positions from
  271. our base. From there, we get the coordinate (4,2,0).
  272. When we use this to access the characters in our
  273. decoding grid, we find the letter "e" so that "thA"
  274. becomes "the" as expected. Our next coordinate will
  275. become (I,e,o) with a numerical value of (2,6,8).
  276.  
  277. All transformations will be listed as was done for the
  278. encryption section. Do not forget that the last decoded
  279. letter will replace its position in the coordinate
  280. before the next letter is appended and the first letter
  281. dropped. This will allow a consistency that will
  282. allowed continued decryption. The following log's
  283. format is ciphertext character -> character coordinate
  284. -> index coordinate -> plaintext character.
  285.  
  286. e -> (E,U,e) -> (1,4,6) -> I
  287. A -> (U,I,A) -> (4,2,0) -> e
  288. o -> (I,e,o) -> (2,6,8) -> e
  289. o -> (e,e,o) -> (6,6,8) -> i
  290. e -> (e,i,e) -> (6,7,6) -> i
  291. u -> (i,i,u) -> (7,7,9) -> o
  292. O -> (i,o,O) -> (7,8,3) -> e
  293. U -> (o,e,U) -> (8,6,4) -> a
  294. O -> (e,a,O) -> (6,5,3) -> e
  295. O -> (a,e,O) -> (5,6,3) -> e
  296. a -> (e,e,a) -> (6,6,5) -> e
  297. e -> (e,e,e) -> (6,6,6) -> a
  298. O -> (e,a,O) -> (6,5,3) -> e
  299. i -> (a,e,i) -> (5,6,7) -> a
  300. O -> (e,a,O) -> (6,5,3) -> e
  301. O -> (a,e,O) -> (5,6,3) -> e
  302. e -> (e,e,e) -> (6,6,6) -> a
  303.  
  304. While the process does not require a computer, using
  305. one to automate this process can be very helpful.
  306. Another problem one might encounter is the space
  307. requirements required by the grid constructed from a
  308. large key. Grids take up space equivalent to A raised
  309. to the power of B where A is the count of unique
  310. characters to encrypt and B is the length of the Markov
  311. chain used to index the grid.
  312.  
  313. As a result, taking the transformations of the key into
  314. a grid should be redesigned so that the encoding and
  315. decoding grids are not needed at all. Otherwise if you
  316. had 100 characters of interest and wanted to use Markov
  317. chains of length 10 (requiring a primer of length 9),
  318. you would need to construct a grid having over 86
  319. Exabytes of data. The final result of our decryption is
  320. as follows:
  321.  
  322. In the beginning God created the heaven and the earth.
  323.  
  324. Conclusion
  325. ----------
  326.  
  327. While this tutorial covered the first plaintext and
  328. ciphertext pair, the second is left as an exercise for
  329. the reader. This tutorial may also be considered to be
  330. a work in progress. If you can improve it, please do so
  331. and pass it on to the rest of your team. Though it
  332. would probably be difficult to discover the results,
  333. finding out how Merlin would respond to this would be
  334. particularly interesting to me.
  335.  
  336. A Concerned Individual,
  337. Velociraptor
RAW Paste Data