Hex Representation of an SHA-1 Digest of a String in Java

In this article, we will explore how to obtain a Hex Representation of an SHA-1 Digest of a String in Java. In the realm of computer science, cryptographic hash functions play a vital role in securing data integrity and authentication. One such hash function is SHA-1 (Secure Hash Algorithm 1), which generates a fixed-size 160-bit hash value known as a digest. This digest is typically represented in hexadecimal format for ease of use and readability. In this guide, we will explore how to obtain the hexadecimal representation of a SHA-1 digest of a string in Java.

1. Introduction

Before diving into the specifics of obtaining the hexadecimal representation of a SHA-1 digest, let’s briefly discuss the purpose and characteristics of SHA-1. SHA-1 is a widely-used cryptographic hash function that produces a 160-bit hash value. It is designed to be a one-way function, meaning it is computationally infeasible to reverse-engineer the original input from the digest.

The hexadecimal representation is commonly used to present hash values due to its compactness and human-readability. Hexadecimal encoding represents each nibble (4 bits) of the digest as a single hexadecimal digit, allowing for easy representation and comparison of hash values.

In Java, there are several approaches to compute the SHA-1 digest and obtain its hexadecimal representation. In the following sections, we will explore three popular methods using different libraries: MessageDigest from the Java standard library, Apache Commons Codec, and Google Guava.

2. Example Setup

Before we delve into the code examples, let’s set up a basic Java project to work with SHA-1 and the respective libraries. Ensure that you have Java Development Kit (JDK) installed on your system.

1. Create a new directory for your project.
2. Open a command prompt or terminal and navigate to the project directory.
3. Create a new Java source file, for example, Main.java.
4. Open the Main.java file in a text editor and add the following code as a starting point:

public class Main {
    public static void main(String[] args) {
        // Code examples will be placed here
    }
}

With this setup, we can proceed to explore the different methods of obtaining the hexadecimal representation of a SHA-1 digest in Java.

3. Using MessageDigest

Java’s standard library provides the MessageDigest class, which allows us to compute the SHA-1 digest of a given string. Here’s an example of how to use MessageDigest to obtain the hexadecimal representation:

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class Main {
    public static void main(String[] args) {
        String input = "Hello, world!";

        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-1");
            byte[] encodedHash = digest.digest(input.getBytes(StandardCharsets.UTF_8));

            StringBuilder hexString = new StringBuilder();
            for (byte b : encodedHash) {
                String hex = Integer.toHexString(0xff & b);
                if (hex.length() == 1) hexString.append('0');
                hexString.append(hex);
            }

            String hexDigest = hexString.toString();
            System.out.println("SHA-1 digest (MessageDigest): " + hexDigest);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }
}

In this example, we first create an instance of MessageDigest using the algorithm name “SHA-1”. We then convert the input string into bytes using the UTF-8 character encoding and compute the hash value by calling digest(). The resulting hash is stored in encodedHash as an array of bytes.

To obtain the hexadecimal representation, we iterate over each byte in `encoded

Hash and convert it to a hexadecimal string using Integer.toHexString(). We append leading zeros if necessary to ensure that each byte is represented by two hexadecimal digits. Finally, we convert the StringBuilder to a String and print the SHA-1 digest.

4. Using Apache Commons Codec

Apache Commons Codec is a popular Java library that provides various encoding and decoding utilities, including support for SHA-1 hashing. Here’s an example of how to use Apache Commons Codec to obtain the hexadecimal representation of a SHA-1 digest:

4.1 Apache Commons Codec Dependency

1. Download the latest version of Apache Commons Codec from the Apache Commons website (https://commons.apache.org/codec/).
2. Extract the downloaded archive to a directory of your choice.
3. In your Java project, locate the build configuration file, such as pom.xml for Maven or build.gradle for Gradle.
4. Open the build configuration file in a text editor.
5. Add the following dependency entry to your build configuration file:

    commons-codec
    commons-codec
    1.15



// For Gradle
implementation 'commons-codec:commons-codec:{commons-codec-version}'

Replace {commons-codec-version} with the actual version number of Apache Commons Codec that you downloaded.

6. Save the changes to your build configuration file.
7. Trigger a build or dependency refresh in your project to download and include the Apache Commons Codec library.

import org.apache.commons.codec.digest.DigestUtils;

public class Main {
    public static void main(String[] args) {
        String input = "Hello, world!";

        String hexDigest = DigestUtils.sha1Hex(input);
        System.out.println("SHA-1 digest (Apache Commons Codec): " + hexDigest);
    }
}

In this example, we use the DigestUtils class from Apache Commons Codec, which provides a simple API for calculating digests. We call the sha1Hex() method, passing in the input string, and it returns the hexadecimal representation of the SHA-1 digest directly.

Apache Commons Codec abstracts away the complexity of working with MessageDigest and provides a convenient and concise way to obtain the SHA-1 digest in hexadecimal format.

5. Using Google Guava

Google Guava is another popular Java library that offers a wide range of utilities and helper functions. Although it doesn’t have a dedicated class for SHA-1 hashing, we can leverage Guava’s Hashing class to compute the digest and convert it to hexadecimal representation. Here’s an example:

5.1 Google Guava Dependency

1. In your Java project, locate the build configuration file, such as pom.xml for Maven or build.gradle for Gradle.
2. Open the build configuration file in a text editor.
3. Add the following dependency entry to your build configuration file:

    com.google.guava
    guava
    32.0.1-jre



// For Gradle
implementation 'com.google.guava:guava:{guava-version}'

Replace {guava-version} with the desired version of Google Guava.

4. Save the changes to your build configuration file.
5. Trigger a build or dependency refresh in your project to download and include the Google Guava library.

After adding the dependencies, you should be able to use the Apache Commons Codec and Google Guava libraries in your Java code to obtain the hexadecimal representation of a SHA-1 digest.

import com.google.common.hash.Hashing;

public class Main {
    public static void main(String[] args) {
        String input = "Hello, world!";

        String hexDigest = Hashing.sha1().hashString(input, StandardCharsets.UTF_8).toString();
        System.out.println("SHA-1 digest (Google Guava): " + hexDigest);
    }
}

In this example, we use the Hashing class from Google Guava, which provides a fluent API for working with cryptographic hashes. We call the sha1() method to obtain a HashFunction instance for SHA-1 hashing. Then, we use the hashString() method, passing in the input string and the desired character encoding. Finally, we convert the resulting HashCode to a string using toString() and obtain the hexadecimal representation of the SHA-1 digest.

While Google Guava doesn’t provide a direct method for obtaining the hexadecimal representation of the digest, the toString() method of HashCode returns a hexadecimal representation by default.

6. Conclusion

In this guide, we explored three different methods for obtaining the hexadecimal representation of a SHA-1 digest of a string in Java. We covered the usage of MessageDigest from the Java standard library, Apache Commons Codec, and Google Guava.

Using MessageDigest requires more manual steps, such as iterating over the byte array and converting each byte to a hexadecimal string. Apache Commons Codec simplifies the process by providing a dedicated method for obtaining the hexadecimal representation directly. Google Guava offers a fluent API that combines the computation of the digest and the conversion to hexadecimal in a single line of code.

Choose the method that best suits your project’s requirements and dependencies. Regardless of the approach, computing the SHA-1 digest and representing it in hexadecimal format enables secure data integrity verification and authentication in various applications.

7. Download the Source Code

This was an example of Hex Representation of an SHA-1 Digest of a String in Java.

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.