Hashcracky Guide

Hashing Foundations

Hashing is a fundamental concept in cybersecurity and is the result of a one-way algorithm to transform plaintext into ciphertext. The act of hash cracking is replicating the one-way transformation with known plaintexts to identify a match in ciphertext. If the ciphertext matches, then the plaintexts probably also match.

$ password="password"
$ salt="test"
$ echo -n "${salt}${password}" | openssl dgst -sha256
SHA2-256(stdin)= 9f735e0df9a1ddc702bf0a1a7b83033f9f7153a00c29de82cedadc9957289b05

$ mkpasswd --method=sha256crypt --rounds=1000 --salt=12324566 password
$5$rounds=1000$12324566$9KqrHsJ9mSQJMYBJ0iBLSN4gZaOOPWGbD2NuKz4K1XC

$ mkpasswd --method=sha256crypt --rounds=2000 --salt=12324566 password
$5$rounds=2000$12324566$UpQkGap2msCkdYtu21Va3uEX4Va7vAbyHtX22psDFn7

$ message="The quick brown fox jumps over the lazy dog"
$ key="key"
$ printf "%s" "$message" | openssl dgst -sha256 -hmac "$key"
HMAC-SHA256(stdin)= f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8

$ plaintext="password"; hash="$plaintext"; for i in {1..5}; do hash=$(printf %s "$hash" | md5sum | awk '{print $1}'); printf "Iteration %d: %s\n" "$i" "$hash"; done
Iteration 1: 5f4dcc3b5aa765d61d8327deb882cf99
Iteration 2: 696d29e0940a4957748fe3fc9efd22a3
Iteration 3: 5a22e6c339c96c9c0513a46e44c39683
Iteration 4: e777a29bee9227c8a6a86e0bad61fc40
Iteration 5: 7b3b4de00794a247cf8df8e6fbfe19bf

Getting Started with Hash Cracking

We highly recommend learning the basics of command line interfaces (CLI). Many tasks are easier via CLI, and it’s the fastest way to iterate on cracking strategies. We recommend Hashcat:

• Hashcat — powerful, open-source, supports a wide range of algorithms
• Hashcat Utils — companion utilities

Identify the Hash Type

$ hashcat hashes.left --identify

Start Cracking

Choose an attack based on the pattern being replicated. Hash cracking is cyclical and incorporates new data, tuning attacks, and maximizing work sent to the GPU.

$ hashcat -m 1300 -a 0 hashes.left wordlist.txt
$ hashcat -m 17300 -a 0 hashes.left rules.txt
$ hashcat -m 17700 -a 3 hashes.left ?l?l?l?l?l?l

Helpful Hashcat Flags

• -O (--optimized-kernel-enable): Use optimized kernels if available. This reduces the maximum candidate length but increases speed.
• --bitmap-max=28: Expands the bitmap to a larger amount, likely increasing attack speed.
• --restorefile-path & --session: Keeps a session log file for the task to be resumed if interrupted.
• --loopback: Once a session ends, go back over new founds with the same rules used.
• --show & --left: Good for collecting founds, lefts, and removing bad hashes.

Separating Hashes and Plains

$ awk -F ':' '{print $NF}' file > plaintext.txt
$ cut -d ':' -f2- file > plaintext.txt

Understanding Attack Types

One of the primary goals of hash cracking is replicating human transformations in a computationally effective manner. There are many ways to reach the same plaintext, but only a subset are efficient. Focus on the methodology and patterns; tools are a means to enact strategy.

Dictionary (Straight) Attacks

Use a wordlist of base words, known plaintexts, or common passwords. Often paired with rules to transform candidates. In Hashcat, this is -a 0.

$ hashcat -m 0 -a 0 hashes.txt wordlist.txt
$ hashcat -m 0 -a 0 hashes.txt wordlist.txt -r rule-file.txt

Combination Attacks

Concatenate two lists (optionally apply rules to each side). In Hashcat, this is -a 1. See also combinator from hashcat-utils for writing combined lists to disk.

$ hashcat -m 0 -a 1 hashes.txt wordlist1.txt wordlist2.txt
$ hashcat -m 0 -a 1 hashes.txt wordlist1.txt wordlist2.txt -j "\$\$a\$n\$d\$ :"
$ hashcat -m 0 -a 1 hashes.txt wordlist1.txt wordlist2.txt -k "sa4se3so0"

Brute Force (Mask) Attacks

Try all candidates in a keyspace. In Hashcat, this is -a 3. Use masks and custom charsets to constrain and accelerate search.

$ hashcat -m 0 -a 3 hashes.txt ?l?l?l?l?l?l
$ hashcat -m 0 -a 3 hashes.txt ?d?d?d?d?d?d
$ hashcat -m 0 -a 3 hashes.txt ?u?u?u?u?u?u
$ hashcat -m 0 -a 3 hashes.txt ?a?a?a?a?a?a -i
$ hashcat -m 0 -a 3 hashes.txt ?1?1?1?1?1?1 -1 \?l\?d
$ hashcat -m 0 -a 3 hashes.txt short.mask

Hybrid Attacks

Combine dictionary and mask. In Hashcat this is -a 6 (right) and -a 7 (left).

$ hashcat -m 0 -a 6 hashes.txt wordlist.txt ?d?d?d?d
$ hashcat -m 0 -a 7 hashes.txt ?d?d?d?d wordlist.txt
$ hashcat -m 0 -a 6 hashes.txt wordlist.txt ?l?l?l?l
$ hashcat -m 0 -a 7 hashes.txt ?l?l?l?l wordlist.txt
$ hashcat -m 0 -a 6 hashes.txt ?1?1?1?1?1?1 -1 \?l\?d
$ hashcat -m 0 -a 7 hashes.txt ?1?1?1?1?1?1 wordlist.txt -1 \?l\?d
$ hashcat -m 0 -a 6 hashes.txt wordlist.lst ?a?a?a -i
$ hashcat -m 0 -a 7 hashes.txt ?a?a?a wordlist.lst -i

Association Attacks (-a 9)

Association attacks excel when there is a large amount of unique salts to work this. This is because it removes the iteration through the different salts and “asserts” a plaintext belongs to a specific hash:salt combination.

• By default, -a9 mode does not use the potfile and output needs to be directed.
• The number of candidates is more limited due to leaning on rules, and only so many can be loaded at once.
• The attack requires some pre-processing to get everything into the right format.
• Every item in the left list must have a 1-1 pair in the wordlist.
• Very specific use cases but can increase speeds dramatically because it is a different attack architecture.

$ hashcat -a9 left.lst single-word.lst -r rules.rule -o a9-algo.potfile
$ hashcat -a9 left.lst blank-lines.lst -r words.rule -r rules.rule -o a9-algo.potfile

Understanding Rules

Rules are ran on the GPU and maximize throughput. They can be stacked for complex transforms. In Hashcat, apply with -r.

$ hashcat -m 0 -a 0 hashes.txt wordlist.txt -r best64.rule
$ hashcat -m 0 -a 0 hashes.txt wordlist.txt -r OneRuleToRuleTheMall.rule
$ hashcat -m 0 -a 0 hashes.txt wordlist.txt -r append.rule -r toggle.rule
$ hashcat -m 0 -a 0 hashes.txt wordlist.txt -r prepend-toggle.rule -r leetspeak.rule
$ hashcat -m 0 -a 0 hashes.txt wordlist.txt \
  --generate-rules=50000 --generate-rules-func-min=3 --generate-rules-func-max=3 \
  --generate-rules-func-sel=ioyrzZ+[]{}* --loopback

Common rule primitives:

• : Do nothing (pass through).
• l Lowercase candidate.
• u Uppercase candidate.
• c Capitalize first letter, lowercase rest.
• Tn Toggle case at position n.
• ^x Prepend x.
• $x Append x.
• [ Truncate left.
• ] Truncate right.
• inx Insert x at position n.
• onx Overwrite at position n with x.
• sxy Substitute x with y everywhere.
• 'n Truncate to n characters.
• @n Purge all instances of character n.
• E (ex) Title case after every space or every character x.
• Dn Delete character at position n.
• d Duplicate candidate.

Example to add "TEST" to the front and back of each candidate:

^T ^E ^S ^T
$T $E $S $T

Understanding Masks

Masks specify a character class at each position. They’re ideal for modeling structures and narrowing keyspaces.

• ?l abcdefghijklmnopqrstuvwxyz
• ?u ABCDEFGHIJKLMNOPQRSTUVWXYZ
• ?d 0123456789
• ?h 0123456789abcdef
• ?H 0123456789ABCDEF
• ?s space»!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
• ?a ?l?u?d?s
• ?1 0x00–0xff (custom when defined)

Examples for “Hashcracky123!”:

?u?l?l?l?l?l?l?l?l?l?d?d?d?s
Hashcracky?d?d?d?s
Hashcracky?1?1?1?s -1 \?d
?1?1?1?1?1?1?1?1?1?1?d?d?d?s -1 \?l\?u\?d\?s
?1?1?1?1?1?1?1?1?1?1?2?2?2?2 -1 \?l\?u -2 \?d\?s

Introduction to Analysis

Analysis identifies patterns, trends, and anomalies. In Hashcracky, analysis can help reveal common sources or theme patterns per list. Capture Hashcat debug output to see which rules and candidates perform the best.

$ hashcat -m 0 -a 0 hashes.txt wordlist.txt --debug-mode=1 --debug-file=data.debug

Hashcat debug modes:

• 1: Finding-Rule
• 2: Original-Word
• 3: Original-Word:Finding-Rule
• 4: Original-Word:Finding-Rule:Processed-Word
• 5: Original-Word:Finding-Rule:Processed-Word:Wordlist

Frequency sort to find common entries:

awk '{freq[$0]++} END {for (line in freq) print freq[line], line}' data.debug | sort -nrk1

Defending Applications

• Argon2id for systems that can tolerate authentication latency. Argon requires multiple tuning factors that need to be adjusted to maintain security. This is not a user friendly strategy but offers more customization for domain experts.
• HMAC-Bcrypt for legacy systems and systems that cannot tolerate any authentication latency. Bcrypt has a single cost-factor that controls the number of iterations. This is a user friendly strategy for increasing algorithm strength.
• PBKDF2 for FIPS-140 compliance requirements with a strong iteration count depending on the implemented algorithm.
• Non-salted algorithms should always have a pepper or salt used to prevent shucking. For example, nesting Bcrypt(md5(password)) without a salt or a pepper means a user can use known MD5 hashes and somewhat reduce calculations. Shucking is also prevalent in NTLMv1 with serious impacts on the security of its usage.