Creating a MD5 Hash Dictionary Script

Summary MD5

Introduction

const lowerCaseChars = "abcdefghijklmnopqrstuvwxyzç";
const upperCaseChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZÇ";
const specialChars = "!@#$%^&*()-_+=<>?/,.:;{}[]|";
const numericChars = "0123456789";

Estimating Time

Algorithm

Conclusion

Script Example in Javascript

const cluster = require("cluster");
const totalCPUs = require("os").cpus().length;
const fs = require("fs");
const crypto = require("crypto");

const dictionaryMD5Passwords = {
	6: [],
	7: [],
	8: [],
	9: [],
	10: [],
	11: [],
	12: [],
	13: [],
};

const indexes = [0, 1, 2, 3, 4, 5, 6, 7]; // each worker index
const lowerCaseChars = "abcdefghijklmnopqrstuvwxyzç";
const upperCaseChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZÇ";
const specialChars = "!@#$%^&*()-_+=<>?/,.:;{}[]|";
const numericChars = "0123456789";

const allPasswordPossibleCharacters =
	lowerCaseChars + upperCaseChars + specialChars + numericChars;

function generateCombinationsWithRepetition(inputString, combinationLength) {
	function generateHelper(currentPassword) {
		if (currentPassword.length === combinationLength) {
			const password = {
				plainText: currentPassword,
				md5: crypto.createHash("md5").update(currentPassword).digest("hex"),
			};

			console.log(password);

			dictionaryMD5Passwords[combinationLength].push(password);

			fs.writeFileSync(
				`./md5_hash_dictionary/passwords_length_${combinationLength}.json`,
				JSON.stringify(dictionaryMD5Passwords[combinationLength], null, 4),
				"utf8"
			);

			return;
		}

		for (let i = 0; i < inputString.length; i++) {
			const char = inputString[i];
			const newCombination = currentPassword + char;
			generateHelper(newCombination);
		}
	}

	generateHelper("");
}

if (cluster.isMaster) {
	for (let i = 0; i < totalCPUs; i++) {
		const worker = cluster.fork();
		worker.on("message", message => {
			console.log(
				`\nWORKER ID ${worker.process.pid} => received message: ${message}\n`
			);
		});
	}

	let workerIndex = 0;

	for (const index of indexes) {
		const worker = Object.values(cluster.workers)[workerIndex];
		if (worker) {
			let combinationLength = index + 6;
			worker.send(combinationLength);
			workerIndex = (workerIndex + 1) % totalCPUs;
		}
	}

	cluster.on("exit", worker => {
		console.log(`Worker ${worker.process.pid} finished his job!`);
	});
} else {
	process.on("message", async combinationLength => {
		generateCombinationsWithRepetition(
			allPasswordPossibleCharacters,
			combinationLength
		);
	});
}

Script Example in Go

package main

import (
	"crypto/md5"
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"runtime"
	"sync"
	"time"
)

var allPasswordPossibleCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_+=<>?/,.:;{}[]|"

type Password struct {
	PlainText string `json:"plainText"`
	MD5       string `json:"md5"`
}

func generateCombinationsWithRepetition(length int, workerID int, wg *sync.WaitGroup) {
	defer wg.Done()

	start := time.Now()

	var passwords []Password
	totalRequestsMade := 0

	var generateHelper func(currentPassword string)

	generateHelper = func(currentPassword string) {
		if len(currentPassword) == length {
			md5Hash := md5.New()
			md5Hash.Write([]byte(currentPassword))
			md5String := fmt.Sprintf("%x", md5Hash.Sum(nil))

			passwords = append(passwords, Password{
				PlainText: currentPassword,
				MD5:       md5String,
			})

			totalRequestsMade++
			fmt.Printf("Worker %d generated: {\"plainText\": \"%s\", \"md5\": \"%s\"}\n", workerID, currentPassword, md5String)
			return
		}

		for _, char := range allPasswordPossibleCharacters {
			generateHelper(currentPassword + string(char))
			// time.Sleep(1 * time.Second) // Uncomment to create 1 password per second
		}
	}

	generateHelper("")

	duration := time.Since(start)
	fmt.Printf("Worker %d sent all passwords in %v\n", workerID, duration)
	fmt.Printf("Worker %d generated %d passwords\n", workerID, totalRequestsMade)

	dir := "./dictionary-golang"
	if err := os.MkdirAll(dir, 0755); err != nil {
		fmt.Printf("Error creating directory: %v\n", err)
		return
	}

	filePath := filepath.Join(dir, fmt.Sprintf("passwords_length_%d.json", length))
	file, err := os.Create(filePath)
	if err != nil {
		fmt.Printf("Error creating file %s: %v\n", filePath, err)
		return
	}
	defer file.Close()

	encoder := json.NewEncoder(file)
	encoder.SetIndent("", "  ")
	if err := encoder.Encode(passwords); err != nil {
		fmt.Printf("Error encoding JSON to file %s: %v\n", filePath, err)
		return
	}

	fmt.Printf("Worker %d saved passwords to %s\n", workerID, filePath)
}

func main() {
	numWorkers := runtime.NumCPU()
	var wg sync.WaitGroup

	fmt.Printf("Master setting up %d workers...\n", numWorkers)

	for i := 0; i < numWorkers; i++ {
		wg.Add(1)
		go func(workerID int) {
			defer wg.Done()
			length := 6 + workerID
			fmt.Printf("Worker %d processing length %d\n", workerID, length)
			generateCombinationsWithRepetition(length, workerID, &wg)
		}(i)
	}

	wg.Wait()
}