Tag: encryption

Hello everyone,

Michael here, and in today’s lesson, we’ll explore Python encryption, SHA style.

What is SHA encryption? SHA stands for Secure Hash Algorithm, and it is what’s known as a cryptographic hash function. The SHA algorithms were developed by the US National Security Agency (NSA) and published by the National Institute of Standards and Technology*. SHA is also not a symmetric-key or an asymmetric-key algorithm, as the main purpose of SHA is data security and integrity, not encrypting/decrypting communications.

Now, let’s dive into some SHA coding!

• *The National Institute of Standards and Technology is an agency under the US Department of Commerce.

Types of SHA hashing functions

There are five different types of SHA hashing functions. Let’s explore each of them:

• SHA-256-This hashing function will produce a 256-bit hash
• SHA-384-This hashing function will produce a 384-bit (or 48-byte) hash
• SHA-224-This hashing function will produce a 224-bit (or 28-byte) hash
• SHA-512-This hashing function will produce a 512-bit (or 64-byte) hash; because of the long hash output, this is seen as one of the more secure hashing algorithms
• SHA-1-This was the first SHA hashing function developed by the NSA and produced a 160-bit (or 20-byte) hash; however, this algorithm was found to have many security weaknesses and was thus phased out after 2010

Encrypting text, SHA style

Now that we know about the five different types of hashing functions, let’s see how they work on a text string in Python!

First, let’s import any necessary modules!

import hashlib

The hashlib module will be the only one we’ll need for this post. No need to pip install it since it comes built-in as long as your Python version is 2.5 or higher (and Python 2 has long since been sunset).

Next, let’s set the text we’ll use along with the SHA-256 hash of the text:

text = 'Michaels Programming Bytes: Byte sized programming classes for all coding learners'

SHA256 = hashlib.sha256(text.encode())
print(SHA256.hexdigest())

9854a9d55046c36afafbe47cbaa21ab85c8137d81955c3e344d76156a636a66b

As you see here, we used the name and tagline of this blog for our SHA demonstration. For our SHA encryption, keep these two methods in mind-.encode() and .hexdigest()-as we will use them throughout our demonstrations of the SHA hashing functions.

The .encode() method encodes the text string into a hexadecimal hash while the .hexdigest() method will display the hexadecimal hash.

• Also, if you want to learn more about or need a refresher on hexadecimal numbering systems, check out this post from February 2019-https://michaelsprogrammingbytes.com/java-lesson-5-java-numbering-systems/ (yes I know it’s a Java lesson but it still explains the basics of hexadecimal numbering).

As you can see here, we have generated a SHA-256 hash from our text with just two lines of code!

Now, if your curious what the decimal number of this hash equals, let’s check it out for fun:

68901140284153216712479841246928981776103555384517524587226404491787878442603

It’s a large, 77-digit number that’s roughly 68 quattuorvigintillion (this is a number followed by 75 zeroes). Quite a big number to come out of that hash!

Next, let’s try the SHA-384 encryption method:

SHA384 = hashlib.sha384(text.encode())
print(SHA384.hexdigest())

2777dfcb92166aa95f0796e3ed4edc12d7da9db3226c8831b40aca5576e8aafa106bb26b3eafe07fc9124238e5e7a6be

This time, we appear to have gotten a larger hash than we did from the SHA-256 function. What could be the decimal number of this hash?

6074720975275609937364706669124284930019665411073401970740713484318034757229843193804707918050212936621238163842750

Now, this number is even larger-it’s approximately 6 septentrigintillion (this is a number followed by 114 zeroes). I honestly never even seen such massive numbers, but as a numbers guy, massive numbers are fun to learn about!

Next, let’s try the SHA-224 method:

SHA224 = hashlib.sha224(text.encode())
print(SHA224.hexdigest())

8ed6b6c67f8f543d41472f2b0da146516cc6e28a20637d4fc3018518

Since SHA-224 uses less bits/bytes than the SHA-384 and SHA-256 functions, it makes sense that the generated hash would be shorter than the hashes generated from those functions.

I imagine that the decimal number would be shorter too:

15042673619469762912744046603652644639808686980332500102671983805720

Not surprisingly, the decimal number from this hash is also shorter, but still fairly massive-it’s approximately 15 unvigintillion (a number followed by 66 zeroes).

Next, let’s try the SHA-512 method:

SHA512 = hashlib.sha512(text.encode())
print(SHA512.hexdigest())

8d42047543b1bea09199838101c6ba0b5fb5d2631c1bb9b772333f2faa51b7cd0c53946e79758475929244d33e02b8e8cd994d79c63747ffdeeec3d6e9a66719

Since SHA-512 generates the largest hashes of all the SHA hashing functions, it’s not surprising that the generated hash is so large.

With a hash so large, I can only imagine what the decimal number would look like:

7398275510411850389223316484636795314726283670587045768118856918282820596862752633935810532260756989519458279298581715671072351034597240609479775136147225

The number above is approximately 7 quinquagintillion, which sounds like a word Dr. Seuss would make up, but it’s a number followed by 153 zeroes.

Last but not least, let’s try the retired, and original, SHA hashing function on our text-SHA-1:

SHA1 = hashlib.sha1(text.encode())
print(SHA1.hexdigest())

5ed4ecb61ff2323823781c514cbe2181e034a186

Since the hashes generated from the SHA-1 function use the least bytes (20) from the five functions we explored, the generated hash would also be the shortest of the five hashes we’ve generated.

With that said, it won’t be surprising that the decimal number of this hash is also fairly short:

541393510912863704690262334257797793251671187846

Even though this number is shorter than the other four numbers we got from the other four hashes, it’s still fairly massive-541 quattuordecillion (a number followed by 45 zeroes).

All in all, we got to see the power of SHA hashing functions through some simple text encryption. The massive decimal numbers we got from each of the generated hashes put the power of the SHA algorithm into perspective (plus, I had fun exploring massive numbers).

An interesting application of SHA hashing algorithms

Before we go, I wanted to explain an interesting application of the SHA hashing algorithm-Bitcoin mining. Yes, Bitcoin mining utilizes the SHA-256 algorithm during the mining process-this is because SHA-256 is both computationally efficient and offers a good deal of security throughout the process. Granted, SHA-512 could also offer a great deal of security, but the hashes also take up a lot of memory.

So, how would one mine Bitcoin? Check out this illustration below for an explanation:

For a very simplistic explanation of Bitcoin mining, a miner would need to utilize a very powerful computer (with processing power much greater than even your standard gaming laptop) to continually generate SHA-256 hashes until the correct hash is found. Once that happens, the miner is entitled to some Bitcoin as a reward. How much Bitcoin they get is determined by Bitcoin’s value at a given time-for instance, the reward as of August 2024 is 3.125 Bitcoin (or 3 1/8 Bitcoin).

Here’s the GitHub link to the script from this post (SHA is the script name)-https://github.com/mfletcher2021/blogcode/blob/main/SHA.py.

Thanks for reading!

Michael

Hello everybody,

Michael here, and in today’s post, we’re going to cover file encryption with Python. The previous two posts simply covered text encryption, but today, we’re going to explore something a little different-encrypting and decrypting files!

This will be the file we’ll work with for this tutorial-

Yes, this is an old file and if you want to read the post where I originally used this dataset, here’s the link-R Analysis 10: Linear Regression, K-Means Clustering, & the 2020 NBA Playoffs (written in November 2020).

And now, to start the encryption!

To start with our encryption, let’s import the Fernet class from the cryptography.fernet module like so:

from cryptography.fernet import fernet

Next, let’s create our Fernet key and a file that will store the key:

key = Fernet.generate_key()

with open('C:/Users/mof39/OneDrive/Documents/filekey.key', 'wb') as fileKey:
    fileKey.write(key)

Using the with open() method, we store our Fernet key into a file in (this case) the Documents directory. This method takes two parameters-the file path (where we will store the key in this case) and the mode you wish to open the file in. The mode is a two-character string value with the following options for modes:

First string (denotes method to open the file)

• r-reads file into the IDE, errors out if the file doesn’t exist or path provided is incorrect
• a-appends contents to an existing file or creates the file to append content to if the file provided doesn’t exist
• w-writes content to an existing file or create the file to write content to if the file provided doesn’t exist
• x-creates the file in the specified file path, errors out if file already exists

SECOND STRING (denotes method to handle the file)

• t-handles file in text mode
• b-handles file in binary mode (this is good for handling images)

Now, what does the key look like?

In this example, we wrote our encryption key into a file called filekey.key and stored in the Documents folder.

• Something to note: The encryption keys should be saved as a .key file, but if you want to view the key file, opening it with a text editor like Notepad will work.

The actual file encryption

Now that we have the encryption key file, let’s encrypt the file! Here’s how to do so:

with open('C:/Users/mof39/OneDrive/Documents/filekey.key', 'rb') as fileKey:
    key = fileKey.read()
    
fernetKey = Fernet(key)

with open('C:/Users/mof39/OneDrive/Documents/2020-nba-playoffs.xlsx', 'rb') as testFile:
    originalFile = testFile.read()
    
encryption = fernetKey.encrypt(originalFile)

with open('C:/Users/mof39/OneDrive/Documents/2020-nba-playoffs-encrypted.xlsx', 'wb') as encryptedFile:
    encryptedFile.write(encryption)

with open('C:/Users/mof39/OneDrive/Documents/2020-nba-playoffs-encrypted.xlsx', 'rb') as encryptedFile:
    encryptedFile.read()

So, what exactly am I doing here? Let me explain

• I first read the file key that we generated in the previous section into the IDE.
• I then created a Fernet key object from the file key we generated.
• I then read the dataset we’re using into the IDE-note the originalFile variable.
• I encrypted the originalFile using the Fernet key we created earlier-note the encryption variable.
• Finally, I encrypted the file using the encryption variable and saved it to my Documents folder.

Now what does the encrypted file look like:

In this example, our test Excel file looks like a bunch of gibberish after being encrypted-and that’s the point of the encryption as its supposed to make the file unreadable during transmission from point A to point B.

• Excel files such as this one might not open after they are encrypted as the encryption process could also possibly corrupt the file. In this case, if you want to see the contents of the Excel file, opening it with Notepad (as I did here) should do the trick.

It’s decryption time!

Now that we have successfully encrypted our file, assume we want to prepare it before it reaches its intended recipient. In this case, it’s time to decrypt the file! Here’s how to do so:

decryption = fernetKey.decrypt(encryption)

with open('C:/Users/mof39/OneDrive/Documents/2020-nba-playoffs-decrypted.xlsx', 'wb') as decryptedFile:
    decryptedFile.write(decryption)
    
with open('C:/Users/mof39/OneDrive/Documents/2020-nba-playoffs-decrypted.xlsx', 'rb') as decryptedFile:
    decryptedFile.read()

How did I decrypt the file? Let me explain:

• I used the Fernet key we generated earlier for file encryption to decrypt the file.
• I then created a decrypted file (which is the same thing as our original file) and read that file into the IDE.

What does our decrypted file look like? Let’s take a look:

Ta-da! Our decrypted file is the same as our original file, just with the -decrypted at the end of the file name

• My advice: Although you don’t absolutely need to use different file names for the encrypted and decrypted versions of the file, I like to do so to be able to tell the difference between the encrypted and decrypted files.

Notice a familiar concept?

If you read my 6th anniversary post, you may recall that I discussed the concepts of symmetric and asymmetric-key encryption.

What does this type of encryption/decryption look like to you? If you guessed symmetric-key encryption, you’d be correct! Fernet key encryption-the method we used to encrypt/decrypt this file-is symmetric key encryption because it uses the same key to encrypt and decrypt the file. Granted, I also mentioned that symmetric-key encryption is less secure than asymmetric-key encryption; there are likely many ways to encrypt/decrypt the file using asymmetric-key encryption, but I thought Fernet key encryption would be an easy enough method to utilize to demonstrate basic file encryption/decryption with Python.

Just one more thing…

Six years into this blogging journey, I still strive to find ways to improve how I get my content to you-the readers. With that said, I will now upload scripts I use in my posts to my GitHub so that you can download and play along with the scripts too!

Here’s the link to the repo with the scripts-mfletcher2021/blogcode: Various scripts from Michael’s Programming Bytes (github.com). The script for this lesson is fileencryption.py.

Thanks for reading,

Michael