﻿

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