Creating a Brute Force Attack Script to Find Secret Code

Introduction

• It is quite common for systems to use 6-digit secret codes to authenticate users.
• Delivery usually via email or SMS
• For example: 435 657

Algorithm

• In this algorithm, using parallelism, the algorithm uses the 8 available CPUs in parallel here on my machine.
• I made a logic so that each worker processes an amount of equal numbers.
• Example: if I have 32 possible numbers to check, each worker will check 4 different numbers, in parallel, at the same time.
• When one of the workers finds the secret code, it sends a message to the master cluster of the 8 workers to finish the work of all of them.

Conclusion

• I made this algorithm for didactic purposes, and for pure curiosity/technical interest.

Script Example in Javascript

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

const secretCodeToFind = 213405;

const minNumber = 100000;
const maxNumber = 999999;
const totalNumbersToEachWorkerToTest = Math.floor(
	(maxNumber - minNumber) / totalCPUs
);

const indexes = [0, 1, 2, 3, 4, 5, 6, 7];
const startAt = []; // numbers to each worker start to test
const endAt = []; // numbers to each worker end test

for (let i = 0; i < indexes.length; i++) {
	if (i === 0) {
		startAt[0] = minNumber;
		endAt[0] = minNumber + totalNumbersToEachWorkerToTest;
	} else {
		startAt[i] = endAt[i - 1] + 1;
		endAt[i] =
			startAt[i] + totalNumbersToEachWorkerToTest > maxNumber
				? maxNumber
				: startAt[i] + totalNumbersToEachWorkerToTest;
	}
}

function sleep(ms) {
	return new Promise(resolve => setTimeout(resolve, ms));
}

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`
			);

			if (message === "SECRET CODE FOUND") {
				console.log(
					`\nThe Secret Code ${secretCodeToFind} was found! Terminating all workers...\n`
				);

				for (const id in cluster.workers) {
					cluster.workers[id].kill();
				}
			}
		});
	}

	let workerIndex = 0;

	for (const index of indexes) {
		const worker = Object.values(cluster.workers)[workerIndex];
		if (worker) {
			const object = {
				start: startAt[index],
				end: endAt[index],
			};
			worker.send(object);
			workerIndex = (workerIndex + 1) % totalCPUs;
		}
	}

	cluster.on("exit", (worker, code, signal) => {
		console.log(`Worker ${worker.process.pid} finished his job!`);
	});
} else {
	process.on("message", async ({ start, end }) => {
		for (let i = start; i <= end; i++) {
			console.log(`...WORKER ID ${process.pid} => trying number: ${i}`);

			await sleep(25);

			if (i === secretCodeToFind) {
				console.log(`\n\nTHE SECRET CODE is =========> ${i}\n\n`);
				process.send("SECRET CODE FOUND");
				break;
			}
		}
	});
}

Script Example in Go

package main

import (
	"fmt"
	"runtime"
	"sync"
	"time"
)

const (
	secretCodeToFind = 213405
	minNumber        = 100000
	maxNumber        = 999999
)

var (
	totalNumbersToEachWorkerToTest int
	startAt                        []int
	endAt                          []int
)

func initRanges(numWorkers int) {
	startAt = make([]int, numWorkers)
	endAt = make([]int, numWorkers)

	for i := 0; i < numWorkers; i++ {
		if i == 0 {
			startAt[0] = minNumber
			endAt[0] = minNumber + totalNumbersToEachWorkerToTest
		} else {
			startAt[i] = endAt[i-1] + 1
			endAt[i] = startAt[i] + totalNumbersToEachWorkerToTest
			if endAt[i] > maxNumber {
				endAt[i] = maxNumber
			}
		}
	}
}

func sleep(ms int) {
	time.Sleep(time.Duration(ms) * time.Millisecond)
}

func Worker(id, start, end int, wg *sync.WaitGroup, found chan struct{}) {
	defer wg.Done()

	for i := start; i <= end; i++ {
		select {
		case <-found:
			return
		default:
			fmt.Printf("...WORKER ID %d => trying number: %d\n", id, i)
			sleep(25)

			if i == secretCodeToFind {
				fmt.Printf("\n\nTHE SECRET CODE is =========> %d\n\n", i)
				close(found)
				return
			}
		}
	}
}

func main() {
	numWorkers := runtime.NumCPU()
	totalNumbersToEachWorkerToTest = (maxNumber - minNumber) / numWorkers

	initRanges(numWorkers)

	var wg sync.WaitGroup
	found := make(chan struct{})

	for i := 0; i < numWorkers; i++ {
		wg.Add(1)
		go Worker(i, startAt[i], endAt[i], &wg, found)
	}

	wg.Wait()
}