hashsmith-cli 1.0.0 → 1.0.1

package/hashsmith/algorithms/cracking.py

@@ -93,6 +93,100 @@ def _dictionary_worker(words: List[str], target_hash: str, algorithm: str, salt:
     return None, attempts
 
 
+def _bruteforce_worker(
+    prefixes: List[str],
+    target_hash: str,
+    algorithm: str,
+    charset: str,
+    length: int,
+    salt: str,
+    salt_mode: str,
+) -> Tuple[Optional[str], int]:
+    attempts = 0
+    scrypt_params = None
+    if algorithm == "scrypt":
+        scrypt_params = _parse_scrypt_hash(target_hash)
+    mssql_salt = None
+    if algorithm in {"mssql2005", "mssql2012"}:
+        mssql_salt = _parse_mssql_2005_salt(target_hash)
+    hasher = None
+    verify_mismatch = None
+    invalid_hash = None
+    if algorithm == "argon2":
+        try:
+            from argon2 import PasswordHasher  # type: ignore
+            from argon2.exceptions import VerifyMismatchError, InvalidHash  # type: ignore
+        except Exception:  # pragma: no cover
+            return None, attempts
+        hasher = PasswordHasher()
+        verify_mismatch = VerifyMismatchError
+        invalid_hash = InvalidHash
+
+    for prefix in prefixes:
+        remaining = length - len(prefix)
+        if remaining < 0:
+            continue
+        if remaining == 0:
+            attempts += 1
+            candidate = prefix
+            if algorithm == "bcrypt":
+                if bcrypt is None:
+                    continue
+                if bcrypt.checkpw(candidate.encode("utf-8"), target_hash.encode("utf-8")):
+                    return candidate, attempts
+            elif algorithm == "argon2":
+                try:
+                    hasher.verify(target_hash, candidate)
+                    return candidate, attempts
+                except (verify_mismatch, invalid_hash):
+                    continue
+                except Exception:
+                    continue
+            elif algorithm == "scrypt":
+                n, r, p, salt_bytes, digest = scrypt_params
+                value = hashlib.scrypt(candidate.encode("utf-8"), salt=salt_bytes, n=n, r=r, p=p, dklen=len(digest))
+                if value == digest:
+                    return candidate, attempts
+            elif algorithm in {"mssql2005", "mssql2012"}:
+                digest = hashlib.sha1(mssql_salt + candidate.encode("utf-16le")).hexdigest().upper()
+                if target_hash.lower().startswith("0x0100") and target_hash[14:].upper() == digest:
+                    return candidate, attempts
+            else:
+                if hash_text(candidate, algorithm, salt, salt_mode) == target_hash:
+                    return candidate, attempts
+            continue
+
+        for combo in itertools.product(charset, repeat=remaining):
+            attempts += 1
+            candidate = prefix + "".join(combo)
+            if algorithm == "bcrypt":
+                if bcrypt is None:
+                    continue
+                if bcrypt.checkpw(candidate.encode("utf-8"), target_hash.encode("utf-8")):
+                    return candidate, attempts
+            elif algorithm == "argon2":
+                try:
+                    hasher.verify(target_hash, candidate)
+                    return candidate, attempts
+                except (verify_mismatch, invalid_hash):
+                    continue
+                except Exception:
+                    continue
+            elif algorithm == "scrypt":
+                n, r, p, salt_bytes, digest = scrypt_params
+                value = hashlib.scrypt(candidate.encode("utf-8"), salt=salt_bytes, n=n, r=r, p=p, dklen=len(digest))
+                if value == digest:
+                    return candidate, attempts
+            elif algorithm in {"mssql2005", "mssql2012"}:
+                digest = hashlib.sha1(mssql_salt + candidate.encode("utf-16le")).hexdigest().upper()
+                if target_hash.lower().startswith("0x0100") and target_hash[14:].upper() == digest:
+                    return candidate, attempts
+            else:
+                if hash_text(candidate, algorithm, salt, salt_mode) == target_hash:
+                    return candidate, attempts
+    return None, attempts
+
+
 def dictionary_attack(
     target_hash: str,
     algorithm: str,
@@ -198,11 +292,14 @@ def brute_force(
     max_len: int = 4,
     salt: str = "",
     salt_mode: str = "prefix",
+    workers: int = 1,
     progress_callback: Optional[Callable[[int], None]] = None,
 ) -> CrackResult:
     start = time.perf_counter()
     counter = RateCounter()
     attempts = 0
+    if algorithm == "bcrypt" and bcrypt is None:
+        raise ValueError("bcrypt library is required for bcrypt cracking")
     if algorithm == "argon2":
         try:
             from argon2 import PasswordHasher  # type: ignore
@@ -221,47 +318,95 @@ def brute_force(
     if algorithm in {"mssql2005", "mssql2012"}:
         mssql_salt = _parse_mssql_2005_salt(target_hash)
 
-    for length in range(min_len, max_len + 1):
-        for combo in itertools.product(charset, repeat=length):
-            attempts += 1
-            if progress_callback:
-                progress_callback(1)
-            candidate = "".join(combo)
-            if algorithm == "bcrypt":
-                if bcrypt is None:
-                    raise ValueError("bcrypt library is required for bcrypt cracking")
-                if bcrypt.checkpw(candidate.encode("utf-8"), target_hash.encode("utf-8")):
-                    elapsed = time.perf_counter() - start
-                    rate = counter.rate(attempts)
-                    return CrackResult(True, candidate, attempts, elapsed, rate)
-            elif algorithm == "argon2":
-                hasher, verify_mismatch, invalid_hash = argon2_verify
-                try:
-                    hasher.verify(target_hash, candidate)
-                    elapsed = time.perf_counter() - start
-                    rate = counter.rate(attempts)
-                    return CrackResult(True, candidate, attempts, elapsed, rate)
-                except (verify_mismatch, invalid_hash):
-                    pass
-            elif algorithm == "scrypt":
-                n, r, p, salt_bytes, digest = scrypt_params
-                value = hashlib.scrypt(candidate.encode("utf-8"), salt=salt_bytes, n=n, r=r, p=p, dklen=len(digest))
-                if value == digest:
+    if workers > 1:
+        prefixes = list(charset)
+        futures = []
+        with ProcessPoolExecutor(max_workers=workers) as executor:
+            for length in range(min_len, max_len + 1):
+                batch: List[str] = []
+                for prefix in prefixes:
+                    batch.append(prefix)
+                    if len(batch) >= 50:
+                        futures.append(
+                            executor.submit(
+                                _bruteforce_worker,
+                                batch,
+                                target_hash,
+                                algorithm,
+                                charset,
+                                length,
+                                salt,
+                                salt_mode,
+                            )
+                        )
+                        batch = []
+                if batch:
+                    futures.append(
+                        executor.submit(
+                            _bruteforce_worker,
+                            batch,
+                            target_hash,
+                            algorithm,
+                            charset,
+                            length,
+                            salt,
+                            salt_mode,
+                        )
+                    )
+
+            for future in as_completed(futures):
+                found, count = future.result()
+                attempts += count
+                if progress_callback:
+                    progress_callback(count)
+                if found:
                     elapsed = time.perf_counter() - start
                     rate = counter.rate(attempts)
-                    return CrackResult(True, candidate, attempts, elapsed, rate)
-            elif algorithm in {"mssql2005", "mssql2012"}:
-                digest = hashlib.sha1(mssql_salt + candidate.encode("utf-16le")).hexdigest().upper()
-                if target_hash.lower().startswith("0x0100") and target_hash[14:].upper() == digest:
+                    return CrackResult(True, found, attempts, elapsed, rate)
+                if attempts % 1000 == 0:
+                    counter.rate(attempts)
+    else:
+        for length in range(min_len, max_len + 1):
+            for combo in itertools.product(charset, repeat=length):
+                attempts += 1
+                if progress_callback:
+                    progress_callback(1)
+                candidate = "".join(combo)
+                if algorithm == "bcrypt":
+                    if bcrypt is None:
+                        raise ValueError("bcrypt library is required for bcrypt cracking")
+                    if bcrypt.checkpw(candidate.encode("utf-8"), target_hash.encode("utf-8")):
+                        elapsed = time.perf_counter() - start
+                        rate = counter.rate(attempts)
+                        return CrackResult(True, candidate, attempts, elapsed, rate)
+                elif algorithm == "argon2":
+                    hasher, verify_mismatch, invalid_hash = argon2_verify
+                    try:
+                        hasher.verify(target_hash, candidate)
+                        elapsed = time.perf_counter() - start
+                        rate = counter.rate(attempts)
+                        return CrackResult(True, candidate, attempts, elapsed, rate)
+                    except (verify_mismatch, invalid_hash):
+                        pass
+                elif algorithm == "scrypt":
+                    n, r, p, salt_bytes, digest = scrypt_params
+                    value = hashlib.scrypt(candidate.encode("utf-8"), salt=salt_bytes, n=n, r=r, p=p, dklen=len(digest))
+                    if value == digest:
+                        elapsed = time.perf_counter() - start
+                        rate = counter.rate(attempts)
+                        return CrackResult(True, candidate, attempts, elapsed, rate)
+                elif algorithm in {"mssql2005", "mssql2012"}:
+                    digest = hashlib.sha1(mssql_salt + candidate.encode("utf-16le")).hexdigest().upper()
+                    if target_hash.lower().startswith("0x0100") and target_hash[14:].upper() == digest:
+                        elapsed = time.perf_counter() - start
+                        rate = counter.rate(attempts)
+                        return CrackResult(True, candidate, attempts, elapsed, rate)
+                elif hash_text(candidate, algorithm, salt, salt_mode) == target_hash:
                     elapsed = time.perf_counter() - start
                     rate = counter.rate(attempts)
                     return CrackResult(True, candidate, attempts, elapsed, rate)
-            elif hash_text(candidate, algorithm, salt, salt_mode) == target_hash:
-                elapsed = time.perf_counter() - start
-                rate = counter.rate(attempts)
-                return CrackResult(True, candidate, attempts, elapsed, rate)
-            if attempts % 1000 == 0:
-                counter.rate(attempts)
+                if attempts % 1000 == 0:
+                    counter.rate(attempts)
 
     elapsed = time.perf_counter() - start
     rate = counter.rate(attempts)

package/hashsmith/cli.py

@@ -261,7 +261,7 @@ def build_parser() -> argparse.ArgumentParser:
     crack_params.add_argument("-x", "--max-len", type=int, default=4)
     crack_params.add_argument("-s", "--salt", default="")
     crack_params.add_argument("-S", "--salt-mode", default="prefix", choices=["prefix", "suffix"])
-    crack_params.add_argument("-p", "--workers", type=int, default=0, help="Parallel workers for dictionary attack (0=auto)")
+    crack_params.add_argument("-p", "--workers", type=int, default=0, help="Parallel workers for cracking (0=auto)")
 
     interactive_parser = subparsers.add_parser(
         "interactive",
@@ -519,6 +519,10 @@ def handle_crack(args: argparse.Namespace, console: Console, accent: str = "cyan
             progress.stop()
             raise
     else:
+        if args.workers < 1:
+            args.workers = os.cpu_count() or 1
+        if args.type == "bcrypt" and args.workers > 1:
+            console.print("[yellow]bcrypt is CPU-expensive; multi-processing may not scale well.[/yellow]")
         total = 0
         charset_len = len(args.charset)
         for length in range(args.min_len, args.max_len + 1):
@@ -552,6 +556,7 @@ def handle_crack(args: argparse.Namespace, console: Console, accent: str = "cyan
                         max_len=args.max_len,
                         salt=args.salt,
                         salt_mode=args.salt_mode,
+                        workers=args.workers,
                         progress_callback=progress_callback,
                     )
                 finally:

package/hashsmith.tar.gz

@@ -0,0 +1 @@
+Not Found

package/hashsmith_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hashsmith-cli
-Version: 0.1.0
+Version: 0.1.1
 Summary: Hashsmith CLI for encoding, decoding, hashing, and cracking
 Home-page: https://github.com/salihsefer36/Hashsmith
 Author: Salih Sefer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hashsmith-cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Modular toolkit for encoding, hashing, and cracking.",
   "main": "bin/index.js",
   "bin": {

package/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = hashsmith-cli
-version = 0.1.0
+version = 0.1.1
 description = Hashsmith CLI for encoding, decoding, hashing, and cracking
 long_description = file: README.md
 long_description_content_type = text/markdown