Hashing Method

const fs = require("fs");
const crypto = require("crypto-js");

function hash(content) {
	try {
		// First hash (WordArray hash)
		const wordArray = crypto.lib.WordArray.create(content);
		const firstHash = crypto.SHA256(wordArray);
		const firstHashHex = firstHash.toString(crypto.enc.Hex);
		console.log("First hash:" + firstHashHex);

		// Second hash (WordArray hash)
		const firstHashWordArray = crypto.enc.Hex.parse(firstHashHex);
		const secondHash = crypto.SHA256(firstHashWordArray);
		const secondHashHex = secondHash.toString(crypto.enc.Hex);
		console.log("Double hash:" + secondHashHex);

		// Returns the double hash
		return secondHashHex;
	} catch (err) {
		console.log(`Error hashing the file content: ${err}`);
		throw err;
	}
}
const filePath = "./filetohash.pdf";
const fileContent = fs.readFileSync(filePath, {});
hash(fileContent);

import hashlib

def hash(data):
	sha256 = hashlib.sha256()
	sha256.update(data)
	return hashlib.sha256(sha256.digest()).hexdigest()

file_path = "./filetohash.pdf"
with open(file_path, "rb") as f:
	file_content = f.read()
hash(file_content)

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class JavaExample {
	public static String hashFile(File file) throws NoSuchAlgorithmException, IOException {
		// create a MessageDigest object using SHA-256 algorithm
		MessageDigest digest1 = MessageDigest.getInstance("SHA-256");

		// read the file contents into a byte array
		FileInputStream fis = new FileInputStream(file);
		byte[] buffer = new byte[8192];
		int len;
		while ((len = fis.read(buffer)) > 0) {
			digest1.update(buffer, 0, len);
		}
		fis.close();

		// compute the hash value of the file contents
		byte[] fileHash = digest1.digest();

		// create a new MessageDigest object for the second hash
		MessageDigest digest2 = MessageDigest.getInstance("SHA-256");

		// update the second hash with the first hash value
		digest2.update(fileHash);

		// compute the second hash value
		byte[] doubleHash = digest2.digest();

		// convert the byte arrays to hexadecimal strings
		String fileHashHex = bytesToHex(fileHash);
		String doubleHashHex = bytesToHex(doubleHash);

		// print the hash values and return the double hash value
		System.out.println("First hash: " + fileHashHex);
		System.out.println("Double hash: " + doubleHashHex);
		return doubleHashHex;
	}

	private static String bytesToHex(byte[] bytes) {
		StringBuilder sb = new StringBuilder();
		for (byte b : bytes) {
			sb.append(String.format("%02x", b));
		}
		return sb.toString();
	}

	public static void main(String[] args) throws Exception {
		File file = new File("./filetohash.pdf");
		hashFile(file);
	}
}

package main

import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"io/ioutil"
)

func hash(content []byte) (string, error) {

	// First hash (WordArray hash)
	h1 := sha256.Sum256(content)
	h1Hex := hex.EncodeToString(h1[:])
	fmt.Printf("First Hash (hex): %s\n", h1Hex)

	// Second hash (WordArray hash)
	h2 := sha256.Sum256(h1[:])
	h2Hex := hex.EncodeToString(h2[:])
	fmt.Printf("Double Hash (hex): %s\n", h2Hex)

	// Return the double hash
	return h2Hex, nil

}

func main() {
	// Read file contents
	filename := "filetohash.pdf"
	data, err := ioutil.ReadFile(filename)
	if err != nil {
		fmt.Printf("Error reading file: %s", err)
		return
	}
	// Call double hash method
	hash(data)
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/sha.h>

char *hash(unsigned char *data, size_t len)
{
	unsigned char hash[SHA256_DIGEST_LENGTH];
	SHA256_CTX sha256;
	SHA256_Init(&sha256);
	SHA256_Update(&sha256, data, len);
	SHA256_Final(hash, &sha256);

	unsigned char hash2[SHA256_DIGEST_LENGTH];
	SHA256_Init(&sha256);
	SHA256_Update(&sha256, hash, SHA256_DIGEST_LENGTH);
	SHA256_Final(hash2, &sha256);

	char *output = (char *)malloc((SHA256_DIGEST_LENGTH * 2 + 1) * sizeof(char));
	for (int i = 0; i <CodeGroup SHA256_DIGEST_LENGTH; i++)
	{
		sprintf(&output[i * 2], "%02x", (unsigned int)hash2[i]);
	}
	return output;
}

int main()
{
	char *file_path = "./filetohash.pdf";
	FILE *f = fopen(file_path, "rb");
	if (!f)
	{
		printf("Error opening file\n");
		return 1;
	}
	fseek(f, 0, SEEK_END);
	long file_size = ftell(f);
	fseek(f, 0, SEEK_SET);
	unsigned char *file_content = (unsigned char *)malloc(file_size * sizeof(unsigned char));
	fread(file_content, sizeof(unsigned char), file_size, f);
	fclose(f);

	char *hash_value = hash(file_content, file_size);
	printf("Hash value: %s\n", hash_value);
	free(hash_value);
	free(file_content);
	return 0;
}