Introduce to Advanced Encryption Standard

INTRODUCE TO AES

From G and Wiki, I knew a little bit of AES. For learning purpose, I rewrited it.

Advanced Encryption Standard is known by its original name Rijndeal. It have some features:

•            Each cipher block have 128-bits length.
•            There are 3 key size: 128, 192 and 256 bits length.
•            There are many mode of AES such as: Electronic CodeBook, Cipher Block Chaining, Cipher FeedBlock, Output FeedBlock,Counter.

With very mode, it have some special features, which unsecure and secure. But, today I just introduce to some basic terms.
Let's me see.. first terms is Initialzation Factor (IV).

Read More →

03:09

Cryptography

[CRYPTOPALS] How to Breaking repeating-key XOR

For 3 weeks, It's time that I have solved this challenge! I though I would fail because my english was very bad and challenge, hints was writed by english.

Now, let's see what we have?
   I found some things good by google:

         1st:
The hardest exercise in the set by far, despite the problem description giving you a clear set of steps.
Use the length-normalised Hamming distance to guess the keysize. Contrary to the instructions which kinda indicate you need only consider the first and second blocks, I had to take the average normalised Hamming distance from the first block against all the others.
Break the input into blocks of keysize length, transpose them into a much smaller number (keysize) chunks (ByteString.transpose does the trick), crack each chunk using the code written for #3, concat the keys for each chunk. Done.

                2nd: Matasano Solution

            and so on...

Review the problem of challenge:

     
There's a file here. It's been base64'd after being encrypted with repeating-key XOR.
Decrypt it.

And hints:

Here's how:

1. Let KEYSIZE be the guessed length of the key; try values from 2 to (say) 40.
2. Write a function to compute the edit distance/Hamming distance between two strings. The Hamming distance is just the number of differing bits. The distance between:

   this is a test

   and

   wokka wokka!!!

   is 37. Make sure your code agrees before you proceed.
3. For each KEYSIZE, take the first KEYSIZE worth of bytes, and the second KEYSIZE worth of bytes, and find the edit distance between them. Normalize this result by dividing by KEYSIZE.
4. The KEYSIZE with the smallest normalized edit distance is probably the key. You could proceed perhaps with the smallest 2-3 KEYSIZE values. Or take 4 KEYSIZE blocks instead of 2 and average the distances.
5. Now that you probably know the KEYSIZE: break the ciphertext into blocks of KEYSIZE length.
6. Now transpose the blocks: make a block that is the first byte of every block, and a block that is the second byte of every block, and so on.
7. Solve each block as if it was single-character XOR. You already have code to do this.
8. For each block, the single-byte XOR key that produces the best looking histogram is the repeating-key XOR key byte for that block. Put them together and you have the key.

This code is going to turn out to be surprisingly useful later on. Breaking repeating-key XOR ("Vigenere") statistically is obviously an academic exercise, a "Crypto 101" thing. But more people "know how" to break it than can actually break it, and a similar technique breaks something much more important.

OK. Let's begin to break it!

Firstly, I try to find keylength of the key. Thank to Google.com.vn, I wrote a snippet to do it:

 This snippet I use to find hamming distance:
   

 and it is use to find normalize to determine which is keylength of key:

Run this snippet which random *keysizeMax*, I will get a probaly keysize.

      
2
2.25
-------
3
2.8333333333333335
-------
4
3.625
-------
5
2.6
29
2.8189655172413794
-------

Then, I just try one-by-one keysizes, I try to look up which keysize include english character, it's extractly keysize. In this case, the extractly keysize is 29.

 T
Ibhcl na ro
ncemmoiavano pt1dhgn an'  euY hbo.oxaa ef ygeyoar
hd
o e bc  n'ueoanteraayo yio
btdc,

Run `seq ` to brutefore key, we see T is match, next to second character of key.. we got e 

e
'eis adnnuuiM'a nelnsen'nol - yi
k shtrton ln mi nI rGihr  romSt YwiaYoaal  r,mry  yyy 
 emPohe,

repeat it to 29.. we will get full of key: "Terminator X: Bring the noise".

Read More →

09:51

[Algorithms] INSERTION SORT

 INSERTTION SORT

 

According to Introduce to Algorithms, I coded a small program to solve Insertion sort problem! I present to you below:

Firstly, Let's see what the problem is?

                   Input: A sequence of n number <n1, n2,..n>

                   Output: A reordering <a'1, a'2,...a'n> of the input sequence such as a'1 < a'2 < a'3 <.... < a'n.

Next, What does pseudocode illustrate?

Trying to analyze it...
          Let "j" from 2 to length of A, "j" start at 2 caused by "j" is index of wrong array A, we set the index is 2 as a key to compare with the others.
          Call a variable "i" as explorer. It'll point to address of each member in array to find which is smaller from "j-1" to "1". If the previous char is smaller than the posterior one, they will be exchange each other. After that, set the next wrong of array to be a key and continue! Easy.

This is my code in C programming language :

Read More →

06:33

Algorithms