more on the return function


In this section I will explain the need for file encryption


Encryption may seem unnecessary, but it is actually very useful. Encryption can take a file name or a text, and reduce or increase the size and convert it into an unreadable text.

There are many different ways to encrypt files and many different encryption styles. in this section we will discuss "MD5". "MD5" stands for "message digest 5". What

encryption style does is, it takes a message or text and converts it into 128-bit hash

Encryption will help protect you and your personal information from unauthorized users(hackers). What hackers can do with your iformation is

  1. steal and sell SSIDs
  2. steal money
  3. open credit cards in your name
  4. sell personal photos to others
  5. and much more

let's view some "MD5" code and i'll explain it as we go:

So what we have here is an encryption code using "hashlib.MD5" or better know as "MD5". In the first line what you have is a function named "enc_wrd".

What the first line is saying is to basically encode the word input in 'utf-16'. 'utf-16' stands for "16-bit Unicode Transformation Format".

might sound coplicated, but it isn't, all it means is that it will take the "word" input and transform it into a 16-bit unicode.

This is what a "utf-16" looks like:

So what happened in "enc_wrd" is, it took my word input("word") and encoded with "utf-16". Can you guess what the original text was? Its actually not that hard

This is the original text


do you see the original text now?

you might be thining, "well that's not a very strong encryption". Well that's where line two comes in.

line 2:

What this is, it encrypts it again... but why? We'll get into that in the decryption part. This line is where the "MD5" magic happens.

takes the word input from above and encrypts it after it was already encrypted using "utf-16". Now the outputs are very much different.

This is where the 128-bit output is... well outputted(is "outputted" a word?). The 128-bit text is completely unreadable.

This is the "MD5" output:


Bet you can't guess the original text now! It's the same output as before. You can't tell because it's original text has been encrypted twice.

Now, as previously stated, it cannot be decrypted. Or it cannot be decrypted from the second encryption.

I double encrypted it so that you could decrypt it. You might be thinking "well that makes no sense". But in order to decrypt it, I had to emprovise since I couldn't decrypt the "MD5".

But could decrypt the "utf-8" and get the original text



You might be thinking, "Well how do we decrypt a double encryption that has the second part encrypted with an encryption that can't be cracked?!"

It sounds complicated but it's actually quite simple. We will start with the first decryption line.

first line:

As you can see, we are encrypting it, but we are only encrypting the first part which is the "utf-16" because it is able to decrypted.

If you decrypt it at the first encryption, you can get the original text.

If you try to decrypt it from the second line, the line where it encrypted using "MD5" you will get in error because it is unnable to be decrypted.

we attack the orginal text at the first encryption. That's why we double the encryption.

But if you're familiar with programming, you cannot do anything with the given line unless you define the word "decode" that you see in the given line.

we will start with the defining.

Make Sure That You Define the Function Before You Make it!

first line in defining:

As you see, we define a function called "decoding", and "decode" and "encode" because they are going to be a part of the "decoding" function.

Next, you want to return decode back to it's caller "decoding", with two simple words "return decode".

To learn more on the use on the "return" function, click the link in the link section labled "more on the return function":

Returning decode:

See, just two words, "return decode", it's that simple.

Next, you want to create a function with the "decoder" inside decoding, right under "return decode".

function "decoder":

As you see, once you've returned decode, then you decode your input at "word"

See, it's simple, like I said!

Using what you just learned to hack

Now that you have a full understanding of encryption and decryption, we can start explaining how to use the decryption you just learned, to hack.

All of the encryption and decryption things you learned up there, was a test run that I built for my hack.

so now we will test it!

This is a certificate of security:

I pulled this certificate from a websute posted on '', and at the bottom you can see sha1 and sha256 encryptions.

These are encrypted for a reason, and for those reasons I am not going to show the decryption. So if you're looking for tht you won't find it here, but i will tell you how I got it.

So, decided to make a sha256 encrypter myself and practice decrypting the output using various different methods.

So, what you want to do is start out with a simle input code, and then define the length of the message input.

Input code + length code:

Alright, so moving on, after you've done that, you want to turn your maessage int binary

I found that when I turned my message into binary it helped the decryption alot

Binary code lines:

If you see where i'm going, i'm building my own sha256 encrypter piece by piece so that I can analyze it to get a better understanding of the hack before I do it, and so that I could explain it better to you guys.

The next step is to create a 512-bit message block by padding.

The 512-bit message converter:

The next step is to break the 512-bit message block into a 16 32 bit blocks so that each block is = 32-bits

512-bit breaker:

Next, what you wanna do is declare the initial hash values to be used and append it.

Declaring hash values and append:

second part:

Next you want to define 6 different logical functions that are used for hash generation.

First logical function:

Second logical function:

Third logical function:

Fourth logical function:

Fifth logical functin:

Sixth logical function:

I'm zooming through this because right now i'm just building a sha256 encrypter piece by piece, because i have to test the decryption code before I actually try do decrypt the actual the sha256 fingerprint.

So the next and final step is to generate the print


Now that i've written the code, i can implement my decrypter(or decoder), it's a decoder, and yes there's a difference

So, I accessed the point where the sha256 encrypted fingerprint was encrypted and I enabled local overides and overrided it


Once I did this of course i had to convert my code into java-script, i'm lazy and had not written a single java-script code line in so long before this, so I knew a compiler that would do this for me so i'm sorry, but that's what i did.

I then input my code into my local overrides and directed toward the sha256 encrypter and decoded it

To see my full code, click the link labeled "file encrypter" file encrypter