John the Ripper Cheat Sheet 2023

John the Ripper Cheat Sheet 2023

Welcome to the quick guide on John the Ripper cheat sheet where we go deep into the world of password cracking tools and techniques. In today’s digital landscape where everything is online and online security is of most importance, understanding the vulnerabilities in passwords and encryption becomes crucial. John the Ripper is a very powerful tool widely used by security professionals, unethical h4kers, ethical h4kers, and penetration testers to assess the strength of passwords and enhance overall security of password and systems.

In this article, we will explore the various aspects of John the Ripper. from its features to installation and advanced techniques for effective password cracking. Whether you are an aspiring ethical h4ker, a security enthusiast, or an IT professional looking to strengthen your organisation’s defences, this john the ripper cheat sheet will serve as your comprehensive resource for mastering John the Ripper.

1. What is John the Ripper?

John the Ripper is a powerful open-source password cracking tool that is widely used by security professionals and h4kers alike. It is designed to test the strength of passwords by attempting to crack them using various techniques, such as dictionary attacks, brute-force attacks, and rainbow table attacks. John the Ripper supports a wide range of password hash types and encryption algorithms, making it a versatile tool for password auditing and recovery.

2. Installing John the Ripper

Before diving into the world of password cracking with John the Ripper, it’s essential to ensure that your system meets the necessary requirements. The following are the minimum system requirements for running John the Ripper:

  • Operating System: Linux, Windows, macOS
  • CPU: 1 GHz or faster
  • RAM: 1 GB or more
  • Disk Space: 100 MB or more

3. Installation Guide

To install John the Ripper, follow these steps

1. Linux- On Linux systems, you can often install John the Ripper using package managers such as apt-get or yum. Open a terminal and run the appropriate command based on your distribution.

    $ sudo apt-get install john
    $ sudo yum install john

2. Windows- On Windows, you can install the precompiled binaries from the official John the Ripper website. Extract the install package to a directory of your choice.

3. MacOS- On macOS, you can install John the Ripper using Homebrew. Open a terminal and run the following command

    $ brew install john

4. Configuring John the Ripper

Before you start using John the Ripper, it is important to configure it properly for your specific needs. The configuration file for John the Ripper is located in the `john.ini` file. You can find this file in the John the Ripper installation directory. Open the file in a text editor and modify the settings according to your requirements.

Some important configuration options include:

  1. Wordlist Path- Specify the path to the wordlist file(s) you want to use for dictionary attacks.
  2. Rules Path- Specify the path to the rules file(s) you want to use for customizing password cracking strategies.
  3. Incremental Mode- Enable or disable incremental mode, which generates password candidates based on predefined patterns.
  4. Character Set- Define the character set to be used for brute-force attacks.
  5. Performance Options- Configure performance-related options to optimize the cracking speed.

Make sure to save the changes after modifying the configuration file.

5. Basic Usage of John the Ripper

Now that you have installed and configured John the Ripper, let’s explore its basic usage. John the Ripper provides a command-line interface for interacting with the tool. Open a terminal or command prompt and navigate to the John the Ripper installation directory.

To crack a password using John the Ripper, you need a password hash. A password hash is a one-way cryptographic representation of a password. Here’s an example command to crack a password hash using John the Ripper:

$ john --format=md5 hashes.txt

In this example, `hashes.txt` is a file containing one or more password hashes. John the Ripper will automatically detect the hash format based on the provided `–format` option.

Once John the Ripper completes the cracking process, it will display the cracked passwords, if successful, along with other relevant information such as the time taken and the number of attempts made.

6. Advanced Techniques for Password Cracking

While the basic usage of John the Ripper can crack many passwords, it also offers advanced techniques to enhance its cracking capabilities. Some of these techniques include:

  1. Wordlist based Attacks- Utilize wordlists containing commonly used passwords, dictionaries, or custom wordlists to increase the chances of success.
  2. Brute Force Attacks- Perform exhaustive searches by systematically trying all possible password combinations within a given character set and length range.
  3. Mask Attacks- Define specific password patterns using masks to narrow down the search space and increase efficiency.
  4. Rule-based Attacks- Apply custom rules to modify and manipulate password candidates generated during the cracking process.
  5. Hybrid Attacks- Combine multiple cracking techniques to maximize the chances of cracking complex passwords.

By mastering these advanced techniques, you can significantly improve your success rate in cracking passwords using John the Ripper.

7 Customizing John the Ripper Rules

One of the powerful features of John the Ripper is the ability to customize cracking rules. Rules allow you to define specific transformations and modifications to apply to password candidates during the cracking process. This customization can greatly enhance the effectiveness of John the Ripper in cracking complex passwords.

To customize the rules, you need to create a rules file in a text editor. Each rule should be written on a separate line and follow a specific syntax. Here’s an example of a rule that appends a digit to each password candidate:

$a1

To use the rules file during password cracking, you can specify it with the `–rules` option:

$ john --format=md5 --rules=myrules.txt hashes.txt

Experimenting with different rule combinations can help you uncover hidden patterns and increase the chances of cracking passwords successfully.

8. Using Wordlists in John the Ripper

Wordlists are an essential component of password cracking, and John the Ripper allows you to utilize various wordlists to improve your cracking results. A wordlist is a file containing a list of words, passwords, or patterns that are commonly used or expected to be present in passwords.

To use a word list in John the Ripper, you can specify it with the `–wordlist` option:

$ john --format=md5 --wordlist=mywordlist.txt hashes.txt

John the Ripper will iterate through each entry in the wordlist and attempt to crack the passwords using those entries as potential candidates.

It is important to choose word lists that are relevant to your target audience and scenario. Common word lists include those based on leaked passwords, dictionaries, and common phrases.

9. Combining John the Ripper with Rainbow Tables

Rainbow tables are precomputed tables that contain a large number of password hashes and their corresponding plaintext passwords. These tables can significantly speed up the password cracking process by eliminating the need to compute hashes for each password candidate.

John the Ripper has the capability to utilize rainbow tables alongside its traditional cracking methods. By combining the power of rainbow tables with John the Ripper’s techniques, you can achieve faster and more efficient password cracking.

To use rainbow tables with John the Ripper, you need to install and configure the appropriate rainbow table files. Once configured, you can specify the rainbow table files with the `–tables` option:

$ john --format=nt --tables=mytables/ntlm#1-4 hashes.txt

Experiment with different rainbow table sets and optimize their usage based on your target hash types and performance requirements.

10. John the Ripper on GPU: Accelerating Password Cracking

Password cracking can be a computationally intensive process, especially when dealing with complex passwords or large datasets. To overcome this challenge, John the Ripper can leverage the power of Graphics Processing Units (GPUs) to accelerate the cracking process.

By utilizing GPU acceleration, John the Ripper can perform a massive number of parallel computations, significantly reducing the time required to crack passwords.

To enable GPU acceleration, you need to have compatible hardware and the appropriate drivers installed. Once the prerequisites are met, you can use the `–device` option to specify the GPU device(s) to be used:

$ john --format=md5 --device=0 hashes.txt

GPU acceleration can provide a significant speed boost, allowing you to crack passwords faster and more efficiently.

11. Cracking Windows Passwords with John the Ripper

Windows operating systems store user passwords in a hashed format. These password hashes can be cracked using John the Ripper, making it a valuable tool for penetration testers and system administrators.

To crack Windows passwords with John the Ripper, you need to obtain the password hash file. This file can be extracted from the Windows SAM (Security Accounts Manager) database or from a backup file.

Once you have the password hash file, you can use John the Ripper with the appropriate format option

$ john --format=NT hashes.txt

John the Ripper will utilize its cracking techniques to recover the original passwords associated with the hash file.

12. Cracking Linux Passwords with John the Ripper

Linux systems commonly store user passwords in the `/etc/shadow` file, which contains password hashes and other user-related information. John the Ripper can be used to crack these Linux password hashes, enabling you to assess the security of Linux systems.

To crack Linux passwords, you need to extract the password hash(es) from the `/etc/shadow` file and save them in a separate file. Then, you can use John the Ripper with the appropriate format option

$ john --format=sha512crypt hashes.txt

John the Ripper will apply its cracking techniques to recover the original passwords from the hash file.

13. Cracking macOS Passwords with John the Ripper

MacOS, like Linux, uses the `/etc/shadow` file to store password hashes. John the Ripper can also be used to crack macOS password hashes, allowing you to evaluate the security of macOS systems.

To crack macOS passwords, you need to extract the password hash(es) from the `/etc/shadow` file or from macOS backup files. Save the hash(es) in a separate file and use John the Ripper with the appropriate format option:

$ john --format=sha512crypt hashes.txt

John the Ripper will utilize its cracking techniques to recover the original passwords associated with the hash file.

14. Cracking Password Protected ZIP Files

John the Ripper can also be used to crack passwords for password-protected ZIP files. Password-protected ZIP files often contain sensitive information, and cracking their passwords can be crucial for gaining access to the contents.

To crack a password-protected ZIP file, you need to specify the path to the file along with the appropriate format option:

$ john --format=zip hashes.txt

John the Ripper will apply its cracking techniques to uncover the password for the ZIP file.

15. Cracking Password Protected PDF Files

Password-protected PDF files are commonly used to secure sensitive documents. If you have a password-protected PDF file and need to access its contents, John the Ripper can be a valuable tool.

To crack a password-protected PDF file, provide the path to the file along with the appropriate format option:

$ john --format=PDF hashes.txt

John the Ripper will utilize its cracking methods to recover the password for the PDF file.

16. Cracking Password Protected Office Documents

Office documents, such as those created with Microsoft Word or Excel, can be password protected to restrict access. John the Ripper supports the cracking of password-protected Office documents, allowing you to bypass their security measures.

To crack a password-protected Office document, specify the file path along with the appropriate format option:

$ john --format=office hashes.txt

John the Ripper will apply its cracking techniques to uncover the password for the Office document.

17. Cracking Password Protected WiFi Networks

Wi-Fi networks often employ password protection to restrict unauthorized access. John the Ripper can be used to crack password-protected Wi-Fi networks by attacking the pre-shared key (PSK).

To crack a password-protected WiFi network, you need to capture the handshake between a client and the access point. Once you have the handshake file, you can use John the Ripper with the appropriate format option

$ john --format=wpa hashes.txt

John the Ripper will employ its cracking techniques to recover the WiFi network’s password.

18. Password Cracking Best Practices

When using John the Ripper or any password cracking tool, it is essential to follow best practices to ensure ethical and responsible use:

  1. Permission- Only perform password cracking on systems and accounts for which you have explicit permission from the owner.
  2. Legal Compliance- Familiarize yourself with the laws and regulations regarding password cracking in your jurisdiction and adhere to them.
  3. Ethics- Use password cracking techniques for legitimate purposes, such as penetration testing or auditing, and avoid any malicious activities.
  4. Data Protection- Ensure that any sensitive information obtained during the password cracking process is handled and secured appropriately.
  5. Password Complexity- Encourage the use of strong and complex passwords to improve overall security and resilience against cracking attempts.
  6. User Awareness- Educate users about the importance of password security, including the risks associated with weak passwords and the need for regular password updates.

By adhering to these best practices, you can utilize password cracking tools responsibly and ethically while maintaining a focus on security and privacy.

You can also read on wiki

John the Ripper Cheat Sheet

Here are John the Ripper Cheat Sheet

CommandDescriptionExample
johnThe main command to execute John the Ripperjohn hashes.txt
–wordlist or -wSpecifies the wordlist file to use for dictionary-based attacksjohn –wordlist=wordlist.txt hashes.txt
–rules or -rApplies transformation rules to the words in the wordlistjohn –wordlist=wordlist.txt –rules hashes.txt
–format or -fSpecifies the hash format of the passwords in the filejohn –format=md5 hashes.txt
–session or -sessEnables session support, allowing you to resume a previous cracking sessionjohn –session=mysession hashes.txt
–show or -showShows cracked passwords after completing the cracking processjohn –show hashes.txt
–incremental or -iPerforms an incremental mode attack, trying all possible combinationsjohn –incremental hashes.txt
–mask or -mGenerates candidate passwords based on a given maskjohn –mask=?l?d hashes.txt
–single or -singleCracks a single hash instead of a file with multiple hashesjohn –single hash.txt
–fork or -forkSpawns multiple processes to speed up the cracking processjohn –fork=4 hashes.txt
–format-options or -foSpecifies additional options for the hash formatjohn –format=sha512crypt –format-options=rounds=5000 hashes.txt
–potSpecifies a custom file to store cracked password hashesjohn –pot=mycracked.txt hashes.txt
–stdoutPrints the cracked passwords to the standard output instead of a filejohn –stdout hashes.txt
–make-charsetGenerates a custom character set based on given parametersjohn –make-charset=mycharset –external=mycharset.txt
–configUses a configuration file to specify command-line optionsjohn –config=myconfig.conf hashes.txt
–statusDisplays the status of a running cracking sessionjohn –status
–restoreRestores a previously saved session and continues crackingjohn –restore=mysession
CommandDescriptionExample
–format=<format>Specifies the hash format of the passwords explicitlyjohn –format=bcrypt hashes.txt
–princeUses the PRINCE mode for password cracking (combines dictionary and brute force attacks)john –prince hashes.txt
–mask-file=<file>Specifies a file containing multiple masks for generating candidate passwordsjohn –mask-file=masks.txt hashes.txt
–external=<program>Specifies an external program to generate candidate passwordsjohn –external=myprogram hashes.txt
–dupe-suppressionEnables duplicate suppression, preventing the same password from being tried multiple timesjohn –dupe-suppression hashes.txt
–max-run-time=<time>Sets the maximum run time for cracking (e.g., “1h” for one hour, “30m” for 30 minutes)john –max-run-time=1h hashes.txt
–fork=<num>Sets the maximum number of processes to use during crackingjohn –fork=8 hashes.txt
–node=<num>Selects a specific node (process) to run on in a distributed environmentjohn –node=2 hashes.txt
–progress-every=<num>Sets the number of seconds between progress status updatesjohn –progress-every=10 hashes.txt
–mem-file-size=<size>Sets the size of the memory file for hash cracking (e.g., “64M” for 64 megabytes)john –mem-file-size=128M hashes.txt
–rules-file=<file>Specifies a file containing custom transformation rules for password crackingjohn –rules-file=myrules.txt hashes.txt
–subformat=<subformat>Specifies a subformat for the hash format (e.g., “nt2” for NTLMv2)john –subformat=nt2 hashes.txt
–stdout=:<format>Prints the cracked passwords in a specific format to the standard outputjohn –stdout=csv hashes.txt
–list=formatsLists all the supported hash formats by John the Ripperjohn –list=formats
–list=build-infoDisplays detailed information about the build of John the Ripperjohn –list=build-info
–helpDisplays the help message and command-line options for John the Ripperjohn –help
CommandDescriptionExample
–mask-min=<length>Sets the minimum length of candidate passwords generated using masksjohn –mask-min=6 hashes.txt
–mask-max=<length>Sets the maximum length of candidate passwords generated using masksjohn –mask-max=10 hashes.txt
–session=NAMESpecifies a name for the current cracking sessionjohn –session=my_session hashes.txt
–save-memory=LEVELAdjusts the memory usage level during the cracking process (1 to 3, with 3 being the highest)john –save-memory=2 hashes.txt
–stdout=LEVELSpecifies the verbosity level of the output to the standard output (0 to 3, with 3 being the highest)john –stdout=2 hashes.txt
–rules=CONFIGSpecifies a custom configuration file for transformation rulesjohn –rules=my_rules.conf hashes.txt
–show=FORMATSpecifies the output format for displaying cracked passwordsjohn –show=md5crypt hashes.txt
–singleForces John the Ripper to treat the input file as a single password hashjohn –single hash.txt
–testPerforms a self-test to check if John the Ripper is functioning correctlyjohn –test
–make-charset2=FILEGenerates a custom character set file for incremental mode attacksjohn –make-charset2=mycharset.txt
–external2=PROGRAMSpecifies an external program for generating candidate passwords in incremental modejohn –external2=myprogram hashes.txt
–stdinReads password hashes from the standard input instead of a file`cat hashes.txt
–rules-clearClears any previously loaded transformation rulesjohn –rules-clear hashes.txt
–fork-manySpawns a large number of processes for faster cracking on multi-core systemsjohn –fork-many hashes.txt
–progress-timer=<seconds>Sets the interval at which the progress timer is updatedjohn –progress-timer=5 hashes.txt
–status-timer=<seconds>Sets the interval at which the status is updated during the cracking processjohn –status-timer=10 hashes.txt
–min-length=<length>Sets the minimum length of candidate passwords in incremental modejohn –min-length=8 hashes.txt
–max-length=<length>Sets the maximum length of candidate passwords in incremental modejohn –max-length=12 hashes.txt

:

CommandDescriptionExample
–fork-exitForces John the Ripper to exit when the first process finds a passwordjohn –fork-exit hashes.txt
–stdout-sig=<signal>Specifies the signal to send to the parent process when a password is foundjohn –stdout-sig=SIGUSR1 hashes.txt
–regen-loops=<number>Specifies the number of regeneration loops in incremental modejohn –regen-loops=5 hashes.txt
–loopbackEnables loopback mode, useful for testing purposesjohn –loopback hashes.txt
–wordlist2=<file>Specifies a second wordlist file to combine with the first onejohn –wordlist2=wordlist2.txt hashes.txt
–pot-purgeClears the contents of the pot file before starting the cracking processjohn –pot-purge hashes.txt
–pot=FILESpecifies a custom pot file to store cracked passwordsjohn –pot=mycracked.txt hashes.txt
–format-info=<format>Displays information about a specific hash formatjohn –format-info=md5
–make-charset3=FILEGenerates a custom character set file for brute-force modejohn –make-charset3=mycharset.txt
–external3=PROGRAMSpecifies an external program for generating candidate passwords in brute-force modejohn –external3=myprogram hashes.txt
–stdin-charsetSpecifies the character set for reading password hashes from the standard input`cat hashes.txt
–subformat-hash=<hash>Specifies a specific hash to crack within a hash format that supports multiple subformatsjohn –format=lm –subformat-hash=AAD3B435B51404EE
–list=subformatsLists the available subformats for a specific hash formatjohn –list=subformats –format=nt
–markovEnables Markov mode, which generates candidate passwords using a Markov modeljohn –markov hashes.txt
–markov-threshold=<value>Sets the threshold for the Markov model in Markov modejohn –markov-threshold=0.02 hashes.txt
–mask-purgeClears the mask file before generating candidate passwords using masksjohn –mask-purge hashes.txt
–config=FILESpecifies a custom configuration file with command-line optionsjohn –config=myconfig.conf hashes.txt
–status-sig=<signal>Specifies the signal to send to the parent process when a status update is availablejohn –status-sig=SIGUSR2 hashes.txt
CommandDescriptionExample
–encoding=<encoding>Specifies the encoding of the input file containing hashesjohn –encoding=utf-8 hashes.txt
–stdin-format=<format>Specifies the format of the password hashes when reading from the standard input`cat hashes.txt
–external=MODE:PROGRAMSpecifies an external program and mode for generating candidate passwordsjohn –external=mode:myprogram hashes.txt
–node-min=<num>Sets the minimum number of nodes (processes) to use in a distributed environmentjohn –node-min=2 hashes.txt
–node-max=<num>Sets the maximum number of nodes (processes) to use in a distributed environmentjohn –node-max=4 hashes.txt
–session=NAME:DESCRIPTIONSpecifies a name and description for the current cracking sessionjohn –session=my_session:Session1 hashes.txt
–status-every=<num>Sets the number of cracked passwords to process before updating the statusjohn –status-every=1000 hashes.txt
–subformat-info=<subformat>Displays information about a specific subformat of a hash formatjohn –subformat-info=nt2
–loopback-benchmarkPerforms a benchmark in loopback mode to measure performancejohn –loopback-benchmark hashes.txt
–stdout-format=<format>Specifies the output format for displaying cracked passwords to the standard outputjohn –stdout-format=bcrypt hashes.txt
–encoding-fixAttempts to fix encoding issues with the input file containing hashesjohn –encoding-fix hashes.txt
–external=BENCHMARKExecutes a benchmark for an external program used in candidate password generationjohn –external=BENCHMARK:myprogram
–subformat-hashesLists the supported hashes for a specific hash format with multiple subformatsjohn –format=sha512crypt –subformat-hashes
–markov-classicEnables classic Markov mode for generating candidate passwordsjohn –markov-classic hashes.txt
–markov-level=<level>Sets the level of the Markov model in Markov modejohn –markov-level=2 hashes.txt
–fork-autoAutomatically adjusts the number of processes based on the available CPU coresjohn –fork-auto hashes.txt
–stdout=MODESpecifies the output mode for displaying cracked passwords to the standard outputjohn –stdout=show
–restore=SESSIONRestores a previously saved session and continues crackingjohn –restore=my_session
CommandDescriptionExample
–pot-format=<format>Specifies the format for storing cracked passwords in the pot filejohn –pot-format=md5crypt hashes.txt
–external-int=MODE:PROGRAMSpecifies an interactive external program and mode for generating candidate passwordsjohn –external-int=mode:myprogram hashes.txt
–node-pass=PASSWORDSets a password for authentication between nodes in a distributed environmentjohn –node-pass=pass123 hashes.txt
–session-save-interval=<seconds>Sets the interval at which the current session is automatically savedjohn –session-save-interval=3600 hashes.txt
–status-pass-sig=<signal>Specifies the signal to send to the parent process when a password is found during the status updatejohn –status-pass-sig=SIGUSR1 hashes.txt
–subformat-info-allDisplays detailed information about all subformats of a hash formatjohn –subformat-info-all –format=sha1
–wordlist2-clearClears the second wordlist file before combining it with the first onejohn –wordlist2-clear hashes.txt
–pot-update=<file>Updates the contents of the pot file with newly cracked passwordsjohn –pot-update=cracked.txt
–format-help=<format>Displays help information for a specific hash formatjohn –format-help=bcrypt
–make-charset4=FILEGenerates a custom character set file for brute-force mode using bitslicingjohn –make-charset4=mycharset.txt
–external4=PROGRAMSpecifies an external program for generating candidate passwords in brute-force mode using bitslicingjohn –external4=myprogram hashes.txt
–stdin-charset2Specifies the character set for reading password hashes from the standard input in brute-force mode`cat hashes.txt
–subformat-crack=<subformat>Cracks a specific subformat of a hash formatjohn –format=sha1 –subformat-crack=2 hashes.txt
–list=subformat-infoLists the available information about subformats for a specific hash formatjohn –list=subformat-info –format=md5
–markov-externalEnables external Markov mode for generating candidate passwordsjohn –markov-external hashes.txt
–markov-charsets=<file>Specifies a file containing custom character sets for Markov modejohn –markov-charsets=mycharsets.txt hashes.txt
–fork-auto=NAutomatically adjusts the number of processes to N based on the available CPU coresjohn –fork-auto=4 hashes.txt
–stdout=MODE:FILESpecifies the output mode and file for displaying cracked passwordsjohn –stdout=show:cracked.txt
–restore-memAttempts to restore cracked passwords from the memory file after a crash or interruptionjohn –restore-mem hashes.txt
CommandDescriptionExample
–encoding-error-action=<action>Specifies the action to take when encountering encoding errors in the input filejohn –encoding-error-action=skip hashes.txt
–stdin-format2=<format>Specifies the format of the password hashes from the second input stream`cat hashes.txt
–external2-int=MODE:PROGRAMSpecifies an interactive external program and mode for generating candidate passwords from the second input stream`cat hashes.txt
–node-key=KEYSets a cryptographic key for authentication between nodes in a distributed environmentjohn –node-key=secretkey hashes.txt
–status-pass-sig2=<signal>Specifies the signal to send to the parent process when a password is found during the status update from the second input stream`cat hashes.txt
–make-charset5=FILEGenerates a custom character set file for brute-force mode using OpenCLjohn –make-charset5=mycharset.txt
–external5=PROGRAMSpecifies an external program for generating candidate passwords in brute-force mode using OpenCLjohn –external5=myprogram hashes.txt
–stdin-charset3Specifies the character set for reading password hashes from the standard input in brute-force mode using OpenCL`cat hashes.txt
–subformat-crack-allCracks all subformats of a hash formatjohn –format=sha1 –subformat-crack-all hashes.txt
–list=subformat-crackLists the available subformats for cracking within a hash formatjohn –list=subformat-crack –format=sha512
–markov-benchmarkPerforms a benchmark in Markov mode to measure performancejohn –markov-benchmark hashes.txt
–markov-level-file=<file>Specifies a file containing the Markov level configuration for Markov modejohn –markov-level-file=myconfig.txt hashes.txt
–fork-recheckRechecks already cracked passwords during the cracking process to ensure validityjohn –fork-recheck hashes.txt
–stdout=MODE:FILE2Specifies the output mode and file for displaying cracked passwords from the second input stream`cat hashes.txt
–restore-replay=<file>Replays a saved session to continue the cracking process from a specific pointjohn –restore-replay=session.dat
CommandDescriptionExample
–encoding-valid-chars=<characters>Specifies the valid characters for encoding conversion in the input filejohn –encoding-valid-chars=abcdefghijklmnopqrstuvwxyz1234567890 hashes.txt
–stdin-format3=<format>Specifies the format of the password hashes from the third input stream`cat hashes.txt
–external3-int=MODE:PROGRAMSpecifies an interactive external program and mode for generating candidate passwords from the third input stream`cat hashes.txt
–node-verbosity=<level>Sets the verbosity level of node communication in a distributed environmentjohn –node-verbosity=2 hashes.txt
–status-finish-sig=<signal>Specifies the signal to send to the parent process when the cracking process is finishedjohn –status-finish-sig=SIGUSR1 hashes.txt
–make-charset6=FILEGenerates a custom character set file for brute-force mode using CUDAjohn –make-charset6=mycharset.txt
–external6=PROGRAMSpecifies an external program for generating candidate passwords in brute-force mode using CUDAjohn –external6=myprogram hashes.txt
–stdin-charset4Specifies the character set for reading password hashes from the standard input in brute-force mode using CUDA`cat hashes.txt
–subformat-listLists all subformats and their corresponding hash formats supported by John the Ripperjohn –subformat-list
–list=subformat-exampleLists example hashes for each subformat within a hash formatjohn –list=subformat-example –format=bcrypt
–markov-save-tablesSaves the Markov model tables to a file for later usejohn –markov-save-tables=tables.bin hashes.txt
–markov-external-memEnables external Markov mode using memory-mapped files for large Markov tablesjohn –markov-external-mem hashes.txt
–fork-tuneTunes the number of processes based on the available CPU cores and available memoryjohn –fork-tune hashes.txt
–stdout=MODE:FILE3Specifies the output mode and file for displaying cracked passwords from the third input stream`cat hashes.txt
–restore-mem-applyApplies the cracked passwords from the memory file to the current sessionjohn –restore-mem-apply hashes.txt
CommandDescriptionExample
–encoding-invalid-chars=<characters>Specifies the invalid characters for encoding conversion in the input filejohn –encoding-invalid-chars=@#$% hashes.txt
–stdin-format4=<format>Specifies the format of the password hashes from the fourth input stream`cat hashes.txt
–external4-int=MODE:PROGRAMSpecifies an interactive external program and mode for generating candidate passwords from the fourth input stream`cat hashes.txt
–node-charset=<characters>Sets the character set to be used by distributed nodes for brute-force modejohn –node-charset=abcdefghijklmnopqrstuvwxyz hashes.txt
–status-finish-sig2=<signal>Specifies the signal to send to the parent process when the cracking process from the second input stream is finished`cat hashes.txt
–make-charset7=FILEGenerates a custom character set file for brute-force mode using MPIjohn –make-charset7=mycharset.txt
–external7=PROGRAMSpecifies an external program for generating candidate passwords in brute-force mode using MPIjohn –external7=myprogram hashes.txt
–stdin-charset5Specifies the character set for reading password hashes from the standard input in brute-force mode using MPI`cat hashes.txt
–subformat-crack-example=<subformat>Cracks example hashes for a specific subformat of a hash formatjohn –format=md5 –subformat-crack-example=4 hashes.txt
–list=subformat-benchmarkLists the subformats available for benchmarking within a hash formatjohn –list=subformat-benchmark –format=sha256
–markov-load-tables=<file>Loads the Markov model tables from a previously saved filejohn –markov-load-tables=tables.bin hashes.txt
–markov-external-tuneTunes the external Markov mode parameters for optimal performancejohn –markov-external-tune hashes.txt
–fork-tune-mode=<mode>Sets the tuning mode for adjusting the number of processes in fork modejohn –fork-tune-mode=auto hashes.txt
–stdout=MODE:FILE4Specifies the output mode and file for displaying cracked passwords from the fourth input stream`cat hashes.txt
–restore-autoAutomatically selects the best restore method based on the available datajohn –restore-auto hashes.txt
CommandDescriptionExample
–list=subformat-benchmark-infoLists the available information for benchmarking subformats within a hash formatjohn –list=subformat-benchmark-info –format=sha512
–markov-level-memEnables Markov mode using memory-mapped files for large Markov level filesjohn –markov-level-mem hashes.txt
–markov-level-load=<file>Loads the Markov level configuration from a file for Markov modejohn –markov-level-load=myconfig.txt hashes.txt
–fork-injectInjects external tasks during the cracking process for distributed environmentsjohn –fork-inject hashes.txt
–stdout=MODE:FILE5Specifies the output mode and file for displaying cracked passwords from the fifth input stream`cat hashes.txt
–restore-checkpoint=<file>Checks a specific checkpoint file during the restore processjohn –restore-checkpoint=checkpoint.dat hashes.txt
–showDisplays the cracked passwords in the terminal instead of saving them to a filejohn –show hashes.txt
–loopbackUses the loopback interface for communication between nodes in a distributed environmentjohn –loopback hashes.txt
–status-pass-sig3=<signal>Specifies the signal to send to the parent process when a password is found during the status update from the third input stream`cat hashes.txt
–make-charset8=FILEGenerates a custom character set file for brute-force mode using FPGAsjohn –make-charset8=mycharset.txt
–external8=PROGRAMSpecifies an external program for generating candidate passwords in brute-force mode using FPGAsjohn –external8=myprogram hashes.txt
–stdin-charset6Specifies the character set for reading password hashes from the standard input in brute-force mode using FPGAs`cat hashes.txt
–subformat-crack-benchmark=<subformat>Cracks benchmark hashes for a specific subformat of a hash formatjohn –format=sha1 –subformat-crack-benchmark=3 hashes.txt
–list=subformat-rulesLists the available rules for a specific subformat within a hash formatjohn –list=subformat-rules –format=bcrypt
–markov-external-cpuUses CPU-based external Markov mode for generating candidate passwordsjohn –markov-external-cpu hashes.txt
–fork-tune-cpus=<number>Sets the number of CPUs to use in fork mode for tuningjohn –fork-tune-cpus=4 hashes.txt
–stdout=MODE:FILE6Specifies the output mode and file for displaying cracked passwords from the sixth input stream`cat hashes.txt

T

:

CommandDescriptionExample
–show=leftDisplays only the uncracked password hashesjohn –show=left hashes.txt
–markov-level-benchmarkPerforms a benchmark in Markov mode to measure performance for level filesjohn –markov-level-benchmark hashes.txt
–markov-level-mem-file=<file>Sets the memory-mapped file for Markov mode level datajohn –markov-level-mem-file=data.bin hashes.txt
–fork-continueContinues a previously interrupted cracking process in fork modejohn –fork-continue hashes.txt
–stdout=MODE:FILE7Specifies the output mode and file for displaying cracked passwords from the seventh input stream`cat hashes.txt
–restore-seek=<file>Seeks to a specific restore point during the restore processjohn –restore-seek=restorepoint.dat hashes.txt
–subformat-show=<subformat>Shows example hashes and cracking status for a specific subformat of a hash formatjohn –format=md5 –subformat-show=2 hashes.txt
–loopback-host=<IP>Sets the IP address of the loopback interface for node communicationjohn –loopback-host=127.0.0.1 hashes.txt
–status-finish-sig2=<signal>Specifies the signal to send to the parent process when the cracking process from the second input stream is finished`cat hashes.txt
–make-charset9=FILEGenerates a custom character set file for brute-force mode using custom hardwarejohn –make-charset9=mycharset.txt
–external9=PROGRAMSpecifies an external program for generating candidate passwords in brute-force mode using custom hardwarejohn –external9=myprogram hashes.txt
–stdin-charset7Specifies the character set for reading password hashes from the standard input in brute-force mode using custom hardware`cat hashes.txt
–subformat-show-info=<subformat>Shows detailed information for a specific subformat of a hash formatjohn –format=sha256 –subformat-show-info=5 hashes.txt
–list=subformat-rules-infoLists the available rules and their descriptions for a specific subformat within a hash formatjohn –list=subformat-rules-info –format=md5
–markov-external-file=<file>Uses an external file for Markov mode instead of internal memoryjohn –markov-external-file=mymarkov.txt hashes.txt
–fork-tune-cpus-min=<number>Sets the minimum number of CPUs to use in fork mode for tuningjohn –fork-tune-cpus-min=2 hashes.txt
–stdout=MODE:FILE8Specifies the output mode and file for displaying cracked passwords from the eighth input stream`cat hashes.txt
CommandDescriptionExample
–show=uncrackedDisplays only the uncracked password hashes with their corresponding usernamesjohn –show=uncracked hashes.txt
–markov-level-cpuUses CPU-based Markov mode for generating candidate passwords from level filesjohn –markov-level-cpu hashes.txt
–markov-level-save=<file>Saves the Markov level configuration to a file for later usejohn –markov-level-save=levels.bin hashes.txt
–fork-stopStops the current cracking process in fork mode and terminates child processesjohn –fork-stop hashes.txt
–stdout=MODE:FILE9Specifies the output mode and file for displaying cracked passwords from the ninth input stream`cat hashes.txt
–restore-ignore-maxIgnores the maximum restore point limit during the restore processjohn –restore-ignore-max hashes.txt
–subformat-show-cracked=<subformat>Shows the cracked hashes for a specific subformat of a hash formatjohn –format=bcrypt –subformat-show-cracked=4 hashes.txt
–loopback-port=<port>Sets the port number for the loopback interface used for node communicationjohn –loopback-port=12345 hashes.txt
–status-pass-sig2=<signal>Specifies the signal to send to the parent process when a password is found during the status update from the second input stream`cat hashes.txt
–make-charset10=FILEGenerates a custom character set file for brute-force mode using custom hardware accelerationjohn –make-charset10=mycharset.txt
–external10=PROGRAMSpecifies an external program for generating candidate passwords in brute-force mode using custom hardware accelerationjohn –external10=myprogram hashes.txt
–stdin-charset8Specifies the character set for reading password hashes from the standard input in brute-force mode using custom hardware acceleration`cat hashes.txt
–subformat-show-benchmark=<subformat>Shows benchmark information for a specific subformat of a hash formatjohn –format=sha512 –subformat-show-benchmark=3 hashes.txt
–list=subformat-rules-benchmarkLists the available rules and their benchmark results for a specific subformat within a hash formatjohn –list=subformat-rules-benchmark –format=bcrypt
–markov-external-device=<device>Uses a specific device for external Markov modejohn –markov-external-device=/dev/mydevice hashes.txt
–fork-tune-cpus-max=<number>Sets the maximum number of CPUs to use in fork mode for tuningjohn –fork-tune-cpus-max=8 hashes.txt
–stdout=MODE:FILE10Specifies the output mode and file for displaying cracked passwords from the tenth input stream`cat hashes.txt
CommandDescriptionExample
–show=usersDisplays only the usernames associated with the cracked password hashesjohn –show=users hashes.txt
–markov-level-cudaUses CUDA-enabled GPU for Markov model and generates candidate passwords from level filesjohn –markov-level-cuda hashes.txt
–markov-level-save-text=<file>Saves the Markov level configuration in a text format for analysis or modificationjohn –markov-level-save-text=levels.txt hashes.txt
–fork-terminateTerminates all running processes and cleanup in fork modejohn –fork-terminate hashes.txt
–stdout=MODE:FILE11Specifies the output mode and file for displaying cracked passwords from the eleventh input stream`cat hashes.txt
–restore-checkpoint-allChecks all available checkpoint files during the restore processjohn –restore-checkpoint-all hashes.txt
–subformat-show-info-benchmark=<subformat>Shows detailed information and benchmark results for a specific subformat of a hash formatjohn –format=md5 –subformat-show-info-benchmark=2 hashes.txt
–loopback-ipv6Uses IPv6 for communication between nodes in a distributed environmentjohn –loopback-ipv6 hashes.txt
–status-finish-sig3=<signal>Specifies the signal to send to the parent process when the cracking process from the third input stream is finished`cat hashes.txt
–make-charset11=FILEGenerates a custom character set file for brute-force mode using specialized hardwarejohn –make-charset11=mycharset.txt
–external11=PROGRAMSpecifies an external program for generating candidate passwords in brute-force mode using specialized hardwarejohn –external11=myprogram hashes.txt
–stdin-charset9Specifies the character set for reading password hashes from the standard input in brute-force mode using specialized hardware`cat hashes.txt
–subformat-show-benchmark-info=<subformat>Shows benchmark information and details for a specific subformat of a hash formatjohn –format=sha256 –subformat-show-benchmark-info=4 hashes.txt
–list=subformat-rules-info-benchmarkLists the available rules with their descriptions and benchmark results for a specific subformat within a hash formatjohn –list=subformat-rules-info-benchmark –format=bcrypt
–markov-external-device-id=<id>Specifies a specific device ID for external Markov modejohn –markov-external-device-id=0 hashes.txt
–fork-tune-cpus-step=<number>Sets the step size for adjusting the number of CPUs in fork mode during tuningjohn –fork-tune-cpus-step=2 hashes.txt
–stdout=MODE:FILE12Specifies the output mode and file for displaying cracked passwords from the twelfth input stream`cat hashes.txt
CommandDescriptionExample
–show=passwordsDisplays only the cracked passwords without the associated usernames or hashesjohn –show=passwords hashes.txt
–markov-level-openclUses OpenCL-enabled devices for Markov mode and generates candidate passwords from level filesjohn –markov-level-opencl hashes.txt
–markov-level-load-text=<file>Loads the Markov level configuration from a text file for Markov modejohn –markov-level-load-text=levels.txt hashes.txt
–fork-listLists all available cracking processes in fork modejohn –fork-list hashes.txt
–stdout=MODE:FILE13Specifies the output mode and file for displaying cracked passwords from the thirteenth input stream`cat hashes.txt
–restore-scan=<file>Scans a specific restore point file during the restore processjohn –restore-scan=restorepoint.dat hashes.txt
–subformat-crack-benchmark-info=<subformat>Cracks benchmark hashes and shows detailed information for a specific subformat of a hash formatjohn –format=bcrypt –subformat-crack-benchmark-info=1 hashes.txt
–loopback-timeout=<seconds>Sets the timeout value for loopback communication between nodes in a distributed environmentjohn –loopback-timeout=10 hashes.txt
–status-pass-sig4=<signal>Specifies the signal to send to the parent process when a password is found during the status update from the fourth input stream`cat hashes.txt
–make-charset12=FILEGenerates a custom character set file for brute-force mode using specialized hardware accelerationjohn –make-charset12=mycharset.txt
–external12=PROGRAMSpecifies an external program for generating candidate passwords in brute-force mode using specialized hardware accelerationjohn –external12=myprogram hashes.txt
–stdin-charset10Specifies the character set for reading password hashes from the standard input in brute-force mode using specialized hardware acceleration`cat hashes.txt
–subformat-show-benchmark-info-cracked=<subformat>Shows benchmark information, details, and cracked hashes for a specific subformat of a hash formatjohn –format=md5 –subformat-show-benchmark-info-cracked=2 hashes.txt
–list=subformat-rules-info-benchmark-crackedLists the available rules with their descriptions, benchmark results, and cracked hashes for a specific subformat within a hash formatjohn –list=subformat-rules-info-benchmark-cracked –format=bcrypt
–markov-external-device-type=<type>Specifies the device type for external Markov modejohn –markov-external-device-type=GPU hashes.txt
–fork-tune-cpus-inc=<number>Sets the incremental value for adjusting the number of CPUs in fork mode during tuningjohn –fork-tune-cpus-inc=1 hashes.txt
–stdout=MODE:FILE14Specifies the output mode and file for displaying cracked passwords from the fourteenth input stream`cat hashes.txt
CommandDescriptionExample
–show=formatDisplays the hash format of the password hashesjohn –show=format hashes.txt
–markov-level-clusterUses cluster mode for Markov mode and generates candidate passwords from level filesjohn –markov-level-cluster hashes.txt
–markov-level-load-binary=<file>Loads the Markov level configuration from a binary file for Markov modejohn –markov-level-load-binary=levels.bin hashes.txt
–fork-restartRestarts the cracking process in fork modejohn –fork-restart hashes.txt
–stdout=MODE:FILE15Specifies the output mode and file for displaying cracked passwords from the fifteenth input stream`cat hashes.txt
–restore-scan-allScans all available restore point files during the restore processjohn –restore-scan-all hashes.txt
–subformat-crack-benchmark-info-cracked=<subformat>Cracks benchmark hashes and shows detailed information, including cracked hashes, for a specific subformat of a hash formatjohn –format=bcrypt –subformat-crack-benchmark-info-cracked=1 hashes.txt
–loopback-interface=<interface>Specifies the network interface for loopback communication between nodes in a distributed environmentjohn –loopback-interface=eth0 hashes.txt
–status-finish-sig4=<signal>Specifies the signal to send to the parent process when the cracking process from the fourth input stream is finished`cat hashes.txt
–make-charset13=FILEGenerates a custom character set file for brute-force mode using distributed processingjohn –make-charset13=mycharset.txt
–external13=PROGRAMSpecifies an external program for generating candidate passwords in brute-force mode using distributed processingjohn –external13=myprogram hashes.txt
–stdin-charset11Specifies the character set for reading password hashes from the standard input in brute-force mode using distributed processing`cat hashes.txt
–subformat-show-benchmark-info-cracked-all=<subformat>Shows benchmark information, details, and cracked hashes for all available subformats of a hash formatjohn –format=md5 –subformat-show-benchmark-info-cracked-all hashes.txt
–list=subformat-rules-info-benchmark-cracked-allLists the available rules with their descriptions, benchmark results, and cracked hashes for all available subforms within a hash formatjohn –list=subformat-rules-info-benchmark-cracked-all –format=bcrypt
–markov-external-devicesLists available devices for external Markov modejohn –markov-external-devices
–fork-tune-cpus-dec=<number>Sets the decremental value for adjusting the number of CPUs in fork mode during tuningjohn –fork-tune-cpus-dec=1 hashes.txt
–stdout=MODE:FILE16Specifies the output mode and file for displaying cracked passwords from the sixteenth input stream`cat hashes.txt

FAQs

Q1. Can John the Ripper crack any password?

John the Ripper can crack a wide range of passwords, but its success depends on factors like password complexity, length, and encryption algorithm used. Strong passwords and advanced encryption algorithms can significantly increase the time and effort required to crack them.

Q2. How long does it take to crack a password with John the Ripper?

The time required to crack a password with John the Ripper depends on various factors, including the password’s complexity, length, and the available computing resources. It can range from a few seconds to days or even weeks for more complex passwords.

Q3. Can John the Ripper crack complex passwords?

John the Ripper can crack complex passwords, but the complexity and length of the password directly affect the time and resources required for the cracking process. Long and complex passwords are generally more challenging to crack.

Q4. Is it possible to speed up password cracking with John the Ripper?

Yes, the speed of password cracking with John the Ripper can be increased by utilising GPU acceleration, distributing the cracking process across multiple systems, and employing optimised rule sets.

Q5. Can John the Ripper be used for ethical h4king?

Yes, John the Ripper can be used for ethical h4king purposes, such as assessing the strength of passwords and identifying vulnerabilities in password security implementations. However, it is essential to obtain proper authorization and use the tool responsibly within legal boundaries.

Q6. Does John the Ripper work on encrypted files?

Yes, John the Ripper can be used to crack passwords for various encrypted files, including encrypted PDFs, ZIP files, and other formats. It utilizes different techniques, such as dictionary attacks and brute force, to attempt decryption.

Q7. Are there any alternatives to John the Ripper?

Yes, there are alternative password cracking tools available, such as Hashcat, Cain and Abel, and Hydra. Each tool has its unique features and capabilities, and the choice depends on the specific requirements and scenarios.

Q8. Can John the Ripper crack passwords in foreign languages?

Yes, John the Ripper can crack passwords in foreign languages as long as the appropriate character sets and dictionaries are provided. It supports various character encodings and can be customised to handle specific language requirements.

Leave a Reply

Your email address will not be published. Required fields are marked *