pcl.txt

用于zip arj rar 等密码破解库源码,非常好用

THIS WAS A MACHINE TRANSLATION!
I HAVE NO TIME TO CORRECT IT - WHO CAN HELP, E-MAIL ME PLEASE!
----------------------------------------------------------------
Changes in the versions:

2.0c
  - minor fixes. Now is open source project.

2.0b
  - ".c(1) not defined" error message appeared although you were not
using .c(1); Has been fixed. Passwords counter is now unsigned long long
for gcc compiler and double for others. Password printing in hex has been
added. Compiled with Pentium Pro/II optimizations.

2.0a
  - "5th line" bug fixed for password definitions greater than
4 lines. Thanks to Dmitry Lisiy.
   
2.0:
- Added: support for different languages and encodings, charset
definition, new modifiers and their parameters, timing and benchmarking,
maximum password length now depends only on the amount of free memory.
The max_psw_len, min_psw_len parameters were changed.

1.1:
- The small defects are corrected. The support of special character sets was
added.

1.0:
- First version released.
-----------------------------------------------------------------


           Password Cracking Library (PCL) v. 2.0.

        (c) Copyright PSW-soft 1996-2001 by P. Semjanov


THE PROVIDED VERSION of the LIBRARY IS the BETA-version And IS
DISTRIBUTED "AS IS". USE IT AT YOUR OWN RISK.
ANY CLAIMS ON WORK of the PROGRAM WILL NOT BE ACCEPTED.
THE AUTHOR DOES NOT GUARANTEE FUTURE SUPPORT or UPDATES
TO VERSIONS of THE LIBRARY.

The program included in this archive is FREEWARE and can be 
distributed freely under the following conditions: 
the program code may not be changed,
the program must be distributed in its original form, 
and the reference to PCL in your applications is obligatory.


1. Purpose and characteristics.

The Password Cracking Library is intended to simplify the
writing of password cracking applications
and facilitates the following actions:
- Multifunctional dictionary attack;
- Brute force attack with known characters;
- Recovering an incorrectly typed password, and more.
The library is released as the object files and is 
intended for use with the following compilers:
- Turbo/Borland C/C ++;
- Watcom C/C ++;
- gcc (DJGPP)


2. Password definition file.

The password definition file (PDF) is the main managing file. 
Its  compilation and processing is purely the basic task of the PCL.
The format of the PCL is independent of the application it's used on, 
therefore this library can be used with any 
password-protected filetype.

2.1. Format of the password definition file.


The password definition file is a plain text file divided into two parts:
dictionaries and character set descriptions, and password description.
These parts are divided by the line '##' as in the example below:

[ <the description of the dictionaries and character sets> ]
##
<the description of the passwords>

The first part can be absent; if so, then the file should begin with '##'.
Thus in any other place the symbol '#' is considered as the beginning of
a comment. The blanks and tabulation in a file of the descriptions are
ignored and can be used to visually divide any components.

For convenience, let's first consider the mechanism of the description of 
the passwords, and then the description of character sets, instead of 
against a sequence of the descriptions in a file: 

2.2. Description of the passwords.

It is a required part of the file which goes after "##' line, and 
consists of text lines. Each line defines a set of passwords and 
the working mode, i.e. which algorithm will be used. Each line is 
independent and is processed separately, thus the total number of the 
checked passwords is counted. The basic components of the password 
definition file are: character sets, and words from the dictionaries.
They define one or more characters or symbols, which will be inserted
in the specified places during the password attempts.

2.2.1. Character sets.

The character set (charset) is a set of symbols which can be in a
specified position in the password. They can be either of the following:

 1) Simple single symbols (a, b, etc.). Meaning, that in the
specified position of the password, this will be the only character tried.

 2) Shielded symbols. Special symbols, if they are known to be in
the password, should be shielded. The meaning  is identical
with mentioned above

They are:

  \$, \., \*, \?, \=     - "$", ".", "*", "?", "="
  \], \[, \ , \}, \(, \) - appropriate brackets
  \ (space)              - space
  \\                     - "\"
  \XX, where X is a hex-digit - any symbol in hex-code
  \0 - empty symbol (absence of a symbol). This is usually applied
  in association with the "present" symbol (see examples below).

Basically, any symbols can be shielded, if they are not hex-digits.

  3) Symbol set macros. These sets are defined in 
the first part of the description file (see 2.3.2). 
Meaning that in a current position of the password there is 
any symbol, determined by following macros:

  $a - lower Latin letters (if not defined, there are 26 possibilities);
  $A - upper Latin letters (if not defined, there are 26 possibilities);
  $! - special marks (if not defined,  32 possibilities);
  $1 - Figures (if not defined,  10 possibilities);
  $i - lower national letters;
  $I - upper national letters;
  $o - User's set;
  ?  - Any symbol, i.e. all chars included in these macros.

Note: $v and $p (see 2.3.4) could not be used to generate passwords.

4) Combinations of any of the listed symbols above. The combination
must be enclosed with square brackets. The  meaning is identical with
mentioned above.

Examples:

[$a $A] - any Latin letter;
[abc] - or a, or b, or c;
[$1 abcdef] - hex-digit;
[s \0] - or s, or nothing;
[$a $A $1 $! $i $I $o] - is equivalent to ?.

5) Repetition of symbol(s) "*". Means that the previous 
character set needs to be repeated 0 or more times in 
the appropriate position of the password. Examples:

$a * - password of any length from the small Latin letters;
[ab] * - is empty, a, b, aa, ab, ba, bb, aaa...
[$a $A] [$a $A $1] * - "identifier" - sequence of the letters and
figures, and first letter.

Please note that a password of length 0 symbols can exist, 
and is not always equivalent to absence of a password.
Length of recurrence is calculated automatically on the basis of given maximum
and minimum password by a call of the basic function of the library
parse_rules_file(). Also note that these parameters influence only the
length of a password generated using the "*" symbol and will
not be used if the password consists only of words or static symbols.
It is recommended that you use "*" as often if possible due to the 
fact that it will create the most effective brute force attack.
Current restriction: "*" can only be the last element of a line.

2.2.2. Words from the dictionaries and their modifiers.

Unlike a character set, the word uses not one, but a few
symbols of the password in succession. The PCL library supports
two dictionaries: basic (where more frequently used words are found),
and user (more specific information such as names or dates).
The dictionary is a text file, consisting of words, divided by end of 
line (EOL) symbols. Files such as DOS (CR/LF), and UNIX-format (LF)
can be used. It  is desirable (to increase search rate, among other
factors) to use words of the same (lower) case in dictionaries.

Thus, two macros exist:

$w - Word from the basic dictionary
$u - Word from the user dictionary.

Special character sets are  also considered as words,  because
they can be  of arbitrary length.  They are denoted  as $s(1),
$s(2),  ...  and  depend  on  peculiarities of the task.
The use of special charsets is meaningful only for the specified 
location in the password. Let's assume that $s(1) determines the 
first 2 symbols of the password, and $s(2) determines the third. 
Then only following examples make sense:

$s(1) $s(2)
$S(1) ?
?? $s(2)

Frequently, passwords are altered words. Therefore, to
determine such passwords, the whole set of modified words
are entered. Use following switches:

.u (upper) - convert to uppercase;
.l (lower) - convert to lowercaser;
.t (truncate) - truncate at given length;
.c (convert) - transform the word;
.j (joke) - convert some letters to uppercase;
.r (reverse) - reverse the word;
.s (shrink) -  reduce a word;
.d (duplicate) - repeat a word 2 times.

The modifiers can have parameters enclosed in parentheses. For
modifiers intended to work on separate letters, it is possible to 
set the parameter to indicate the position of the specific letter;
absence of the parameter or a parameter of zero applies the switch 
to the whole word. Further, specific letter positions can be set 
both from the beginning or from the end of the word. The end of a 
word is designated by the '-' symbol.

Currently there are only 3 such modifiers: .u, .l, .t. So,

.u or .u(0) - uppercase the whole word (PASSWORD);
.u(1), .u(2) - uppercase only first (second) letter (Password, pAssword);
.u(-), .u(-1) - uppercase last (last but one) letter (passworD, passwoRd);
.t(-1) - cut off last letter in a word (passwor).

Other switches work only with the whole word and the parameter sets the 
conversion mode. Currently, only the following switch parameters are legal:

.j(0) or .j - uppercase the odd letters (PaSsWoRd);
.j(1) - uppercase the even letters (pAsSwOrD):
.j(2) - uppercase the vowels (pAsswOrd);
.j(3) - uppercase the consonants (PaSSWoRD);
.r(0) or .r - reverse a word (drowssap);
.s(0) or .s - reduce a word by removing vowels, if it is not the first char (password - > psswrd, offset - > offst);
.d(0) or .d - duplicate a word (passwordpassword);
.d(1) - add the reversed word (passworddrowssap);
.c(<number>) - convert all letters in a word according to the
conversion string (see item 2.3.3).

All switches will work correctly with both latin characters and 
national characters (if the national characters are set correctly).
Switch can also be combined (restriction of their
number in succession - 63, which is hardly possible to exceed).