The pursuit of recovering passwords stored within the labyrinthine constructs of computer system s is a field that straddles the realms of both defensive computer security and offensive cryptanalysis . This process, rather unglamorously termed password cracking, fundamentally involves the rather tedious, yet often disturbingly effective, act of guessing passwords [1]. It’s a testament to human predictability and the inherent vulnerabilities of digital fortifications.

One of the more straightforward, albeit resource-intensive, methods is the brute-force attack . This approach operates with the subtle elegance of a sledgehammer: it relentlessly tries every conceivable combination of characters until, by sheer statistical inevitability, it stumbles upon the correct password. The efficacy of such an attack is often amplified when an attacker has managed to procure a cryptographic hash of the password. With this hash in hand, the attacker can perform an unlimited number of offline guesses, checking each against the hash without fear of detection or lockout [2]. It’s akin to having the lock’s blueprint, allowing for endless attempts in privacy.

A more insidious, and frankly, more intelligent, variant of password guessing is known as password spraying. This technique eschews the noisy, rapid-fire approach of brute force against a single account. Instead, it systematically attempts a small number of extremely common passwords across a vast multitude of accounts. The automation involved is typically designed to operate at a glacial pace, allowing significant time to elapse between attempts on any single account, thereby cunningly evading common detection mechanisms and account lockout policies [3]. This method preys on the widespread human tendency to select weak, easily guessable passwords, but it does so without drawing undue attention to itself, making it a particularly frustrating adversary. It doesn’t bother with targeting specific accounts; it merely casts a wide net, expecting to catch a distressingly large number of victims.

The motivations behind engaging in password cracking are, predictably, varied. On the more benign (or perhaps just less malevolent) end of the spectrum, it can be a means to assist a user in the recovery of a forgotten password. One might think it simpler to just reset the password, but that often necessitates the elevated privileges of a system administrator , making recovery a more complex administrative hurdle than it should be. Conversely, and far more frequently, the purpose is overtly malicious: to gain unauthorized access to a system, a network, or sensitive data. However, password cracking also serves a crucial defensive role. System administrators routinely employ these techniques as a preventive measure, auditing their own systems to identify and address easily crackable passwords before a malicious actor does. Furthermore, in the realm of digital forensics, password cracking is indispensable for gaining access to encrypted files or restricted digital evidence, particularly when judicial authorization has been granted.

It’s a common misconception that online brute-force attacks are universally effective. Systems, with a modicum of foresight, are generally engineered with countermeasures such as account lockouts after a predetermined number of failed login attempts. This renders direct, rapid-fire online guessing largely futile. The real danger materializes when attackers manage to obtain the cryptographic hash of the password. These hash files, which are essentially one-way mathematical representations of the original password, can be acquired through various channels: they might be legally compelled via court order, or, far more commonly, they are illegally exfiltrated as part of a significant data breach . Once these hashes are obtained, the attacker can then perform an effectively unlimited number of offline guesses, free from the constraints of network latency, rate limiting, or account lockouts. The peril is further compounded by the regrettable human habit of password reuse across multiple web sites. A hash file purloined from one less-secure service can be cracked offline, and the resulting plaintext password then attempted against the same email addresses on numerous other, potentially more critical, platforms. It’s a domino effect, powered by human convenience and organizational negligence.

As mentioned, the password spraying methodology is particularly adept at circumventing those account lockout countermeasures designed to thwart traditional brute-force attempts. By distributing attempts of the same common password across a large number of distinct accounts, and crucially, by introducing significant time delays between successive attempts on any single account, it allows the attacker to remain largely under the radar. These delays can even be designed to coincide with legitimate login patterns, further masking the malicious activity. This isn’t about targeting a specific individual; it’s about finding the weakest link in a large chain, capitalizing on the statistical certainty that somebody will have chosen a predictable password.

Time needed for password searches

The clock, it seems, is always ticking faster than you’d like when it comes to the security of your digital keys. The time required to successfully crack a password isn’t a simple calculation; it’s a complex interplay of the password’s inherent strength, often quantified as its entropy or “bit strength,” and the precise, often idiosyncratic, mechanisms by which that password is stored and processed by the system. Most methodologies for password cracking, at their core, involve a computer laboriously generating a massive volume of candidate passwords, each of which must then be meticulously checked against the target.

Consider the blunt instrument that is brute-force cracking: a machine, with no subtlety whatsoever, systematically tries every single possible key or password until, with an almost mechanical sigh of success, it finally hits the right one. This process, while conceptually simple, can be optimized through parallel processing. With multiple computational units, the search space can be divided, allowing different processors to tackle different segments simultaneously. For instance, some might search from the beginning of the character set, others from the end, and still others within designated, overlapping or unique, selections of possible passwords [4]. This parallelization significantly compresses the time required, transforming what might be an astronomical individual effort into a mere gargantuan collective one.

However, brute force is rarely the first resort. More intelligent, and often far more efficient, methods of password cracking exist, which aim to drastically reduce the number of necessary guesses. These include dictionary attacks , which leverage vast databases of common words, names, and phrases; pattern checking, which exploits predictable human tendencies like sequential numbers or keyboard patterns; and variations of common words, incorporating substitutions (like ‘E’ for ‘3’) or appended numbers. These methods are invariably attempted prior to resorting to the exhaustive, and often prohibitively time-consuming, brute-force approach. The fundamental truth remains: a higher password bit strength, which is a direct measure of its entropy , exponentially increases the average number of candidate passwords that must be checked. This, in turn, dramatically reduces the probability that the password will be found within any pre-computed cracking dictionary, making the attacker’s task exponentially more difficult [5]. It’s a simple mathematical reality, yet one so often ignored.

The speed at which passwords succumb to these digital sieges is also profoundly influenced by the sheer computational power available to the attacker, specifically, the number of possible passwords a computer program can test per second. If an attacker possesses the hash of the target password, enabling an offline attack, this rate can soar into the staggering billions or even trillions of guesses per second. Without such direct access, the cracking rate is dictated by the defensive mechanisms of the authentication software itself. These often include deliberate time delays between login attempts, the introduction of visual puzzles like CAPTCHAs to verify human interaction, or, as a last resort, forced account lockouts after a certain threshold of failed attempts. Another scenario where rapid guessing becomes feasible is when the password isn’t merely for authentication but is used to derive a cryptographic key . In such instances, an attacker can quickly verify a guessed password by attempting to decrypt data; success or failure provides immediate feedback, circumventing rate limits.

The raw computational horsepower of even ordinary desktop computers is, frankly, alarming. For certain types of password hashes, these machines, when running specialized password cracking tools on their general-purpose central processing units (CPUs), can test over a hundred million passwords every second. When the workload is shifted to graphics processing units (GPUs), which are inherently designed for parallel computation, this rate can skyrocket into the billions of passwords per second [1] [6] [7]. A quick glance at John the Ripper benchmarks [8] will confirm this unsettling reality. The actual rate of password guessing is critically dependent on the specific cryptographic function employed by the system to generate and store password hashes. A robust, purpose-built password hashing function, such as bcrypt , offers orders of magnitude more resistance than a poorly implemented or naive function like a simple MD5 or a generic SHA . Consider a user-selected eight-character password incorporating numbers, mixed-case letters, and symbols, and assuming it avoids common dictionary words or patterns. According to NIST , such a password might achieve an estimated 30-bit strength. While 2^30 permutations might sound substantial at one billion, it would be cracked in mere seconds if the underlying hashing function were naive [9]. When multiple ordinary desktop computers are conscripted into a collective cracking effort, often orchestrated via malicious botnets , the capabilities of password cracking are extended considerably, reaching truly formidable scales. A historical example from 2002 saw distributed.net successfully uncover a 64-bit RC5 key over a period of four years, an endeavor that harnessed the power of over 300,000 distinct computers at various points, collectively generating an average of over 12 billion keys per second [10].

The role of graphics processing units (GPUs) in accelerating password cracking cannot be overstated. These specialized processors can, for specific hashing algorithms, accelerate the cracking process by a factor of 50 to 100 compared to general-purpose CPUs. To put this into perspective, in 2011, commercially available products boasted the capability to test up to 2.8 billion NTLM passwords per second on a standard desktop computer equipped with a high-end graphics processor [11]. Such a device, a mere consumer-grade component, could conceivably crack a 10-letter, single-case password within a single day. The efficiency can be further amplified by distributing the workload across numerous computers, each housing comparable GPUs, leading to a proportional increase in overall cracking speed. However, it’s crucial to note that some cryptographic algorithms are deliberately designed to run slowly on GPUs, or simply don’t lend themselves well to GPU parallelization. Examples of these more resilient algorithms include DES , Triple DES , bcrypt , scrypt , and Argon2 , which often incorporate design elements that require sequential processing or significant memory access, thus thwarting the parallelization benefits of GPUs.

The relentless march of hardware acceleration , particularly within GPU architectures, has undeniably revolutionized the efficiency and speed of brute-force attacks across the majority of hashing algorithms. In 2012, the Stricture Consulting Group dramatically showcased this capability by unveiling a 25-GPU cluster. This formidable array achieved an astonishing brute-force attack speed of 350 billion NTLM password guesses per second. This allowed them to meticulously check 95^8 (approximately 6.63 x 10^14) password combinations in a mere 5.5 hours, a timeframe more than sufficient to crack all 8-character alpha-numeric-special-character passwords commonly deployed in enterprise environments. Utilizing ocl-Hashcat Plus on a Virtual OpenCL cluster platform [12], this Linux-based GPU cluster famously managed to “crack 90 percent of the 6.5 million password hashes belonging to users of LinkedIn ” [13] following a significant data breach. It served as a stark, public demonstration of the real-world vulnerability of even seemingly complex passwords when pitted against dedicated hardware.

For a select few, particularly stubborn, hashing algorithms, even the formidable power of CPUs and GPUs proves to be an inefficient match. In these specialized scenarios, purpose-made hardware becomes not just advantageous, but absolutely essential for achieving high cracking speeds. This custom hardware can be meticulously engineered using either FPGA (Field-Programmable Gate Array) or ASIC (Application-Specific Integrated Circuit) technology. The development overhead for both technologies is notoriously complex and exorbitantly expensive. Generally speaking, FPGAs are more cost-effective for smaller production quantities and offer greater flexibility for modification post-deployment. ASICs, on the other hand, are the choice for very large quantities, offering unparalleled energy efficiency and raw speed once designed and fabricated. A landmark achievement in this domain occurred in 1998 when the Electronic Frontier Foundation (EFF) constructed a dedicated password cracker utilizing ASICs. Their machine, aptly named Deep Crack , demonstrated its prowess by breaking a DES 56-bit key in a staggering 56 hours, all while testing over 90 billion keys per second [14]. More recently, in 2017, leaked documents provided a glimpse into the ongoing arms race, revealing that ASICs were being leveraged for a military project with the potential to compromise a significant portion of internet communications secured by weaker encryption standards [15]. The utility of these specialized hardware solutions continues to evolve; since 2019, John the Ripper has incorporated support for password cracking on a limited number of hashing algorithms using FPGAs [16], and commercial entities are now actively deploying FPGA-based setups for high-performance password cracking operations [17].

Easy to remember, hard to guess

It’s a rather depressing irony that the very measures intended to bolster password security often end up undermining it, largely due to the predictable, and frankly, lazy tendencies of human users. Passwords that are excessively difficult for a human to recall inevitably reduce the overall security posture of a system. This isn’t rocket science; it’s basic psychology.

The reasons for this self-sabotage are painfully clear:

• Users, faced with an unmemorable string of characters, will inevitably resort to insecure methods of storage. This could mean scribbling it on a sticky note attached to their monitor (a classic, for a reason), or saving it in an unencrypted digital document, effectively handing the key to any casual observer or digital intruder.
• The cognitive burden of complex, frequently changed passwords leads to an increased demand for password resets. Each reset is not just an administrative hassle, but a potential vector for social engineering or other vulnerabilities, as the recovery process itself can be exploited.
• Perhaps most critically, difficult passwords significantly increase the likelihood that users will succumb to the temptation of reusing the same password across multiple, disparate systems. This single act transforms a breach on one minor, inconsequential service into a potential compromise of every other account the user holds, an utterly catastrophic ripple effect.

It’s a pattern that security professionals observe with a weary sigh: the more stringent and inflexible the requirements for password strength—demands like “must contain a mix of uppercase and lowercase letters and digits” or the truly antiquated “must be changed monthly”—the greater the degree to which users will ingeniously, if inadvertently, subvert the system to make their lives easier [18]. They aren’t trying to be malicious; they’re simply trying to cope.

Research, such as the paper “The Memorability and Security of Passwords” [19] by Jeff Yan et al., has delved into the efficacy of common advice given to users regarding password selection. Their findings are illuminating: passwords constructed by conceiving a memorable phrase and then extracting the first letter of each word were found to be just as memorable as those chosen more intuitively, yet they offered a security posture comparable to randomly generated passwords. This technique creates a longer, more complex, and less predictable string while remaining anchored to a phrase a user can easily recall. Similarly, the simple act of combining two entirely unrelated words into a single, longer password also proved to be a robust method. For those with a more systematic bent, developing a personal, idiosyncratic “algorithm ” for generating obscure yet repeatable passwords can also be highly effective. These methods tap into the human capacity for narrative and association, rather than brute-force memorization.

However, the prevailing wisdom often falls short. Asking users to remember a password that is merely a “mix of uppercase and lowercase characters” is, from a cognitive standpoint, not far removed from asking them to recall a sequence of random bits. It’s an arduous task that yields only a marginal gain in security. For instance, for a 7-letter password, incorporating mixed cases might only make it 128 times harder to crack—a negligible increase in the face of modern cracking capabilities, and even less if the user simply capitalizes the first letter, a common and easily predictable pattern. The ubiquitous demand for “both letters and digits” frequently backfires, leading to entirely predictable and easily guessable substitutions, such as ‘E’ becoming ‘3’ or ‘I’ transforming into ‘1’. Attackers are intimately familiar with these common substitution patterns, rendering the “strength” illusory. Another painfully common, and equally ineffective, user trick known to attackers is shifting the entire password one keyboard row higher. These are not ingenious defenses; they are transparent tells.

Further research, notably a paper published in April 2015 by a team of professors at Carnegie Mellon University , starkly illustrates that human choices in password structure are far from random; they often conform to several well-documented, exploitable patterns. For example, when confronted with minimum length requirements, particularly those extending to 16 characters or more, users frequently resort to repeating characters or even entire words within their password constructs [20]. The tragic consequence of this behavior is that these seemingly “long” passwords become significantly easier to crack than their theoretical mathematical probabilities would suggest. Another telling pattern is the placement of digits: passwords containing a single digit are disproportionately likely to feature that digit at the very end of the string [20]. These are not minor quirks; they are fundamental flaws in human-generated randomness that attackers exploit with devastating efficiency.

Incidents

The history of password cracking is, unfortunately, replete with incidents that serve as stark reminders of persistent vulnerabilities and human fallibility. Each breach is a cautionary tale, often unheeded.

On July 16, 1998, a report from CERT detailed an alarming incident where an attacker had successfully acquired 186,126 encrypted passwords. By the time this breach was even detected, a substantial 47,642 of those passwords had already been cracked [21]. This early incident underscored the speed with which even encrypted credentials could be compromised, even with the relatively limited computational resources of the late 90s.

Fast forward to December 2009, and the internet witnessed a colossal password breach at Rockyou.com . This incident led to the public dissemination of an astounding 32 million passwords. The attacker, with a brazen disregard for privacy, leaked the complete list of these passwords (mercifully, without other identifiable user information) directly onto the internet. The root cause of this catastrophic failure was a fundamental lapse in security: passwords were stored in cleartext within the database, a practice so egregiously negligent it borders on self-sabotage. The data was exfiltrated via an SQL injection vulnerability, a common and well-understood attack vector that still, inexplicably, persists. The Imperva Application Defense Center (ADC) subsequently conducted a detailed analysis of the compromised passwords, revealing a disheartening pattern of weak choices [22]:

• Approximately 30% of users had chosen passwords with a length of fewer than seven characters, making them trivial to brute-force.
• Nearly 60% of users limited their password choices to a highly restricted set of alpha-numeric characters, further diminishing the entropy.
• A staggering 50% of users resorted to names, common slang, dictionary words, or utterly trivial constructs such as consecutive digits or adjacent keyboard keys. The most egregious, yet entirely predictable, example being “123456” as the most common password among RockYou account holders [22]. It’s a testament to humanity’s enduring capacity for choosing convenience over security.

June 2011 saw the North Atlantic Treaty Organization (NATO) suffer its own security breach, resulting in the public release of first names, last names, usernames, and passwords for over 11,000 registered users of their e-bookshop. This data dump was a component of Operation AntiSec , a broader movement encompassing various hacking collectives and individuals, including the notorious Anonymous and LulzSec groups [23].

Barely a month later, on July 11, 2011, Booz Allen Hamilton , a prominent American consulting firm with substantial contracts with the Pentagon , became the next high-profile victim. Its servers were compromised by Anonymous , and the stolen data was leaked on the same day. This incident, cynically dubbed “Military Meltdown Monday,” exposed 90,000 login credentials belonging to military personnel, including individuals from USCENTCOM , SOCOM , the Marine Corps , various Air Force facilities, Homeland Security , State Department staff, and private-sector contractors [24]. A subsequent analysis by the ADC team at Imperva revealed that these leaked passwords were hashed using unsalted SHA-1 , a fundamentally insecure practice that made them highly susceptible to cracking. Shockingly, even within this ostensibly secure environment, some military personnel were found to be using passwords as embarrassingly weak as “1234” [25]. The audacity of the attackers was matched only by the negligence of the victims.

In a rather belated and somewhat futile gesture, on July 18, 2011, Microsoft Hotmail finally banned the password “123456” [26]. One can only wonder what took them so long.

A more recent, and particularly infamous, incident occurred in July 2015, when a group identifying itself as “The Impact Team” orchestrated the massive Ashley Madison data breach . [27] This breach was a masterclass in exploiting flawed security practices. Many of the user passwords were, inexplicably, hashed using two different algorithms: the relatively robust bcrypt and the significantly weaker MD5 hash. This dual-hashing blunder proved fatal. By focusing their efforts on the less secure MD5 hashes, the password cracking group CynoSure Prime was able to recover an astonishing 11 million plaintext passwords [28]. It was a stark demonstration that even a single weak link in a security chain can compromise the entire system.

Prevention

The relentless, often exhausting, struggle to prevent password cracking is a perpetual arms race between those who seek to defend and those who seek to exploit. It’s a constant adaptation, an endless cycle of patching vulnerabilities only for new ones to emerge.

One foundational principle in preventing password cracking is to deny attackers access to the hashed passwords in the first place. Historically, on the Unix operating system , hashed passwords were stored in the publicly readable /etc/passwd file. This was, to put it mildly, a terrible idea. Modern Unix (and similar) systems have, thankfully, evolved. They now store these critical hashes in a dedicated shadow password file, typically /etc/shadow, which is accessible only to programs operating with enhanced, “system” level privileges. This architectural shift significantly raises the bar for a malicious user attempting to obtain hashed passwords directly. However, it’s a defense, not an impenetrable shield. Despite such protections, numerous collections of password hashes have, regrettably, been stolen, often through more sophisticated means of system compromise. Furthermore, the problem extends beyond local file storage; some alarmingly common network protocols continue to transmit passwords in cleartext or rely on notoriously weak challenge/response schemes, effectively broadcasting credentials to any eavesdropper [29] [30]. It’s like building a high wall around your house but leaving the front door wide open.

A critical, and now widely accepted, countermeasure is the judicious use of salt . A salt is a unique, random value that is generated for each individual password and then incorporated into its hashing process. This simple, yet profoundly effective, technique prevents attackers from efficiently mounting simultaneous attacks against multiple identical hashes. Crucially, it also thwarts the creation and utility of pre-computed dictionaries, such as rainbow tables , which rely on consistent hashes for common passwords. Without salt, a single pre-computed rainbow table could crack millions of passwords; with salt, each password effectively requires its own unique attack.

Beyond salting, another layer of defense involves combining a site-specific secret key with the password hash. The theoretical benefit here is that even if the hashed values are successfully purloined, the attacker would also need to acquire this secret key to recover the plaintext password. It’s a good idea in principle, but with a significant caveat: sophisticated privilege escalation attacks capable of stealing protected hash files may very well also expose the site’s secret key, rendering this additional layer moot. A more robust, and increasingly essential, approach is the implementation of key derivation functions (KDFs). These functions are specifically designed to intentionally slow down the rate at which passwords can be guessed, effectively making offline brute-force attacks computationally infeasible within reasonable timeframes [31] : 5.1.1.2 .

The evolution of password hashing on modern Unix systems reflects this ongoing arms race. They have wisely moved beyond the traditional DES -based crypt() function, adopting significantly stronger methods such as crypt-SHA , bcrypt , and scrypt [32]. Other systems have followed suit; for example, Cisco IOS , which once used a laughably reversible Vigenère cipher for password encryption, now employs md5-crypt with a robust 24-bit salt when the “enable secret” command is utilized [33]. These newer hashing methods are characterized by their use of large, random salt values, which effectively prevent attackers from mounting efficient offline attacks against multiple user accounts simultaneously. Furthermore, and critically, these algorithms are deliberately much slower to execute. This inherent computational cost drastically increases the time and resources required for a successful offline attack, making the attacker’s task exponentially more expensive and time-consuming [34].

The inherent design of many traditional cryptographic hashes used for password storage, such as MD5 and the various algorithms within the SHA family, is fundamentally problematic in the context of password security. They were engineered for speed of computation, minimal memory requirements, and efficient hardware implementation. While admirable goals for general hashing, these characteristics are a liability for password storage. Their speed and low resource demands mean that multiple instances of these algorithms can be run in parallel on graphics processing units (GPUs), accelerating cracking efforts to terrifying speeds. Consequently, these “fast” hashes are largely ineffective in preventing password cracking, even when combined with salt, because the sheer volume of attempts per second overwhelms any minor delays.

This is where key stretching algorithms come into play. Algorithms like PBKDF2 and crypt-SHA intentionally perform an iterative calculation of password hashes, repeating the hashing process thousands or even millions of times. This significantly reduces the rate at which candidate passwords can be tested, but only if the iteration count is sufficiently high. A more advanced class of algorithms, known as memory-hard functions, takes this a step further. Algorithms such as scrypt are designed to require relatively large amounts of memory in addition to time-consuming computation. This dual requirement makes them particularly difficult to accelerate using GPUs and custom integrated circuits, as these specialized hardware platforms often struggle with high memory bandwidth requirements.

Recognizing the critical need for a new, universally strong standard, a long-term Password Hashing Competition was initiated in 2013 [35]. The culmination of this rigorous process arrived in 2015 with Argon2 being chosen as the designated winner, a testament to its robust design and resistance to various attack vectors. Another algorithm, Balloon , has also received a recommendation from NIST [36]. Both Argon2 and Balloon are prime examples of memory-hard functions, embodying the current best practices for secure password storage.

Beyond algorithmic improvements, hardware-based solutions offer an even more formidable line of defense. Solutions like a security token provide a truly robust answer by generating constantly shifting, time-sensitive passwords. These dynamic credentials dramatically truncate the timeframe available for a brute-force attack , as an attacker would need to not only crack the password but also use it within the brief window of its validity. This ephemeral nature inherently reduces the long-term value of any stolen passwords, as their utility expires almost immediately. The “formal proof” aspect (which, if you must know, refers to the cryptographic guarantee of their one-time use and resistance to replay attacks) means they provide a strong cryptographic assurance of authenticity without relying on static, guessable secrets.

Software

For those with a penchant for digital demolition, or perhaps just a morbid curiosity, the landscape of password cracking software is surprisingly vast and continually evolving. There are, regrettably, many tools available for this purpose, but a select few have achieved a certain notoriety and widespread adoption [37]. These include Aircrack-ng (often used for Wi-Fi network keys), Cain & Abel (a venerable Windows utility), John the Ripper (the venerable, cross-platform brute-force and dictionary attack tool), Hashcat (a highly optimized, GPU-accelerated cracker), Hydra (a versatile network login cracker), DaveGrohl (a macOS-specific tool), and ElcomSoft (a commercial suite for forensic and recovery purposes).

It’s worth noting that many professional litigation support software packages also integrate password cracking functionality. This isn’t for nefarious purposes, but rather to facilitate lawful access to encrypted evidence in legal investigations. Regardless of their specific application, most of these packages employ a hybrid approach, combining various cracking strategies. Algorithms leveraging both brute-force and dictionary attacks consistently prove to be the most productive, often supplemented by rules-based attacks that incorporate common password patterns and substitutions [38].

The insidious truth is that the ever-increasing availability of raw computing power, coupled with the proliferation of user-friendly, automated password cracking software tailored for a multitude of protection schemes, has democratized this activity to an alarming degree. The barrier to entry has plummeted, allowing even so-called script kiddies —individuals with minimal technical understanding but a desire for digital mischief—to engage in activities that once required significant expertise [39]. It’s a sad reflection on the state of digital security that such destructive capabilities are now within reach of the casually malicious.

Notable Software Tools

• Crack
• Cain
• Chntpw
• DaveGrohl
• Hashcat
• John the Ripper
• L0phtCrack
• Ophcrack
• RainbowCrack

See also

If you insist on delving deeper into this rather depressing landscape of digital compromise and human error, consider these related topics:

• Brute-force attack
• Cold boot attack
• Dictionary attack
• Password strength
• Smudge attack