pcl.txt

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

Examples (let $w - password):

$w.u(1).u(-) - PassworD
$w.s.t(4) - pssw
$w.t(4).s - pss


2.2.3.  Permutation brackets.

Maybe you know the password, but it does not work when you enter it.
You probably made a mistake when you typed it. To discover such
passwords, the program has its own specific algorithm. It checks the 
following common typing errors while trying to discover your password:
two letters are swapped (psasword), 
one letter is removed (pasword),
an extra letter is inserted (passweord)
or one is replaced with another (passwird).

Such changes of a password are called "permutations".
The start and end of a possible permutation in the
password are indicated with permutation brackets: "{" and  "}". 
"}" is followed by the permutation number (default=1), 
separated by "." or in parentheses. The value of the permutation 
number sets the number of simultaneously allowed mistakes. Examples:


{abc} - will receive 182 (different) passwords, such as:
  bac, acb - 2 swaps;
  bc, ac, bc - 3 removals;
  aabc, babc... - 4 * 26 - 3 inserts;
  bbc, cbc... - 3 * 25 replacements;
  abc - and the word;

{Password}.2 or {Password}(2) - in particular, words as:
 "psswrod", "passwdro" and "paasswor" will be received;

{$w} - all words with one error from the basic dictionary.

Notes:
1) It  is obvious  that some  passwords will  be generated more
than once, so  the larger is  the number of  permutations, the
larger is the  number of replicas.  Efforts were made  in this
program to reduce replicas, but they are purely empirical  and
were made for  two permutations at  most. In other  words, for
the  large  numbers  there  is  no certainty that a particular
password  cannot  be  discarded  erroneously.  Fanatics of the
theory  of  combinations  can  compute  the  exact  number for
{password}.3, for  example, then  I'll be  able to  compare it
with that one obtained by the program.
2) For insertion  and replacement you  are to know  the set of
characters to be inserted or  replaced. In the event this  set
is not specified explicitly (see section 4.3.4), this  program
forms  it  automatically  for  character  sets, in relation to
standard set these characters  are from (i. e.  for {password}
$a will be inserted, for {Password} [$a $A] will be inserted).
The similar operation  with words is  performed, based on  the
first word from the dictionary with modifiers being taken into
account. In the event this set is specified explicitly, it  is
just the set to be used.

3)  Current  restriction  is  that  the  character  '{'   must
necessarily   be   the     first    in   the     line.    Such
expressions   as  good_{password} remain to be  supported, but
{good}_password is quite possible.

2.3. Description of the dictionaries and character sets.

The dictionaries to be used are set in the beginning of 
the password definition file before the line beginning with '##'.

2.3.1. Description of the dictionaries.

The beginning of the definition file can be used to specify the basic 
and user dictionary (see item 2.2.2). It is necessary only if the 
password description file will be using words from the dictionaries, 
(i.e. $w or $u).

The dictionaries are set as follows:

$w = "<dictionary_filename>"  # the basic dictionary
$u = "c:\\dict\\user.dic"     # additional
It is necessary to place the filenames in quotes, and to use 
shield symbols when defining the filepath(s).

2.3.2. Definition of used character sets.

Used character sets can be further defined by the user if needed, or
predefined sets may be used. The predefined sets consist of:

$a - small latin letters, only 26 elements;
$A - large latin letters, only 26 elements;
$! - special symbols  {}:"<>?[];\',./~!@#$%^&*()_+`-=\|  - (32 elements);
$1 - figures, (10 elements).

User-defined sets consist of:

$i - lowercase letters of the national alphabet;
$I - uppercase letters of the national alphabet;
$o - additional set (for example, any character which does
not actually appear on a physical keyboard key).

The definition of sets is determined by the following format:

$<set> = [< single symbols or character sets >]

The character set can also consist of the name and a combination of
symbols (see 2.2.1), for example:

$o = [$! $1 \FF]

NOTES:
1) You may specify any character sets, including the predefined sets. 
For example, it is possible to add additional symbols in set $!, 
such as a blank or \FF.
2) The definition of sets $i and $I automatically determines
rules of upper/lowercase conversion. Therefore it is important 
that the letters in these sets are in the same order.

Only after all character sets are defined, the complete set of
'?' symbols will be formed, consisting of [$a $A $1 $! $i $I $o],
in that order (it is important for following item).

2.3.3. Definition of the conversion modifiers.

Conversion modifiers .c (see item 2.2.2) can be defined with 
reference to a complete set of symbols '?' using lines of 
the following format:

?.c(<number>) = " < conversion line > "

Each symbol available in a complete set will be transformed 
according to its position in the conversion string. For
example, let

?      = [1234567890], then
?.c(0) = "!@#$%^&*()"

sets shift-conversion.

In the conversion string it is necessary to shield the symbols '\' and '"".
The value of the conversion modifier can be from 0 up to 255.

2.3.4. Definition of special character sets

The special character sets are:
$v - the set of vowels (in all alphabets) - this is required only if
the modifiers .s and .j are used.
$p - the set for insertion within permutation brackets - this is
required only if, for some reason, this set does not include
a previously defined permutation string (see item 2.2.3).
They are are used like previously explained character sets.


2.4. Useful examples of password descriptions.

1) Let me give you a fragment from the documentation on the
program ZEXPL2L:  "Let's assume that you have an archive with a
password, similar to "Heaven!!!", but you have forgotten, how
many exclamation points '!' were at the end of the password,
and if the vowels in the password were upper or lower case.
This password would be written using the PCL language as:
 "He [aA] v [eE] n! * "
Let's also assume that you weren't sure about a
set within basic part of the password. Then it would be 
necessary to try following:  
"{He [aA]  v [eE]  n} !  * "

2) Another quote: "If you were to have two variants of a line
of the password:  "myprog", "MyProg","my_prog" and "My_Prog".
It should be written down as:
"[mM] y [_ \0] [pP] rog".

3)  It  is  often  recommended  to  use  two meaningful words,
separated   by   certain   character,   as   a  password.  The
description is as following:
 "$w [$1 $!] $w" or
 "$w.u(1) [$1 $!] $w.u(1)"
It is important to note that the use of $w are not equal in these two
examples, and will generate a total of (if there are 20000 words in the dic-
tionary): 20000 * 42 * 20000 = 1.68E10 passwords.
Accordingly, if it is simply two words separated by a number,
breaking the password would be 42 times faster.

4)  You remember that your password was "MyVeryLongGoodPassword",
but it  does not match for some reason when you type it in. Try these
combinations:
  "{MyVeryLongGoodPassword}" - 2382 passwords
  "{MyVeryLongGoodPassword}.2" - 2836413 passwords


5) You know that the password consists of an meaningful word,
inside of which some figure is inserted ("meanin8gful"). The appropriate
description would then be:

$p = [$1]  # define insert set
##
{$w}

7) Attack on syllables. Create a dictionary of allowed syllables in your
language, and then it is possible to test all intelligent-sounding words
as follows:

$u      # all one-syllable words
$u$u    # two-syllables
$u$u$u  #etc.
$u$u$u$u
...

8) To do the work on 2 computers, set
the following descriptions:
"[abcdefghijklm] $a * " - first
"[nopqrstuvwxyz] $a * " - second.
You can do likewise for n of computers.


3. Interface with the application.

It's rather simple and is described in the PCL.H file.


4. How to contact to the author.

Only by e-mail.

FIDO: 2:5030/145.17
e-mail: [e-mail]
WWW: http://www.ssl.stu.neva.ru/psw/

The PCL library is distributed by the author as FREEWARE containing .LIB files 
(under Borland, Watcom C) or .a (under DJGPP) with the requirement that if you
use it in your programs, you are required to include a reference to 
it and the author in your programs. Basic URL of library:

http://www.ssl.stu.neva.ru/psw/crack.html#PCL

Comments on the source texts - subject of a separate conversation.
It is now in a the development stage, therefore I would be very glad to hear
about any mistakes and defects in it, especially comments, ideas, or
wishes concerning its improvement and additions.


5. Thanks to.

Solar Designer and Alec Muffett - for ideas of some modifiers.
Eric Young - for timing function from libdes.
John Vandermeersch for correcting this docs.