totse.com | Password Cracking Using Focused Dictionaries

NOTICE: TO ALL CONCERNED Certain text files and messages contained on this site deal with activities and devices which would be in violation of various Federal, State, and local laws if actually carried out or constructed. The webmasters of this site do not advocate the breaking of any law. Our text files and message bases are for informational purposes only. We recommend that you contact your local law enforcement officials before undertaking any project based upon any information obtained from this or any other web site. We do not guarantee that any of the information contained on this system is correct, workable, or factual. We are not responsible for, nor do we assume any liability for, damages resulting from the use of any information on this site.

Can the chances of cracking an individual?s password be improved by using a more focused dictionary? This dictionary would contain words and information that have a specific relationship to the owner of the targeted password. Such information could comprise, names of spouse and children, birth dates, pet names, schools etc.

When attempting to crack passwords, there are two often-used approaches: dictionary and brute-force attacks. A dictionary attack involves taking a list of words, then feeding them through the password routine to see if they are the correct password. More specifically, in the case of Unix passwords, for example, the dictionary word is fed through the password hashing mechanism and compared to the stored password. If they match, then we have cracked the password.

Furthermore, when using a dictionary attack, the words are often hybridized to account for subtle password changes. For example, under a password policy where the password must change every 30 days, the password could start off as ?puddles21? and then next time it?s changed become ?puddles22?. This is a common practice among password users as it makes it easier for the individual to remember a new password. But ?puddles21? does not exist in any dictionary that I know of. Yet a simple hybrid of the dictionary word ?puddles? could put numbers ranging from 1-100 at the end of the word, and we would then crack the password.

Many dictionaries exist that have been crafted based on language, movies, music, location, schools, books, politics and so forth. By using one dictionary after another, and then feeding them through some hybridization routines, we can increase the chance of cracking an individual?s password.

The brute-force method of cracking passwords is a sure way to find any password, providing that the character set used is large enough. This method can take a lengthy amount of time to complete. In a sense, the brute-force method is essentially using the largest dictionary that can be created from any given character set.

Do people tend to use passwords that have a close relationship to some aspect of their life? This question is hard to answer without qualitative study. But as an administrator I have seen people use names of pets, children, race car drivers, rock stars, planets and even swear words as passwords. My particular password policy also requires that an individual use at least one (1) digit in their password.

There are also those individuals who use passwords that have no relation to them, such as perkins, c1t1bank, puzz[{s and so forth.

And then there are those who use phrases as their password, for example "hmniwbmvimpvm" (From that great movie Sneakers ? can you guess?)

If we are looking for a specific password of a specific individual, we could improve our chances of cracking their password by using a dictionary that contains words with a close relationship to that individual.

What follows is a spreadsheet that could be used to collate personal information about your target. Remember the movie Wargames? Turns out that the password was the name of the target?s son: Joshua. (Of course, joshua is in a standard dictionary, but hey you know what I mean)

Now that we have our raw data, we need some rules for creating hybrids of this information. The hybrids of these passwords aren?t actually stored in the dictionary themselves because the dictionary would grow too big. Rather, the hybrids are generated on the fly by the password-cracking program.

Words can be changed through simple appends. Specifically, append the following:

-ing(e.g. pauling)
-er(e.g. pauler)
-s(e.g. pauls)
-?s(e.g. paul?s)
-4u(e.g. paul4u)
-4you
-2b(e.g. paul2b)
-2be

It should be noted that many of the words become ?nonsense? after the grammar change, but our process is not designed to care about nonsense words. Rather it generates quick hybrids of the words, and feeds them through the password program.

Words can be changed by substituting characters that ?look? like their letter equivalent. The list I suggest follows:

O or o becomes0 (zero)(e.g. p00l)
0becomesO or o
G or gbecomes@(e.g. scra@@y)
L or l or I or i becomes1 or ! or |(e.g. pub!|c)
3becomes] or }
E or ebecomes[ or {(e.g. jo{)
S or sbecomes$ or 5(e.g. $tuff)
C or cbecomes( or [(e.g. ar(h)

A common technique of hardening passwords is to substitute non-standard characters for the regular letters of the alphabet, or other numbers. These letter-changing rules can help attack this practice.

Each newly generated hybrid should be used with a number spread. The range I suggest is 0 through 99. For example,

Now that we have defined our dictionary and hybridization rules, in what order should we apply them? The following table suggests a procedure. Some definitions that apply are:

Please note that these calculations were based on all words being used as permutations together. In other words, when analyzing wordword pairs, the word pairs themselves are not duplicates, but rather mathematical permutations. For example, the words joe and public would form 4 permutations unlike most dictionary cracking programs that would only form duplicates of the word; i.e. joejoe and publicpublic.

This list of hybridization combinations is not exhaustive. It is a good start. For example, wordword(gc)(ns) is missing, along with others.

The reason I chose the format of the last series of letter changes is because if the individual makes a letter change in one word, chances are they?ll do it to the second word also. Of course someone could concatenate two dictionary words together as their password, and only make letter changes to the first password, but as I said, this is not an exhaustive hybrid list. For example, word(gc)lc(word(ns)) is missing, along with many others.

How efficient? What numbers are involved? Here?s the hybrid rules list again with new definitions:

Number of words = w
Number of grammar changes = g
Number of letter changes = l
Number spread = n

Using a password-cracking program on my P2-400Mhz computer, I can achieve an average crack rate of 4800 login/password combinations per second.

To implement the strategy in this paper we need a password-cracking program. This program should be fast in its attempts to crack passwords, and it should have a flexible enough language to generate the required hybrids of the input dictionary. The best program I could find is one called John the Ripper. Unfortunately, it is not complete, and its shortcomings I will mention later.

This excellent program, whose primary purpose is to test weak UNIX passwords, comes with a very large number of rules that change the dictionary words. An exhaustive list of all these rules is beyond this paper, but the reader is referred to http://www.openwall.com/john/ where one can find downloads and documentation.

The standard option of John is to crack passwords using information from the password file itself. The words in the password file can be used in a true ?permutable? fashion; i.e. the generated passwords come from combinations of these words. However, when operating in dictionary mode, John will only hybridize one word at a time. This is a shortcoming of the program; one that the author assures me will be dealt with at some future time.

The workaround to this problem is that we can include our focused dictionary inside of the password information. More specifically, with respect to cracking the UNIX password file, we can place all of these words in the GECOS information areas. The number of words inserted here could be up to 200 or so, which would require a compilation change for John. Specifically:

Unfortunately, John the Ripper is capable of cracking other password types, LDAP for example, and I guess we?ll have to wait for the change to the dictionary mode until that time.

The initialization file that is used by John includes a language to construct the hybridization rules. The number of components that comprise a rule has a maximum number of eight (8). This makes some of my rules unusable unless a compilation change is made. The rules are commented out in the supplied initialization file. The compilation change:

Convert the collected data from the spreadsheet into a text file with each word delimited by a space. For example:

Appendix A contains the Single Mode cracking rules. For ease of use I also included all the other options within the .INI file so simply cut and paste Appendix A into notepad or emacs, and save it as john.ini.

Is it possible that compiling the information about the intended target takes much longer than a brute-force attack on the same password? The actual time taken to hybridize and password-test the 200 or so words is the fastest part of this whole process, but it might take a week or so to compile the target information.

Character set: [A-Z][a-z][0-9][~!@#$%^%&*()-=_+`[]{};?:"\|,.<>/?]
Total: 95 characters
PC capable of 48000 tries/second at a maximum length of 8 character passwords

958 (i.e. each character position could be 1 of 95 choices
= 6.6e1015 passwords (then divide by 48000)
= 1.38e1011 seconds or about 4382 years!

A dictionary attack will always take less time than the corresponding brute-force attack using the same dictionary?s character set.

The administrator?s password is often the intended target, and they may sometimes pick a good password. In that case, brute-force is the only choice. But for the most part they pick poor passwords just like the rest of us. My focused dictionary approach, along with the hybrid rule set, should improve the chances of cracking a password.

I have had this idea for some time now. What I been unable to do is perform some qualitative analysis on this. At some point, with the blessing of Sans perhaps, I would like to create a website for a form and a CGI that collects the information and the encrypted/unencrypted password, and then performs a series of tests.

I would collect the unencrypted password in case the end-user is unable to supply it.

Default rules, default dictionary
Default rules, focused dictionary
My rules, default dictionary
My rules, focused dictionary
Such an exercise would have to be run for a period of time.

If an administrator is willing to supply me with password files for testing purposes, I would be more than grateful. I do not need to know where they came from; I am just interested in the results from a cracking attempt.

Klein, Daniel V., " "Foiling the cracker": A survey of, and Improvements to, Password Security", Feb 22nd 1991, http://packetstorm.securify.com/papers/password/klein.ps

Thompson, Ken & Morris, Robert, "Password Security: A Case History", http://www.alw.nih.gov/Security/FIRST/papers/password/pwstudy.ps

Feldmeier, David C., Karn, Philip R. "UNIX Password Security ? Ten Years Later", http://www.alw.nih.gov/Security/FIRST/papers/password/pwtenyrs.ps

Password Cracking Using Focused Dictionaries

by Paul Bobby