Additional information

Showing posts with label codes. Show all posts
Showing posts with label codes. Show all posts

March 3, 2012

An Important Message

You know things have been pretty calm this past week or so, so I thought I'd take a break from talking about myself and do something I'm substantially better at: talking about all of you.  Well perhaps that isn't completely accurate, but this is about something that's at least slightly relevant to or directed at most of you.  I'm talking about something that many of encounter on a regular basis: Captha codes.  You know those strings of letters that you have to type in to put your comment on someone else's blog?  They're designed to keep computer programs from posting in places where they aren't supposed to, and in general I suppose that's a good thing, although I turned my captha's off in October, and never once has a program posted here.  You know, a while ago I didn't even mind, but lately they've been getting on my nerves.  Here, let me provide some examples:

(mundona)
This is about as bad as they used to get, which is why I didn't really mind.



(redit)                                                  (stole)

Sometimes they even came out looking like real words, every now and then they would even be words relevant to the comment that I had just made.  I always found these coincidences pretty amusing.



(cooties)                                          (dablog)

And I mean come on, how could you not laugh at a few of them.








(slain. t(r or i)v(I think that's an e followed by a v, maybe)I(not i, I, evidently there's a diffrence now))

But evidently they got tired of being laughed at, and google edited the captha's to prevent human posting as well.


(astere(t or i)(d or l) souls,(" or '', yes there is a diffrence))

It's very irritating trying to figure out what goes on in those blotches.





(usuldo What)

Eventually the codes were later re-edited to allow humans to post again, though still not as easily or entertainingly as before.  "What" indeed, this is actually on of the easier ones.


So yeah, sorry if I got a little whiny there, but it really is easy to turn those things off (just go to "Settings", then "Comments", go down to "Show word verification for comments", and select "No," it's quite simple), and it makes commenting around far less frustrating.  That's all I have for this post, but I really don't want to leave it at this.  I know, how about a song with a tangently relevant title and completely unrelated lyrics?  No, I don't particularly care that it doesn't fit the theme of the whole post, I like the song.



See you around
Cage

December 1, 2011

Just a bunch of 1's and 0's

Yes that's right, it's time for another lesson in building and breaking code, and this time I thought I'd try tackeling binary.  Binary appears to be a superisingly common encryption technique in this communitty, possibly due to the fact that it is an extremly difficult (or more accuratly time consuming) code to crack manually, even if you know binary, but also one that is realitively simple to make or break if you have easy internet acess.  Another possible explination is that, in purely abstract terms, binary is actually more basic than regular lanuage.  Binary runs off of a simple yes or no system, it only uses two symbol 0 to represent no, and 1 to represent yes, each segment is usually eight units long (though there are some less common variations), and can be translated into a letter or symbol based off of the number and placement of the 1's.  Technially speaking, this is all you need to know to decode binary logically, but I'll get to that later.  The point is, that becuase binary only ever has eight arguments at a time, it can easily be seen as the next logical step down from rational thinking, which may be at least partially responsible for its semi-common use by people that are experinceing the mental breakdown associated with becoming "hallowed".

While most people belive that binary is "computer code", and are, for the most part, correct, binary code as we understand it was actually first concived in the 1600's by the German mathmatician Gottfried Leibniz.  Leibniz belived that all of logic could essisientially be broken down into yes or no statements, and created a system of ones and zeros to represent this.  Though this system had little to no practial uses at the time it is the first example of a system that repersents binary code as we know it now.  I'm aware that you probably don't just come here for history lectures, so I'll skip ahead, however it is always important to note binary's origin as a system logic that predates computers.  There are plenty of binary translators online, and I would recomend using those rather than trying to memorize actual binary code (while binary is relatively easy to learn, decodeing it manually is more time-consuming than trusting a website).  However, you may not always have a computer with internet acess avaliable when you find binary code, and there are some tricks to remember that can help you to crack these codes in such cases.  Here is a list of 52 letters (capatilized and lower cased) translated in binary, which I will refer back to for cracking techniques. 




Letter
Binary Code
A
01000001
B
01000010
C
01000011
D
01000100
E
01000101
F
01000110
G
01000111
H
01001000
I
01001001
J
01001010
K
01001011
L
01001100
M
01001101
N
01001110
O
01001111
P
01010000
Q
01010001
R
01010010
S
01010011
T
01010100
U
01010101
V
01010110
W
01010111
X
01011000
Y
01011001
Z
01011010

Letter
Binary Code
a
01100001
b
01100010
c
01100011
d
01100100
e
01100101
f
01100110
g
01100111
h
01101000
i
01101001
j
01101010
k
01101011
l
01101100
m
01101101
n
01101110
o
01101111
p
01110000
q
01110001
r
01110010
s
01110011
t
01110100
u
01110101
v
01110110
w
01110111
x
01111000
y
01111001
z
01111010


For the record a blank space " " is represented by 00100000, which shouldn't be suprising if you've noticed the pattern by now.

Before I get into the lists I want to note that even if you don't remember any of these tricks that you can still crack a binary code logically the same way you code a cipher as long as you treat each segment of eight numbers as an in individual letter and work from there (to help you should probably identify all of the eight segment sets and replace them with an aarbitrary number right away).  One of the first things you should notice is that all of these numbers begin with the pattern "01", which is actually quite useful when manually decoding something.  Logically there are only four possible ways for the first two digits of a binary pattern to be arranged: "00", "01", "10", "11", and if a segment of eight letters begins with any of the three crossed out patterns than you aren't dealing with a letter at all, and shouldn't bother trying to translate it  (though for the record all numbers begin with "0011") (also it should be noted that there are actually four symbols at the end of the spectrum that begin with "01", but they are rarely used).  The next thing you might notice is that the only diffrence between the capatilized and lower case letters is that wirh lower case letters there is a "1" in the third spot, and in the capatilized versions ther is a "0".  This draws attention to the fact that the first three digits can basiclly be ignored once you've checked to make sure what you're translating is actually a letter.  In case you didn't notice from the chart, the placement of the "1"'s and "0"'s is actually quite predictable after that: "00001"=a, "00010"=b, "00011"=c, and so on.  The letters start at the bottom of a scale, as the letters increase the "1"'s gradually work their way up towards the top.  And once they "fill up" the places below them, a new one forms at the top, and the places get filled in exactly the same way they did before.  For example: "00111" (which equals g) is followed by "01000" (which naturally equals h).  If you can remember this progression than binary code is actually quite easy to learn, and can be decoded with realitive ease.

Now this will probably be my last full blown post for a while, as this past week a cooling fan in my computer broke, and I want to get that fixed so I can run more energy comsuming programs without it overheating.  And since I don't want to log onto this account through public computers I won't actually be able to put anything on this blog, however I will probably still leave a few comments here and there through the nice Name Only feature on the blogs that have Anonomyous comments enabled.  Then, after next week I have finals, which means lots of essay writing and studying for my various classes, so even if I have my computer back I probably won't have the time or energy to update this thing.  Admitadly you all have your own concerns, and I'm likely not a major one of them, but this way you don't have to worry about checking back for new material inbetween all of your other various happenings.


See you around
Free

November 12, 2011

The oldest trick in the book

Hello again, everyone, I'm sorry I haven't been posting more, but sometimes it is difficult to find the time to sit down and focus on a single subject for a while.  In fact, I still have to record the results of that last poll, update my return post, and begin work on a case study I'm preparing.  But you aren't here to listen to me talk about the things I need to do or my excuses for not doing them, and because my actually useful tag is getting a shameful amount of work I thought I would give a basic tutorial on basic codes, specifically the Caesar's Cipher.

The Caesar's Cipher was so named because it was used first and most famously by none other than the great Roman Emperor: Julius Caesar.  Caesar would, when writing information he wished to keep a secret, shift all of the letters in his message right three times, for example A==D, B==E, and so on, with letters at the end of the alphabet wrapping around to the front ( X==A, Y==B, Z==C).  While this is infamously the most simple code out there, it worked quite well for Caesar, as many of his enemies were largely uneducated and the whole idea of encryptions was not widely used.  However, today it is embarrassingly simple to crack a Caesar's Cipher, though it can be admittedly time consuming if you lack the proper tools, as letters can be shifted as many times as the user chooses (up to 25, of course, for obvious reasons), though the most popular shift seems to be one of 13, so if you think you are dealing with this kind of code you should probably start there.

Of course shifting a letter over two or three (or even 13) places in the alphabet isn't likely to fool anyone for long, and to overcome this problem the Cipher has evolved over time.  One of the most successful ways of making a Cipher more difficult to crack for your enemies is to include a key in your encryption.  This means that instead of simply shifting letters over through the alphabet you use a phrase or other reference point to shift the letters to seemingly random other letters, so the shift is no longer completely liner. If the key is "The quick brown fox jumps over the lazy dog" (which is a convenient phrase at it contains every of letter in the English language) than you could use it one of two ways.  First you could shift the letters within the phrase over on top of each other, so that within the encrypted message T==H, H==E, E==Q and so on, leaving an encrypted message looking like this: "Heq Uickb Rownf Owj Uipso Wlqo Heq Azyd Gwt"  Ovbiously, this looks far more confusing if you aren't encrypting the actual key, but for teaching purposes it should be sufficient.  The other option is to use the key itself as the basis for coding the alphabet, and then adding extra shifts as needed, for example:

T H E   Q U I C K   B R O W N   F O X   J U M P S   O V E R   T H E   L A Z Y   D O G
A B C   D E F G H   I J K L M   N K O   P E Q R S   K T C J   A B C   U V W X   Y K Z

To avoid unnecessary confusion already used letters in the key were struck through, as were their translated counterparts.  As you can see, this makes cracking a keyed cipher far more challenging.  However, while it is no longer possible (or at least no longer feasible) to crack a keyed cipher through a brute force application (randomly testing all combinations of matchups until one that works is discovered) these can still be overcome logically, even without the key.  What is most important to remember when cracking a keyed Cipher (I am running largely off of memory and personal experience here, so I'm no longer sure that these examples qualify as strict Caesar's Ciphers, but they are close enough that I will cover them a bit further) is that English is a structured language.  There are many letters that will appear together very commonly, and other letters that appear only rarely.  If you are having trouble with some of the letters in a specific word it may help to make note of where within a sentence it is, that could narrow down the words purpose or meaning, and make it clearer what the letters within could be; this is where knowing the writing style of the coder can be very helpful.  Finally it helps to make a list of as many two or three letter words as you can think of, as these will be the easiest to crack, and will often give hints as to what some of the letters in the other words are, and make them easier to crack as well.  Needless to say, one letter words should be quite easy to crack as well.  All in all the longer a keyed Cipher is the more chances someone has to crack it, which is something to keep in mind when you are making your own.

That's all I have on Ciphers for now, though I will probably explore other kinds of codes in the future.  In fact you can make a cipher even more difficult to crack by stacking it on other codes, but this post is long enough, so that coding strategy will have to wait for its own post.  Now I must go update my return post, so until next time


See you around
Free