Read the original article here.

---

Dictionary Attacks: Exploiting Human Predictability in Passwords

Welcome, aspiring digital locksmiths and code whisperers, to another dive into the methods often left out of standard textbooks. In the world of security, understanding how systems are broken is just as crucial as knowing how to build them. Today, we dissect the Dictionary Attack, a foundational technique that preys on a vulnerability far more common than any zero-day exploit: human nature and predictable password choices.

While seemingly simple, mastering the nuances of dictionary attacks, understanding their effectiveness, and knowing their limitations is a critical skill for anyone venturing into penetration testing, security auditing, or simply wanting to grasp the realities of online security.

---

What is a Dictionary Attack?

A Dictionary Attack is a type of attack in cryptanalysis and computer security that attempts to defeat a cipher or authentication mechanism by systematically trying a predetermined list of possibilities. Unlike a brute-force attack that tries all possible combinations, a dictionary attack restricts its efforts to a subset of the keyspace, focusing on the most likely candidates, often derived from common words, phrases, or previously leaked credentials.

Think of it like trying to guess a combination lock, but instead of trying every single number from 000 to 999, you start by trying numbers like 111, 123, 777, 911, or maybe birthdays – the numbers people are most likely to choose. In the digital realm, this "likely list" is the "dictionary."

---

The Core Technique: How It Works

At its heart, a dictionary attack is straightforward:

1. Obtain a "Dictionary": This is a list of potential passwords. Originally, this meant using actual dictionaries of words in various languages. However, the term has evolved significantly. Modern "dictionaries" are far more potent.
2. Target the Authentication Mechanism: This could be a login form (web, SSH, FTP), a password-protected file (like a ZIP archive), a hashed password database obtained from a breach, or a wireless network key.
3. Iterate and Attempt: The attack software or script takes each entry from the dictionary list and attempts to use it as the password or key.

The Modern "Dictionary"

The lists used today are vastly more powerful than simple word lists:

• Actual Word Dictionaries: Still a basic starting point.
• Lists from Data Breaches: This is where the real power lies. Billions of passwords, often including variations and common patterns, have been leaked over the years (e.g., the RockYou list, millions from LinkedIn, etc.). These lists contain passwords that people actually use.
• Common/Default Passwords: Lists of default router passwords, common manufacturer codes, etc.
• Pattern-Generated Lists: Cracking software doesn't just try the list as-is. It often applies rules and common variations to the dictionary entries.

Common Variations Applied by Cracking Software

Sophisticated tools automate the process and generate permutations based on observed user habits. These include:

• Case Changes: Password, password, PASSWORD.
• Number Substitution (Leet Speak): password -> pa55word, p455w0rd. Replacing a with 4, e with 3, i with 1, o with 0, s with 5, t with 7, etc.
• Appending/Prepending Digits or Symbols: password1, 123password, password!, !password!.
• Replacing Spaces with Symbols: my password -> my_password, my-password.
• Combining Words: wordone + wordtwo -> wordonetwo.
• Capitalizing First Letter: password -> Password.

Example Scenario:

Imagine trying to crack a user's password on a web application. You suspect they used a common word with a slight modification. Your dictionary list might contain just the word "hunter2". A dictionary attack tool wouldn't just try "hunter2". It would also likely try:

• Hunter2
• HUNTER2
• hunteR2
• h@nter2
• hunt3r2
• hunter2!
• 1hunter2
• hunter2123

...and potentially hundreds or thousands of other variations derived from the base word and common patterns. If the user's password is Hunter2!, a simple wordlist wouldn't find it, but a dictionary attack with variation rules likely would.

---

Why Dictionary Attacks Are Often Successful

The success of dictionary attacks hinges on one primary factor: human predictability and laziness when creating passwords.

• Cognitive Ease: People tend to choose passwords that are easy to remember. This naturally leads to using familiar words, names, dates, or simple sequential patterns.
• Commonality: Many users will simply pick a password from the top of a list of most commonly used passwords (e.g., 123456, password, qwerty). If you use a dictionary derived from leaked passwords, you're effectively trying the most common keys in the world.
• Simple Variations: When forced to make passwords more complex, users often resort to the same predictable variations (appending 1!, capitalizing the first letter) that dictionary attack tools are specifically programmed to generate.

Because such a large percentage of users fall into these traps, a dictionary attack, despite not covering the entire keyspace, stands a very high chance of guessing a common or slightly varied password relatively quickly.

---

Advanced Techniques: The Time-Space Tradeoff

When attacking hashed passwords obtained offline (e.g., from a database breach), continuously calculating the hash for every dictionary word for every target hash can still be time-consuming, especially with slow hashing algorithms. This led to Pre-computed Dictionary Attacks, the most famous variant being Rainbow Tables.

Pre-computed Dictionary Attack / Rainbow Table Attack: This technique involves calculating the hashes of a large list of potential passwords before the actual attack begins. These pre-computed hash -> password mappings are stored, often in optimized formats like Rainbow Tables. When an attacker obtains a list of target hashes, they can then quickly look up these hashes in their pre-computed database to find the corresponding plaintext password, significantly speeding up the cracking process for many targets simultaneously.

Here's the breakdown:

1. Preparation (Offline):

   • Choose a dictionary or generate a list of potential passwords.
   • For each word in the list, calculate its hash using the target system's hashing algorithm.
   • Store the resulting hash -> password pair. Rainbow tables use clever mathematical functions to reduce storage requirements compared to simple hash lists, but the principle is the same: mapping hashes back to the original passwords.
   • This preparation can take significant time (days, weeks, or even months) and requires considerable storage space.

2. Attack (Offline):

   • Obtain a list of hashed passwords from a compromised system.
   • For each target hash, look it up in the pre-computed database.
   • If a match is found, the corresponding password is retrieved almost instantly.

Example:

Suppose you get a database of 10,000 hashed passwords from a breach, and the system used MD5.

• Standard Dictionary Attack (Offline): You take a dictionary of 1 million words. For the first target hash, you hash all 1 million words and compare. If no match, you do the same for the second target hash, and so on. Total hashes calculated: 10,000 targets * 1,000,000 words = 10 billion hashes.
• Pre-computed Dictionary Attack: You calculate the MD5 hash for your 1 million words once and store them (or use a Rainbow Table). Now, for each of the 10,000 target hashes, you perform a fast database lookup. Total hashes calculated (attack phase): 0. The work was done upfront.

This is a classic time-space tradeoff: spend a lot of time and space preparing the tables to save a lot of time during the attack, especially when cracking many passwords.

---

The Defense: Countermeasures Against Dictionary Attacks

Knowing how the attack works is the first step to defending against it. Effective countermeasures target the attack's core assumptions and mechanisms:

1. User Education and Strong Password Policies:

   • Encourage Long Passwords/Passphrases: Passwords of 15 characters or more, especially using combinations of multiple unrelated words (passphrases), are exponentially harder to guess with a dictionary attack.
   • Discourage Predictable Patterns: Advise users against using common words, personal information, sequential numbers, or simple variations.
   • Use Password Managers: Password managers can generate long, random, unique passwords for each service, completely bypassing the predictability dictionary attacks rely on.

2. Server-Side Protections (Online Attacks):

   • Rate Limiting: Implement limits on the number of failed login attempts from a single IP address or account within a certain timeframe. After a few failures, lock the account or introduce delays. This makes trying thousands or millions of dictionary words impractically slow for online attacks.
   • Account Lockout: Temporarily or permanently lock accounts after excessive failed attempts.

3. Server-Side Protections (Offline Attacks Against Hashes):

   • Use Strong, Computationally Expensive Hashing Algorithms: Traditional fast hashes like MD5 and SHA are vulnerable because the attacker can calculate billions of hashes per second offline. Password-hashing functions like bcrypt, scrypt, and Argon2 are designed to be intentionally slow and memory-intensive. This makes offline dictionary attacks (and brute-force attacks) much more time-consuming and expensive for the attacker, even with powerful hardware.

     Hashing: The process of transforming data (like a password) into a fixed-size string of characters (a hash or digest). A good cryptographic hash function is designed to be a one-way process (hard to get the original data from the hash) and produce drastically different hashes for even slightly different inputs.

     Password-Hashing Function: A specialized type of hashing algorithm designed specifically for securely storing passwords. Unlike general-purpose hashes (like SHA-256), they are designed to be computationally expensive (slow) and often memory-intensive to make brute-force and dictionary attacks against the hashes infeasible.

   • Key Stretching: For older systems or as an additional layer with faster hashes, you can apply the hashing function multiple times to the input password (iterative hashing). This makes each password attempt by the attacker take longer.

     Key Stretching: The process of repeatedly applying a cryptographic hash function or a Key Derivation Function (KDF) to an input password or key. This increases the time required to test each potential key, making brute-force attacks more difficult.

   • Salting: This is a critical defense against pre-computed dictionary attacks (Rainbow Tables). A unique, random piece of data (the salt) is generated for each password and stored alongside the hash. When hashing a password, the salt is combined with the password before hashing.

     Salting: The technique of adding a unique, random value (the "salt") to a password before hashing it. This ensures that identical passwords used by different users will produce different hashes, and more importantly, it forces an attacker using pre-computation (like Rainbow Tables) to generate a separate pre-computed table for each unique salt encountered, making the approach infeasible if the salt space is large enough.

     Why Salting Works Against Pre-computation: If an attacker uses a pre-computed table to find the hash of "password", they look for the hash H(password). But if the system salts, it stores H(password + salt). Since the salt is unique for each user, H(password + salt_A) will be different from H(password + salt_B). A pre-computed table mapping H(word) to word is useless. The attacker would need a table mapping H(word + salt_A) to word, H(word + salt_B) to word, and so on for every unique salt. This requires generating a separate, massive pre-computed table for every salt, which is practically impossible when salts are large and random.

---

Tools of the Trade

Understanding the theory is one thing; seeing it in action requires tools. Many password cracking tools incorporate dictionary attack capabilities alongside brute-force methods. Some notable examples (often used for security auditing and penetration testing) include:

• John the Ripper: A powerful, fast, and flexible password cracker.
• Hashcat: Known for being the world's fastest password recovery tool, highly optimized for GPUs.
• Cain and Abel (Windows only, older): Comprehensive password recovery tool.
• Aircrack-ng: Primarily used for cracking wireless network keys.
• Ophcrack: Specializes in cracking Windows LM hashes (historically vulnerable, but good for demonstration).
• L0phtCrack (Commercial): Another robust password auditor and cracker.
• Metasploit Project: A powerful penetration testing framework that includes modules for dictionary attacks against various services.
• Cryptool: An educational tool for exploring cryptographic concepts, often includes password cracking demos.

These tools often allow users to load custom dictionary files and configure complex rule sets for generating variations, demonstrating the techniques discussed earlier.

---

Dictionary Attacks vs. Brute-Force Attacks

It's important to distinguish dictionary attacks from brute-force attacks, though they are often used in combination:

Brute-Force Attack: An attack that attempts to defeat a cipher or authentication mechanism by systematically trying every possible combination of characters (within a defined character set and length).

• Scope: Dictionary attacks explore a limited subset of the keyspace (likely passwords). Brute-force attacks explore the entire keyspace.
• Speed: Dictionary attacks are much faster if the password (or a common variation) is in the dictionary list, as they try fewer possibilities. Brute-force attacks are much slower but are guaranteed to find the password eventually, given enough time and computational power, because they try every single possibility.
• Effectiveness: Dictionary attacks rely on user predictability. Brute-force attacks rely purely on computational power and the password's length/complexity.
• Typical Usage: Often, an attacker will try a dictionary attack first (it's faster and has a high success rate against weak passwords). If that fails, they might resort to a brute-force attack, possibly starting with a smaller character set or length.

---

Conclusion: The Unseen Threat

Dictionary attacks represent a fundamental technique in password cracking. They are not complex cryptography; they are an exploitation of human behavior and pattern. Understanding how they work, the types of lists and variations used, and how pre-computation and salting impact their effectiveness is crucial for anyone securing systems or evaluating their security posture.

The "Forbidden Code" isn't always about arcane exploits; sometimes, it's simply about recognizing and leveraging the most common vulnerabilities – the ones we ourselves introduce through predictable choices. By understanding the dictionary attack, you gain insight into why strong, unique, and long passwords (especially when combined with robust server-side hashing and salting) are the first and often best line of defense.