# Passwords cracking Password cracking is the process of recovering passwords from data that have been stored in or transmitted in a hashed form by a computer system. Passwords cracking can be attempted using a: * Brute-force attack, in which all possible passwords are exhaustively tried. Past a certain password length and complexity, brute force attack become ineffective * Dictionary attack rely on a wordlist to guess passwords * Rainbow table attack use a precomputed table of hashes reducing the computer processing time required The time to crack a password is related to the password strength and the hashing function used. ### Wordlist The following word list can be used for passwords cracking: | Name | Entry count | Description | | --------------------- | ----------------- | -------------------------------------------------------------------------------------------- | | `darkweb2017-top` | 10/100/1000/10000 | Top X passwords. | | `rockyou.txt` | 14 millions | Usually considered sufficient for any CTF purpose, coupled if necessary with cracking rules. | | `CrackStation`’s 15GB | 1.5 billion | The publicly available most complete password wordlist to date. | **kwprocessor** `kwprocessor` is a keyboard-walk generator utility, with configurable basechars, keymap and routes. Keyboard-walk sequences correspond to a sequence of juxtaposed keyboard keys, such as "qwerty" or "azerty" for example. The `basechars` characters list consist of every characters that will be used as a starting point for the keyboard-walking sequences. The `tiny.base` list includes very limited, `QWERTY` keyboard based, starting points: `1q!Q`. The `full.base` file provides a more comprehensive `basechars` list and its use is recommended. The `keymap` correspond to a keyboard layout, representing the physical disposition of the keyboard keys. A `keymap` file should consist of 12 lines: 4 complete physical keyboard lines, represented as of (`azertyuiop^$`), and if pressed in combination with the modifier keys `Shift` (`AZERTYUIOP¨£`) and `AltGr` (`€¤`). Various keymaps (`en-us`, `en-gb`, `fr`, `es`, `de`, `ru`, etc.) are provided on the `kwprocessor` GitHub. The `route` corresponds to the patterns used to generate the keyboard-walking sequences. A `route` is composed of a sequence of number(s), each number representing the number of pressed keys in the same geographical directions (north, south, west and east by default, extendable to north-west, north-east, south-west, south-east and repeat in place). For example, the route `1`, for the `h` key starting point and with the default `kwprocessor` configuration, would generate the following words: `hn`, `hg`, `hj` and `hy`.\ For more information and explanation on `route`, refer to the `kwprocessor` GitHub documentation: `https://github.com/hashcat/kwprocessor` ``` # -s: include characters reachable by holding Shift. Default to false. # -a: include characters reachable by holding AltGr. Default to false. # -n: minimum allowed distance between keys. Default to 1. # -x: maximum allowed distance between keys. Default to 1. # --keywalk-all: enable all --keywalk-* directions (keywalk-north, keywalk-south, keywalk-west, keywalk-east, keywalk-north-west, keywalk-north-east, keywalk-south-west, keywalk-south-east and keywalk-repeat). # Default keywalk routes are the cardinal geographic directions: north, south, west and east, with out repetition. kwp -s 1 -a 1 ./basechars/full.base > ``` ### Python EXREX The Python `EXREX` module can be used to generate wordlists from the specified regular expression. ``` # pip install exrex import exrex # Example regex to generate variation around the password keyword: # ((p|P)(a|A|@)(s|S|\$){2}(w|W)(o|O|0)(r|R)(d|D)\d{0,3}!{0,3}) print '\n'.join(exrex.generate('')) ``` ### Hash types The `hashid` Python utility can be used to determine the hash type and its corresponding `hashcat` and `john` modules: ``` hashid -m -j "" ``` Additionally, the `hashcat` documentation may be directly used as well in order to identify the hash type and its corresponding `hashcat` mode: ``` https://hashcat.net/wiki/doku.php?id=example_hashes ``` ### Passwords cracking tools It is recommended to use the cracking tools on the native operating system, as opposed to a virtual system, as the performance can greatly improve. John should be used for quick passwords cracking attempts while hashcat allows for better performance and more complex attacks for serious needs. **John-the-Ripper & magnumripper John-the-Ripper** `John`, also abbreviated `JrT`, is a password cracking tool, available notably on Linux and Windows and supporting a wide range of hashes type. The `Jumbo` version of `John the Ripper` is a community-enhanced version of `John` that can be found on the `magnumripper` `GitHub` repository. It notably supports more hash types. `John` will try to automatically detect the hash type of the provided hashes. John stores the cracked passwords in a "pot" file, located in `~/.john/john.pot`. `John-the-Ripper` usage: ``` john [OPTIONS] [HASH_FILE] # Supported hash types john --list=formats # Show cracked passwords john --show cat ~/.john/john.pot # With out the --format option, John will automatically attempt to determine the hash type. john --wordlist= john --wordlist= --format= # Default rules. john --wordlist= --rules --format= # Specified rule. john --wordlist= --rules= --format= ``` **hashcat** `hashcat` is an advanced cracking tool that generally offer better performance than `John` and is considered to be among the world's fastest password cracking tool. Multi-OS (Windows, Linux, etc.) and multi-platforms (CPU, GPU, etc.), `hashcat` supports more than 200 different hash types. Moreover, `hashcat` introduced rule-based attack, which is one of the most complicated of all the passwords cracking attack modes. The rule-based attack is like a programming language designed for password candidate generation. It has functions to modify, cut or extend words and has conditional operators. The [`OneRuleToRuleThemAll`](https://github.com/NotSoSecure/password_cracking_rules) or its newer version [`OneRuleToRuleThemStill`](https://github.com/stealthsploit/OneRuleToRuleThemStill) rule aggregate multiples rule sets with the aim of maximizing efficiency (success rates versus number of total candidates). The following attack modes can be used, specified by the `-a` / `--attack-mode` option: * 0: dictionary attack * 1: combinator attack, concatenating words from multiple wordlists * 3: mask attack, trying all combinations from a given keyspace, defined using a mask * 6/7: hybrid attack, combining wordlists+masks (mode 6) and masks+wordlists (mode 7) `hashcat` usage: ``` # Supported hash types, with a hash example # -m 500 for md5crypt # https://hashcat.net/wiki/doku.php?id=example_hashes hashcat --example-hashes # -w: Sets workload profile, with may have significant performance and power consumption impacts. 1 = Low, 2 = Default, 3 = High, and 4 = Nightmare. # --hwmon-temp-abort : Defines a maximum temperature in place of the default 90° celsius. hashcat [options] [] # Dictionary attack hashcat -w 3 -m -a 0 -o hashcat -w 3 -m -a 0 -r -o # Mask attack # A mask is a string that configures the keyspace of the password candidate # Built-in mask charsets ?l = abcdefghijklmnopqrstuvwxyz ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ ?d = 0123456789 ?h = 0123456789abcdef ?H = 0123456789ABCDEF ?s = «space»!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ ?a = ?l?u?d?s ?b = 0x00 - 0xff hashcat -w 3 -m -a 3 --increment -o "?a?a?a?a?a?a?a?a" hashcat -w 3 -m -a 3 --increment --increment-min=4 -o "?a?a?a?a?a?a?a?a" ``` ### Misc **Firefox / Thunderbird stored passwords** `Firefox` and `Thunderbird` save the password registered by the user in the user profile: ```bash ~/.mozilla/firefox/$profile$.default/ ~/.thunderbird/$profile$.default/ ``` The passwords are stored in the following files: ```bash Key3.db signons.sqlite3 / logins.json ``` A master password can be set in either program and this affects `key3.db`. By default no password is set. `John-the-Ripper` can be used to crack the master password: ```bash # First extract the master password hash python mozilla2john.py key3.db > john_key3.hash # Crack it with john john --show john_key3.hash ``` The passwords can then be extracted from the `Firefox` / `Thunderbird` profile: ```bash python firefox_decrypt/firefox_decrypt.py ``` **ZIP and RAR protected archives** The Linux utilities `zip2john` and `rar2john`, packaged with the `John the Ripper Jumbo` community version, can be used to extract the hash of the password protecting the archive. ``` zip2john > rar2john > ``` `Jumbo john` can then be used to crack the extracted hash. ``` # Detected hash type should be "PKZIP [32/64]" john --wordlist= john --wordlist= ``` The Linux utility `fcrackzip` may be used as well and works directly on the ZIP archive. ``` # -u (–use-unzip): use unzip to weed out wrong passwords # -D and -p: use dictionary with the specified wordlist fcrackzip -u -D -p ``` **Password protected PDF** The Linux utility `pdfcrack` can be used to crack password protecting PDF files. ``` pdfcrack -w -f ``` **Encrypted SSH private keys** The Linux utilities `ssh2john`, packaged with the `John the Ripper Jumbo` community version, can be used to convert an encrypted SSH private key to a crackable hash by `john`. ``` ssh2john > ``` `Jumbo john` can then be used to crack the extracted hash. ``` john --wordlist= ``` **Linux Unified Key Setup (LUKS)** `hashcat` and `bruteforce-luks` can be used to crack LUKS encrypted disks: ``` dd if= of=tmp_luks_header bs=512 count=4097 # dd if= of=tmp_luks_header bs=1M count=10 hashcat --force -m 14600 -a 0 -w 3 tmp_luks_header bruteforce-luks -t 4 -f tmp_luks_header ``` Once the password is retrieved, the Linux utility `cryptsetup` can be used to create a device that can be mounted: ``` cryptsetup open --type luks mount /dev/mapper/ /mnt ``` **PKCS#12 certificate** The Linux utilities `pfx2john`, packaged with the `John the Ripper Jumbo` community version, can be used to convert a password protected `PKCS12` certificate to a hash crackable by `john`. ``` pfx2john > john --wordlist= ``` **mRemoteNG** `mRemoteNG` is an open source multi-protocol remote connections manager. The connections information, including usernames and passwords, are stored encrypted in `confCons.xml` files. On older versions of `mRemoteNG`, the passwords were encrypted in AES-128-CBC using the md5 of `mR3m` as the secret key and storing the IV in the 16 first bytes of the passwords hash. The clear-text passwords can be retrieved on all `mRemoteNG` versions directly through the GUI application by creating an external tool: ``` Tools -> External Tools -> New External Tool Display Name: Print password Filename: cmd Arguments: /k echo %password% After the confCons.xml is loaded, the created external tool can be used to retrieve the passwords Connections -> -> External Tools -> Print pasword ``` *** ### References --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://notes.qazeer.io/general/passwords_cracking.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.