Building 70 Projects ranging from beginner to advanced so anyone can — learn from, build upon, use as a reference, or even copy directly. Owned by my cybersecurity company 👇
Go aicertificationcloud-engineeringcybercybersecuritycybersecurity-analystcybersecurity-certificationcybersecurity-certificationscybersecurity-educationcybersecurity-jobscybersecurity-portfoliocybersecurity-projectscybersecurity-toolsgrchackinglearningpentestingproject-repositoryprojetcspython
feat: CLI with Boost.program_options and hash type dispatch
CarterPerez-devf90a6ada5e1f
diff --git a/PROJECTS/beginner/hash-cracker/main.cpp b/PROJECTS/beginner/hash-cracker/main.cppindex e696711c..68380d53 100644--- a/PROJECTS/beginner/hash-cracker/main.cpp+++ b/PROJECTS/beginner/hash-cracker/main.cpp@@ -1,6 +1,182 @@// ©AngelaMos | 2026// main.cpp-int main() {- return 0;+#include <boost/program_options.hpp>+#include <expected>+#include <iostream>+#include <print>+#include <string>+#include "src/attack/BruteForceAttack.hpp"+#include "src/attack/DictionaryAttack.hpp"+#include "src/attack/RuleAttack.hpp"+#include "src/config/Config.hpp"+#include "src/core/Concepts.hpp"+#include "src/core/Engine.hpp"+#include "src/hash/HashDetector.hpp"+#include "src/hash/MD5Hasher.hpp"+#include "src/hash/SHA1Hasher.hpp"+#include "src/hash/SHA256Hasher.hpp"+#include "src/hash/SHA512Hasher.hpp"++namespace po = boost::program_options;++static std::string build_charset(const std::string& spec) {+ std::string result;++ auto has = [&](std::string_view token) {+ return spec.find(token) != std::string::npos;+ };++ if (has("lower")) { result += config::CHARSET_LOWER; }+ if (has("upper")) { result += config::CHARSET_UPPER; }+ if (has("digits")) { result += config::CHARSET_DIGITS; }+ if (has("special")) { result += config::CHARSET_SPECIAL; }++ if (result.empty()) {+ result += config::CHARSET_LOWER;+ result += config::CHARSET_DIGITS;+ }++ return result;+}++template <Hasher H>+static auto dispatch_attack(const CrackConfig& cfg)+ -> std::expected<CrackResult, CrackError> {+ if (cfg.bruteforce) {+ return Engine::crack<H, BruteForceAttack>(cfg);+ }+ if (cfg.use_rules) {+ return Engine::crack<H, RuleAttack>(cfg);+ }+ return Engine::crack<H, DictionaryAttack>(cfg);+}++static auto dispatch_hasher(HashType type, const CrackConfig& cfg)+ -> std::expected<CrackResult, CrackError> {+ switch (type) {+ case HashType::MD5: return dispatch_attack<MD5Hasher>(cfg);+ case HashType::SHA1: return dispatch_attack<SHA1Hasher>(cfg);+ case HashType::SHA256: return dispatch_attack<SHA256Hasher>(cfg);+ case HashType::SHA512: return dispatch_attack<SHA512Hasher>(cfg);+ }+ return std::unexpected(CrackError::UnsupportedAlgorithm);+}++static void write_json_result(const std::string& path,+ const CrackResult& result) {+ auto* f = std::fopen(path.c_str(), "w");+ if (!f) { return; }++ std::fprintf(f,+ "{\n"+ " \"plaintext\": \"%s\",\n"+ " \"hash\": \"%s\",\n"+ " \"algorithm\": \"%s\",\n"+ " \"elapsed_seconds\": %.4f,\n"+ " \"candidates_tested\": %zu,\n"+ " \"hashes_per_second\": %.2f\n"+ "}\n",+ result.plaintext.c_str(),+ result.hash.c_str(),+ result.algorithm.c_str(),+ result.elapsed_seconds,+ result.candidates_tested,+ result.hashes_per_second);++ std::fclose(f);+}++int main(int argc, char* argv[]) {+ po::options_description desc("hashcracker - Multi-threaded hash cracking tool");+ desc.add_options()+ ("help,h", "Show help message")+ ("hash", po::value<std::string>(), "Target hash to crack")+ ("type", po::value<std::string>()->default_value("auto"),+ "Hash type: md5, sha1, sha256, sha512, auto")+ ("wordlist,w", po::value<std::string>(), "Path to wordlist file")+ ("bruteforce,b", "Use brute-force attack mode")+ ("charset", po::value<std::string>()->default_value("lower,digits"),+ "Character sets: lower,upper,digits,special")+ ("max-length", po::value<std::size_t>()->default_value(+ config::DEFAULT_MAX_BRUTE_LENGTH), "Max password length for brute-force")+ ("rules,r", "Apply mutation rules to dictionary words")+ ("chain-rules", "Chain mutation rules in combination")+ ("salt", po::value<std::string>(), "Salt value to prepend/append")+ ("salt-position", po::value<std::string>()->default_value("prepend"),+ "Salt position: prepend or append")+ ("threads,t", po::value<unsigned>()->default_value(+ config::DEFAULT_THREAD_COUNT), "Thread count (0 = auto)")+ ("output,o", po::value<std::string>(), "Write JSON result to file");++ po::variables_map vm;+ try {+ po::store(po::parse_command_line(argc, argv, desc), vm);+ po::notify(vm);+ } catch (const po::error& e) {+ std::println(stderr, "Error: {}", e.what());+ return 1;+ }++ if (vm.count("help") || !vm.count("hash")) {+ std::cout << desc << std::endl;+ return vm.count("help") ? 0 : 1;+ }++ CrackConfig cfg;+ cfg.target_hash = vm["hash"].as<std::string>();+ cfg.hash_type = vm["type"].as<std::string>();+ cfg.thread_count = vm["threads"].as<unsigned>();+ cfg.bruteforce = vm.count("bruteforce") > 0;+ cfg.use_rules = vm.count("rules") > 0;+ cfg.chain_rules = vm.count("chain-rules") > 0;+ cfg.max_length = vm["max-length"].as<std::size_t>();++ if (vm.count("wordlist")) {+ cfg.wordlist_path = vm["wordlist"].as<std::string>();+ }+ if (vm.count("salt")) {+ cfg.salt = vm["salt"].as<std::string>();+ }+ cfg.salt_position = vm["salt-position"].as<std::string>();+ if (vm.count("output")) {+ cfg.output_path = vm["output"].as<std::string>();+ }++ if (cfg.bruteforce) {+ cfg.charset = build_charset(vm["charset"].as<std::string>());+ } else if (cfg.wordlist_path.empty()) {+ std::println(stderr, "Error: --wordlist required for dictionary/rule attacks");+ return 1;+ }++ HashType hash_type;+ if (cfg.hash_type == "auto") {+ auto detected = HashDetector::detect(cfg.target_hash);+ if (!detected.has_value()) {+ std::println(stderr, "Error: {}",+ crack_error_message(detected.error()));+ return 1;+ }+ hash_type = *detected;+ } else if (cfg.hash_type == "md5") {+ hash_type = HashType::MD5;+ } else if (cfg.hash_type == "sha1") {+ hash_type = HashType::SHA1;+ } else if (cfg.hash_type == "sha256") {+ hash_type = HashType::SHA256;+ } else if (cfg.hash_type == "sha512") {+ hash_type = HashType::SHA512;+ } else {+ std::println(stderr, "Error: Unknown hash type '{}'", cfg.hash_type);+ return 1;+ }++ auto result = dispatch_hasher(hash_type, cfg);++ if (result.has_value() && !cfg.output_path.empty()) {+ write_json_result(cfg.output_path, *result);+ }++ return result.has_value() ? 0 : 1;}