Encryption vs Hashing 🤔 Lets decode

Repana Reddy Sekhar — Sat, 10 Feb 2024 06:30:15 +0000

Everyone thinks encryption and hashing are same, but there is so much difference between them which we will see next.

While both techniques are essential for protecting data, they serve distinct purposes. In this post, we'll delve into the disparities between encryption and hashing, exploring their applications and providing practical code examples.

Encryption:

Encryption is a process that transforms readable data into an unreadable format, commonly known as ciphertext. This conversion is reversible, meaning that the ciphertext can be decrypted back into the original plaintext if the proper key is available. Encryption is commonly used to secure data during transmission or storage.

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class EncryptionExample {

    private static final String secretKey = "MySecretKey123"; // Replace with a strong and secure key

    public static void main(String[] args) {
        // Original data
        String originalData = "Sensitive information";

        // Encryption example using AES algorithm
        String encryptedData = encrypt(originalData);
        System.out.println("Original data: " + originalData);
        System.out.println("Encrypted data: " + encryptedData);

        // Decryption example
        String decryptedData = decrypt(encryptedData);
        System.out.println("Decrypted data: " + decryptedData);
    }

    private static String encrypt(String data) {
        try {
            // Generate a key specification from the secret key
            SecretKeySpec secretKeySpec = new SecretKeySpec(secretKey.getBytes(), "AES");

            // Create a Cipher instance with AES algorithm
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);

            // Encrypt the data
            byte[] encryptedBytes = cipher.doFinal(data.getBytes());

            // Encode the encrypted data using Base64
            return Base64.getEncoder().encodeToString(encryptedBytes);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    private static String decrypt(String encryptedData) {
        try {
            // Generate a key specification from the secret key
            SecretKeySpec secretKeySpec = new SecretKeySpec(secretKey.getBytes(), "AES");

            // Create a Cipher instance with AES algorithm
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);

            // Decode the Base64 encoded encrypted data
            byte[] encryptedBytes = Base64.getDecoder().decode(encryptedData);

            // Decrypt the data
            byte[] decryptedBytes = cipher.doFinal(encryptedBytes);

            // Convert the decrypted bytes to a string
            return new String(decryptedBytes);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

Remember to replace the secretKey in the EncryptionExample program with a strong and secure key. The decrypt function in this program demonstrates the decryption process using the same key used for encryption.

Hashing:

Hashing is a one-way process that converts input data into a fixed-size string of characters, commonly referred to as a hash or digest. Unlike encryption, hashing is not reversible, meaning that you cannot retrieve the original data from its hash. Hashing is frequently employed for data integrity verification and password storage.

import java.security.MessageDigest;

public class HashingExample {

    public static void main(String[] args) {
        // Original data
        String originalData = "Sensitive information";

        // Hashing example using SHA-256 algorithm
        String hashedData = hash(originalData);
        System.out.println("Original data: " + originalData);
        System.out.println("Hashed data: " + hashedData);
    }

    private static String hash(String data) {
        try {
            // Create a MessageDigest instance with SHA-256 algorithm
            MessageDigest digest = MessageDigest.getInstance("SHA-256");

            // Update the digest with the data bytes
            byte[] hashedBytes = digest.digest(data.getBytes());

            // Convert the hashed bytes to a hexadecimal representation
            StringBuilder hexStringBuilder = new StringBuilder();
            for (byte hashedByte : hashedBytes) {
                hexStringBuilder.append(String.format("%02x", hashedByte));
            }

            return hexStringBuilder.toString();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

Summary: Encryption ensures confidentiality by transforming data into a reversible format, while hashing provides data integrity and password protection through irreversible processes. Understanding when and how to use each technique is crucial for implementing robust security measures in applications and systems.

Happy coding!

Feel free like this blog and subscribe for more tech blogs.
Feel free to buy me a coffee: https://ko-fi.com/repanareddysekhar

SOLID Principles

Repana Reddy Sekhar — Sat, 06 Jan 2024 18:25:11 +0000

The SOLID principles are a set of five design principles in software development intended to make software designs more understandable, flexible, and maintainable.
These principles were introduced by Robert C. Martin (also known as Uncle Bob) to guide developers in creating better software architecture.

We will look each of these principles one by one:

Single Responsibility Principle (SRP)

It states that

A class should have one and only one reason to change

Example:

If we carefully observe in the above Employee class, we are doing two things i.e storing employee and calculating pay which defies SRF.

The Solution for the above problem is just create two classes like below:

Open Closed Principle (OCP):

It states that    

Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification

Example:
Let us consider below class to calculate penal fee based on lender:

Suppose if we want to add another lender, we need to modify this class which is not best practice and defies OCP.

Solution for the above problem is:

Liskov Substitution Principle (LSP)

It states that    

Objects of a superclass should be replaceable with objects of its subclasses without affecting the correctness of the program

In other words,
Inheritance hierarchies such that derived classes must be completely substitutable for their base classes

Example:

In the above code, we have seen it clearly violates LSP.

Solution for the above problem is:

Interface Segregation Principle

It states that    

Clients shouldn’t be forced to depend on methods they do not use.

Solution:

Dependency Inversion Principle

It states that    

High-level module must not depend on the low-level module, but they should depend on abstractions.

Example:

Solution:

Advantages

Maintainability
Flexibility and Extensibility
Readability and Understanding
Quality Software

Happy coding!

Feel free like this blog and subscribe for more tech blogs.
Feel free to buy me a coffee: https://ko-fi.com/repanareddysekhar

DEV Community: Repana Reddy Sekhar

Encryption vs Hashing 🤔 Lets decode

Encryption:

Hashing:

SOLID Principles

Single Responsibility Principle (SRP)

Open Closed Principle (OCP):

Liskov Substitution Principle (LSP)

Interface Segregation Principle

Dependency Inversion Principle

Advantages