"TheGiant" Cipher

[Shootinfish]

I made a chart that basicly chops the 8 bit ASCII into the four six bit segments. At the top of the chart is space, there is no character for it

ASCII  |8 bit  |      |Block1|  |Block2|   |Block3|   |Block4|
  
32     00100000       001000     000010     000000     100000 

Base64 index               I                C              A               g

Can we draw any information on the fact that uppercase "I" is one of the disputed characters and maybe some position data i dont know just a thought

Here is the chart anyway i hope its correct sorry the formatting is all wonky it should copy and paste ok though

Spoiler

                                        

ASCII |8 bit  |      |Block1|  |Block2|   |Block3|   |Block4|
  
32     00100000       001000    000010     000000     100000                                             
33  !  00100001       001000    010010     000100     100001                                        
34  "  00100010       001000    100010     001000     100010                                        
35  #  00100011       001000    110010     001100     100011                                        
36  $  00100100       001001    000010     010000     100100                                        
37  %  00100101       001001    010010     010100     100101                                        
38  &  00100110       001001    100010     011000     100110                                        
39  '  00100111       001001    110010     011100     100111                                        
40  (  00101000       001010    000010     100000     101000                                        
41  )  00101001       001010    010010     100100     101001                                        
42  *  00101010       001010    100010     101000     101010                                        
43  +  00101011       001010    110010     101100     101011                                        
44  ,  00101100       001011    000010     110000     101100                                        
45  -  00101101       001011    010010     110100     101101                                        
46  .  00101110       001011    100010     111000     101110                                        
47  /  00101111       001011    110010     111100     101111                                        
48  0  00110000       001100    000011     000000     110000                                        
49  1  00110001       001100    010011     000100     110001                                        
50  2  00110010       001100    100011     001000     110010                                        
51  3  00110011       001100    110011     001100     110011                                        
52  4  00110100       001101    000011     010000     110100                                        
53  5  00110101       001101    010011     010100     110101                                        
54  6  00110110       001101    100011     011000     110110                                        
55  7  00110111       001101    110011     011100     110111                                        
56  8  00111000       001110    000011     100000     111000                                        
57  9  00111001       001110    010011     100100     111001                                        
58  :  00111010       001110    100011     101000     111010                                        
59  ;  00111011       001110    110011     101100     111011                                        
60  <  00111100       001111    000011     110000     111100                                        
61  =  00111101       001111    010011     110100     111101                                        
62  >  00111110       001111    100011     111000     111110                                        
63  ?  00111111       001111    110011     111100     111111                                        
64  @  01000000       010000    000100     000001     000000                                        
65  A  01000001       010000    010100     000101     000001                                        
66  B  01000010       010000    100100     001001     000010                                        
67  C  01000011       010000    110100     001101     000011                                        
68  D  01000100       010001    000100     010001     000100                                        
69  E  01000101       010001    010100     010101     000101                                        
70  F  01000110       010001    100100     011001     000110                                        
71  G  01000111       010001    110100     011101     000111                                        
72  H  01001000       010010    000100     100001     001000                                        
73  I  01001001       010010    010100     100101     001001                                        
74  J  01001010       010010    100100     101001     001010                                        
75  K  01001011       010010    110100     101101     001011                                        
76  L  01001100       010011    000100     110001     001100                                        
77  M  01001101       010011    010100     110101     001101                                        
78  N  01001110       010011    100100     111001     001110                                        
79  O  01001111       010011    110100     111101     001111                                        
80  P  01010000       010100    000101     000001     010000                                        
81  Q  01010001       010100    010101     000101     010001                                        
82  R  01010010       010100    100101     001001     010010                                        
83  S  01010011       010100    110101     001101     010011                                        
84  T  01010100       010101    000101     010001     010100                                        
85  U  01010101       010101    010101     010101     010101                                        
86  V  01010110       010101    100101     011001     010110                                        
87  W  01010111       010101    110101     011101     010111                                        
88  X  01011000       010110    000101     100001     011000                                        
89  Y  01011001       010110    010101     100101     011001                                        
90  Z  01011010       010110    100101     101001     011010                                        
91  [  01011011       010110    110101     101101     011011                                        
92  \  01011100       010111    000101     110001     011100                                        
93  ]  01011101       010111    010101     110101     011101                                        
94  ^  01011110       010111    100101     111001     011110                                        
95  _  01011111       010111    110101     111101     011111                                        
96  `  01100000       011000    000110     000001     100000                                        
97  a  01100001       011000    010110     000101     100001                                        
98  b  01100010       011000    100110     001001     100010                                        
99  c  01100011       011000    110110     001101     100011                                        
100 d  01100100       011001    000110     010001     100100                                        
101 e  01100101       011001    010110     010101     100101                                        
102 f  01100110       011001    100110     011001     100110                                        
103 g  01100111       011001    110110     011101     100111                                        
104 h  01101000       011010    000110     100001     101000                                        
105 i  01101001       011010    010110     100101     101001                                        
106 j  01101010       011010    100110     101001     101010                                        
107 k  01101011       011010    110110     101101     101011                                        
108 l  01101100       011011    000110     110001     101100                                        
109 m  01101101       011011    010110     110101     101101                                        
110 n  01101110       011011    100110     111001     101110                                        
111 o  01101111       011011    110110     111101     101111                                        
112 p  01110000       011100    000111     000001     110000                                        
113 q  01110001       011100    010111     000101     110001                                        
114 r  01110010       011100    100111     001001     110010                                        
115 s  01110011       011100    110111     001101     110011                                        
116 t  01110100       011101    000111     010001     110100                                        
117 u  01110101       011101    010111     010101     110101                                        
118 v  01110110       011101    100111     011001     110110                                        
119 w  01110111       011101    110111     011101     110111                                        
120 x  01111000       011110    000111     100001     111000                                        
121 y  01111001       011110    010111     100101     111001                                        
122 z  01111010       011110    100111     101001     111010                                        
123 {  01111011       011110    110111     101101     111011                                        
124 |  01111100       011111    000111     110001     111100                                        
125 }  01111101       011111    010111     110101     111101                                        
126 ~  01111110       011111    100111     111001     111110                                        

 

 

[WaterKH]

@Shootinfish Were you using the chart below? I assume so, but I'll just try it to confirm. Thought I'd ask though to save me the trouble. Ohhh, forgot you said you were just giving an example of how the bits were chopped with the three repeating letters. Gotcha, looks like that is good! Also, I don't know if you saw in the last post but I opened up a channel to foster like-minded cipher enthusiasts to get cracking away at this cipher! #TheGiant on irc.freenode.net (:

 

[Shootinfish]

EDIT //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

I got this wrong because I forgot I had used three characters in a row will have to rethink, but the idea is something to start with so I will leave it there

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Ok so im trying to prove that its not Base64 just transposed using the space

Look at the building blocks for the ASCII space Base64 index characters  I, C , A , g , and  do a frequency count on these characters

I = 02 C = 03 A = 04 g = 05 in total that is fourteen instances of them , meaning as long as there not used anywhere else and only once per space then
can only be 14 spaces

Now the difficult bit. there is and correct me if im wrong 192 ciphertext charcters and if it was converted into ASCII you only get 3 for every 4 used

So 192 divide 4 times 3 (192 / 4 )* 3) = 144 characters

Ok im guessing this bit and assuming the first word doesnt need a space so we can  add 1 to the 14 making 15
 
144 / 15 = 9.6

This gives an average word length which seems too high

I think i can do some more stats with other index characters and rule out it is encoded into standard BASE64 meaning its subsituted in some way

I could be wrong on this so check it out

I will try and get on the chat I'm supposed to be beta testing software at the moment so I'm doing this in my breaks

[WaterKH]

Okay, I think I understand fairly well - Though if you could explain these two parts that would be great:

1. What do you mean by "just transposed using the space?" I honestly don't believe there are any spaces in the ciphertext, though that's just because some of the ciphers didn't have any spaces. So that's just speculation. 

2. Where does 14 come from? 

You seem to know what you're doing though - I just find it odd that we can convert this to Base32... Though I haven't actually done that myself, someone I know did who is fairly credible when it comes to stuff like this. Though, thinking about it now, that doesn't necessarily prove that it is Base64, just that we can encode it in a different base.

The only Base I can think of that includes a-z A-Z and 0-9 as well as have "/" is Base64 though. So if not B64 what do you think it is?

[Tac]

@Shootinfish no worries :)

@vigiliisgaming I was about to post about that room you created, didn't realize you were waterkh haha! Also, you can always link the Google Doc as opposed to pasting the URL if it gets too long!

[WaterKH]

@Tac Thanks! I will definitely do that from now on! Your name seems familiar... Have you ever participated in the Do Not Believe His Lies IRC Channel?

[Tac]

3 minutes ago, vigiliisgaming said:

@Tac Thanks! I will definitely do that from now on! Your name seems familiar... Have you ever participated in the Do Not Believe His Lies IRC Channel?

I haven't, though I'm friends with Waffles and am relatively active on Reddit so perhaps you know me through one of those avenues?

[WaterKH]

Just now, Tac said:

I haven't, though I'm friends with Waffles and am relatively active on Reddit so perhaps you know me through one of those avenues?

Ahh, yeah, that makes sense then! So have any ideas on this so far? I think we are torn between whether it's Base64 or not. I'm toying around with some transposition based on the "TheGiant" key currently, not turning up much luck though.

[Tac]

Honestly I'm not sure haha. Ciphers aren't something I understand nearly as well as these fellas so I'm more or less just watching and seeing if I can offer any input, but haven't been able to yet :p

[Shootinfish]

For starters for sure have not got a clue what im doing with cipher, i only just started cutting my teeth and only worked out how the ADGFX cipher works recently, but i understand how that works fully. I do know a little about binary and bit patterns though

If your not going to use the ASCII space then i believe the count of bit patterns is wrong for standard Base64 i will have to do more checking

If your assuming like i am the message contains no spaces and is a mainly concancated string of lower case letters then

The characters with the highest frequency should be lowercase which in ASCII start bitpattern 011*****
The uppercase characters start with  01*****

There is only 38 of these Base64 index characters contained in the cipher message (can someone check this because i seem to be getting a lot wrong lately)

Now cipher text length divided by the four blocks

192 /  4 = 48     So you would need 48 min if it was a string of characters and that doesn't seem enough

Can you check but i only count 38 characters in the 01 range which isnt enough (Base64 index range | 16 -31 | Q-Z a-f | )

To throw a spanner in the works i havent looked at throwing a load of ASCII numbers in the mix starting bit pattern 0011**** or dots or something else crazy

 

EDIT /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Thought I would just try a common word to see if I can see pattern so I tried Group 935 and encoded it into Base64. I think I may have just common bit patterns but it is interesting when you highlight all the numbers in the list because there is quite a few grouped but I'm not sure it makes 100% sense

Group 935

R3JvdXAgOTM1

17 , 55 , 09 , 47 , 29 , 23 , 00 , 32 , 14 ,19 , 12 , 53

 36,02,38,37,32,05,34,58,
 06,20,09,13,32,36,13,37,
 53,16,56,53,31,27,31,50,
 11,40,02,05,19,02,47,37,
 42,36,25,34,37,14,10,37,
 00,23,00,51,15,53,20,53,
 46,50,53,01,04,56,20,31,
 15,01,31,41,10,38,38,11,
 14,27,35,24,39,16,13,17,
 01,26,15,45,10,34,21,22,
 51,28,57,00,56,47,14,48,
 55,49,37,30,60,05,14,33,
 00,06,09,25,59,32,56,34,
 39,14,48,39,29,09,49,12,
 14,47,14,55,29,28,53,12,
 60,54,26,45,54,19,58,61,
 55,57,43,40,19,42,50,22,
 03,32,45,06,03,63,33,48,
 48,17,05,55,40,07,42,05,
 12,57,21,28,48,53,09,45,
 37,13,27,44,32,22,17,38,
 56,40,56,63,42,46,04,03,
 36,25,59,49,53,01,54,59,
 57,27,23,55,63,05,40,53,

[WaterKH]

@Shootinfish I don't know-  it could be a short message... But anyways, I'll check on the bits right now and edit this post once I have the results!

[Shootinfish]

Cool I will add this image of Group 935 with all the occurrences  marked , sorry there all the same colour I only can mark with 5 color styles , maybe I can edit the notepad++ xml file to give me more colours , does anyone know ?

[WaterKH]

7 minutes ago, Shootinfish said:

Cool I will add this image of Group 935 with all the occurrences  marked , sorry there all the same colour I only can mark with 5 color styles , maybe I can edit the notepad++ xml file to give me more colours , does anyone know ?

 

So... I'm a little confused. I understand the breaking down the text into Base64, but then wouldn't we be looking for that entire string instead of bits here and there?

[Shootinfish]

It most be transposed in some way so I am guessing this is what it will look like before its transposed if its just all the correct Base64 characters just scrambled

What i tried to do is a crib that uses a common word or phrase and looked for a pattern to be transposed so the string was assembled correctly

You are right there would be a more logical pattern to assemble the string together like if there where just in different columns. sorry i dont really know checkerboard transposition so that is why i posted it to see if it made sense because i got a lot of individual bits grouped some in the same row

Maybe i got it wrong on how this is ciphered sorry like i explained its kinda of new to me and i hope everyone dont mind me experimenting and posting ideas

[WaterKH]

@Shootinfish Oh, of course not! My apologies if I came off strong! (: It's good that you tried it! Since you have it pulled up and everything, can you try using "the" as a possible try? That is probably the most frequent word and I'm sure it's a good one to try and see if your theory works with.

[Shootinfish]

No worrys i will try the and see if i can test the diagraph Th somehow

I had a quick messaround to see what column transposing works on Base64

Divison9 Has There Own Test Subjects Send Help!!

Encode into base64

RGl2aXNvbjkgSGFzIFRoZXJlIE93biBUZXN0IFN1YmplY3RzIFNlbmQgSGVscCEh

Split into 4 columns

RGl2
aXNv
bjkg
SGFz
IFRo
ZXJl
IE93
biBU
ZXN0
IFN1
Ympl
Y3Rz
IFNl
bmQg
SGVs
cCEh

Assign the keyword "ring" transpose into  a-z

 

2GlR
vXNa
gjkb
zGFS
oFRI
lXJZ
3E9I
UiBb
0XNZ
1FNI
lmpY
z3RY
lFNI
gmQb
sGVS
hCEc

You could transpose again by row here with a joined keyword like ringzero using first four for column and next four for row

2GlRvXNagjkbzGFSoFRIlXJZ3E9IUiBb0XNZ1FNIlmpYz3RYlFNIgmQbsGVShCEc

Decode using base64 decoder

٩Q޳Z¹͡RTHֲYݏHR [ҳYՓHתXдXՓHäѥRġ

That was just a quick five minute mess around but you get the idea

[WaterKH]

Yeah, I tried that originally with TheGiant (The transpose part) but no luck there. Just get some garble. I'll look into some more things you can do with keys when I get home.

[Shootinfish]

Now i going to post this incase someone finds this useful , this is from the above cipher i just made up i picked the word "Has" and it is lined up with the spaces because i just converted "Has" to Base64
and split into 8 columns to see how that transposed

As you can see it didnt do a very good job and all the letters are in a row just not in the right order

Now you asked to look for the word "the". If i was ciphering for 3arc i would make sure the spaces did not line up like they have above and finding "the" would be more difficult

For example i will encode "Own" which is T3du now there is not a "T" in the cipher text meaning it is encoded in a different bit pattern. So i try and find it. I have the non transposed version so i can just count the bits

 

As you can see its Ow then a space encoded into IE93 then n space T  encoded into  biBU

The column transpose really didn't work has anyone got any ideas how to obfuscate more with column transpose , is it because I did not use enough letters and short message length or is it because Base64 is in packets of 4 blocks or is it all of these reasons. I know its a bit stupid making my own cipher but  sometimes you can learn things by doing so. I'm going to finish up with running some frequencies and seeing if anything shows up with the ratios in the range and will post again if I find anything

[WaterKH]

Not really sure... I just tried converting to Base64 the key and then column transposing that, but no luck.

[Shootinfish]

I edited this after an avalanche of mistakes its just really confusing going from 6-8 bit

 BASE64 letter "t" bitpattern 101101 , theres a count of 4 of the character "t" in TheGiant cipher text. So i look to see what ASCII characters that bitpattern can make. 6 characters

[      -      k      K            m       {

 

 

[WaterKH]

Sounds good to me. It's interesting seeing these bit patterns, definitely worth working on. 

Also, I worked on this a while back, just updated it slightly but I created a Vigenere cipher creator and a frequency counter as well as a "map to column" function. I'll just put it below. I created it in Java on the Eclipse IDE, so if you have the IDE I'd recommend trying it! If it's not intuitive, I can make it better!

GitHub Link: https://github.com/WaterKH/TreyarchCodes-Ciphers/tree/master/LetterDistinguishing

[Shootinfish]

@vigiliisgaming i will check that out, i be honest i have little to none programming skills and java is language i am least familer with but i will have a look

I am trying to work on space and its melting my mind please someone help me out :).What im trying to do is find all the bit patterns that space will use in every block position so i can do a frequency on the base64 index characters and 1. count how many there are 2.try figure out some spacing

I know i did this in an earlier post but i got my calculations incorrect

First 3 ASCII spaces in a row

 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 |
    0     0     1     0     0     0     0     0     0     0     1     0     0     0     0     0     0     0     1     0    0      0     0    0

Block 1 (bit 01-06)   001000 
Block 2 (bit 07-12)   000010
Block 3 (bit 13-18)   000000
Block 4 (bit 19-24)   100000

I am sure I am missing something, is this all the bit patterns for space in each block position ?
If so i have the frequencies in the cipher using the base64 index letters converted from the binary  can you check them ?

||Uppercase A = 4 || uppercase C = 3 || Uppercase I = 7 || Lowercase g = 5 || 4+3+7+5= 19 in total max amount of spaces

I am not sure how to get an accurate average word length but if its Base64 >> ASCII then it will use 75% of the characters and i calculate that to be 144. Does that sound reasonable to have 19 spaces in 144 characters ?

If not the only route i have is there are coordinates with dots "." in the deciphered text or its not scrambled base64 but subbed

 

[WaterKH]

I would think then that it's substituted Base64. I personally think Vigenere would be the way to go, but I'd have to do some more research and testing with it to know for sure. 

Also, this is really impressive, good job!

The program I made is completed, you would just need to open the program in the IDE and then run it and follow the commands given. (: If you'd like I can do it for you just so you simply have to run it. Or I can compile it into a program... I've never done that before so it would be good experience for me!

[certainpersonio]

That's where I'm at too. I believe there is a substation involved. I don't think it's mono alphabetic because I tired all the alphabets I posted in my spreadsheet and got nothing. There are all sorts of variants of those though, so ruling out 5 alphabets doesn't prove it's not a mono alphabetic. Anyways I've moved onto polyalphbetic stuff, and I'm just not sure where to go. Vigenere has been promising, but when I've tried, it doesn't create legible plaintext. 

[WaterKH]

I think it is Poly- but not sure exactly what to do with the Vigenere... I've created this .jar file for distribution @Shootinfish if you'd like it. Simply open your terminal (Or command line if you are using Windows) and type in "java -jar [name-of-jar]" with this .jar file I'm attaching. Now, I may have set this up wrong, I've seen both ways, but how is a Vigenere square's first row set up? If we have A B C D .... do we start on the first row A B C D .... or B C D E... ? Anyways, it will ask for an alphabet, which I will provide as well as a key. The key is just for column sorting currently, but I can make it find the correct row to perform the substitution if you'd like! Class time now, but I'll be back in a couple hours. 

Also, make sure the alphabet.txt is in the same place as the LetterFreq.jar. NOTE - Do not include extensions when inputting alphabet to use.

alphabet.txt

LetterFreq.jar