PACK（密码分析与破解工具包）是一套实用程序集合，旨在帮助分析密码列表，通过检测密码的掩码、规则、字符集及其他特征来增强密码破解效率。该工具包生成的输入文件可直接用于 Hashcat 系列密码破解工具。
注意：该工具包本身无法破解密码，而是旨在让密码破解工具的操作更高效。
在开始使用工具包之前，我们需要确定密码列表的选择标准。由于我们希望分析人们创建密码的方式，我们必须尽可能获取大量的泄露密码样本。一个极好的样本是基于 RockYou.com 泄露事件的列表。该列表提供了足够大且多样化的集合，能够很好地反映类似网站（如社交网络）的常用密码。但基于此列表的分析结果可能不适用于具有特定密码策略的组织。因此，选取的样本输入应尽可能接近你的目标。此外，尽量避免使用基于已破解密码的列表，因为这会引入统计偏差——这些规则和掩码反映的是破解者的行为，而非实际用户。
你能进行的最基本分析，是获取所提供列表中密码最常见的长度、字符集及其他特征。在下面的示例中，我们将使用包含约 1400 万个密码的 'rockyou.txt' 文件。使用以下命令行启动 statsgen.py：
$ python statsgen.py rockyou.txt
以下是上述命令的输出：
_
StatsGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] 正在分析 [rockyou.txt] 中的密码
[+] 分析进度 100% (14344390/14344390) 的密码
注意：以下统计数据均基于已分析的密码数量，而非总密码数
[*] 长度：
[+] 8: 20% (2966037)
[+] 7: 17% (2506271)
[+] 9: 15% (2191039)
[+] 10: 14% (2013695)
[+] 6: 13% (1947798)
...
[*] 字符集：
[+] loweralphanum: 42% (6074867)
[+] loweralpha: 25% (3726129)
[+] numeric: 16% (2346744)
[+] loweralphaspecialnum: 02% (426353)
[+] upperalphanum: 02% (407431)
...
[*] 密码复杂度：
[+] 数字: 最小值(0) 最大值(255)
[+] 小写: 最小值(0) 最大值(255)
[+] 大写: 最小值(0) 最大值(187)
[+] 特殊字符: 最小值(0) 最大值(255)
[*] 简单掩码：
[+] stringdigit: 37% (5339556)
[+] string: 28% (4115314)
[+] digit: 16% (2346744)
[+] digitstring: 04% (663951)
[+] othermask: 04% (576324)
...
[*] 高级掩码：
[+] ?l?l?l?l?l?l?l?l: 04% (687991)
[+] ?l?l?l?l?l?l: 04% (601152)
[+] ?l?l?l?l?l?l?l: 04% (585013)
[+] ?l?l?l?l?l?l?l?l?l: 03% (516830)
[+] ?d?d?d?d?d?d?d: 03% (487429)
...
注意：你可以使用 --hiderare 标志减少异常值显示，该标志不会显示出现次数低于 1% 的项目。
从以上列表中我们可以立即了解以下信息：
最后一部分“高级掩码”列出了最常出现的掩码，采用 Hashcat 格式。各个符号的含义如下：
?l - 单个小写字母
?u - 单个大写字母
?d - 单个数字
?s - 单个特殊字符
例如，第一个掩码 "?l?l?l?l?l?l?l?l" 将匹配所有小写字母密码。根据样本量，你将能够破解大约 4% 的密码。不过，在生成初始输出后，你可能会想使用过滤器来缩小密码数据的范围。
让我们看看 RockYou 用户在使用 "stringdigit" 简单掩码（字符串后跟数字）时如何选择密码：
$ python statsgen.py ../PACK-0.0.3/archive/rockyou.txt --simplemask stringdigit -q --hiderare
[*] 正在分析 [rockyou.txt] 中的密码
[+] 分析进度 37% (5339556/14344390) 的密码
注意：以下统计数据均基于已分析的密码数量，而非总密码数
[*] 长度：
[+] 8: 23% (1267260)
[+] 7: 18% (981432)
[+] 9: 17% (939971)
[+] 10: 14% (750938)
[+] 6: 11% (618983)
[+] 11: 05% (294869)
[+] 12: 03% (175875)
[+] 13: 01% (103047)
[+] 14: 01% (65958)
[*] 字符集：
[+] loweralphanum: 88% (4720184)
[+] upperalphanum: 06% (325941)
[+] mixedalphanum: 05% (293431)
[*] 密码复杂度：
[+] 数字: 最小值(1) 最大值(252)
[+] 小写: 最小值(0) 最大值(46)
[+] 大写: 最小值(0) 最大值(31)
[+] 特殊字符: 最小值(0) 最大值(0)
[*] 简单掩码：
[+] stringdigit: 100% (5339556)
[*] 高级掩码：
[+] ?l?l?l?l?l?l?d?d: 07% (420318)
[+] ?l?l?l?l?l?d?d: 05% (292306)
[+] ?l?l?l?l?l?l?l?d?d: 05% (273624)
[+] ?l?l?l?l?d?d?d?d: 04% (235360)
[+] ?l?l?l?l?d?d: 04% (215074)
...
输出顶部指明了总密码中被分析的百分比。在本例中，只破解匹配 "stringdigit" 掩码的密码，仅能恢复总集合的大约 37%，与原始输出一致。接着，似乎只有 11% 的这种密码类型使用了小写以外的字符。因此，明智的做法是只关注匹配该掩码的小写字符串。最后，在“高级掩码”部分，我们可以看到大多数 "stringdigit" 密码由字符串后跟两个或四个数字组成。根据从上述输出中获得的信息，我们可以开始形成目标用户密码生成模式的心理图景。
还有几个针对密码长度、掩码和字符集的过滤器可用：
长度： --minlength 和/或 --maxlength
简单掩码： --simplemask [numeric, loweralpha, upperalpha, mixedalpha, loweralphanum 等]
字符集： --charset [digit, string, stringdigit, digitstring, digitstringdigit 等]
注意：同一类别的多个过滤器可以通过逗号分隔列表指定：
--simplemask="stringdigit,digitstring"
虽然“高级掩码”部分只显示匹配超过 1% 密码的模式，但你可以通过以下命令获取并保存与给定字典匹配的完整密码掩码列表：
$ python statsgen.py rockyou.txt -o rockyou.masks
所有密码掩码及其频率将以 CSV 格式保存到指定文件中。当然，你可以提供过滤器，只生成符合指定参数的掩码文件。输出文件可作为下节介绍的 MaskGen 工具的输入。
MaskGen 允许你为 Hashcat 系列密码破解工具制作基于模式的掩码攻击。该工具使用上面 statsgen 通过 '-o' 标志生成的输出，以产生最优的掩码攻击，并按掩码复杂度、掩码出现次数或两者之比（最优指数）排序。
我们用 StatGen 的输出作为参数运行 MaskGen：
$ python maskgen.py rockyou.masks
_
MaskGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] 正在分析 [rockyou.masks] 中的掩码
[*] 计算时使用 1,000,000,000 keys/sec 速度。
[*] 按 [optindex] 对掩码排序。
[*] 掩码生成完成：
生成的掩码数量：146578
掩码覆盖率：100% (14344390/14344390)
掩码总运行时间：>1 年
你应该注意以下几点信息：
由于你通常受限于执行和策划攻击的时间，maskgen 允许你指定可用于掩码攻击的时间，并将根据排序模式生成最有效的掩码集合。让我们尝试不同的排序模式和目标时间：
$ python maskgen.py rockyou.masks --targettime 600 --optindex -q
[*] 正在分析 [rockyou.masks] 中的掩码
[*] 计算时使用 1,000,000,000 keys/sec 速度。
[*] 按 [optindex] 对掩码排序。
[!] 超出目标时间。
[*] 掩码生成完成：
生成的掩码数量：779
掩码覆盖率：56% (8116195/14344390)
掩码总运行时间：0:11:36
$ python maskgen.py rockyou.masks --targettime 600 --complexity -q
[*] 正在分析 [rockyou.masks] 中的掩码
[*] 计算时使用 1,000,000,000 keys/sec 速度。
[*] 按 [complexity] 对掩码排序。
[!] 超出目标时间。
[*] 掩码生成完成：
生成的掩码数量：5163
掩码覆盖率：31% (4572346/14344390)
掩码总运行时间：0:10:01
$ python maskgen.py rockyou.masks --targettime 600 --occurrence -q
[*] 正在分析 [rockyou.masks] 中的掩码
[*] 计算时使用 1,000,000,000 keys/sec 速度。
[*] 按 [occurrence] 对掩码排序。
[!] 超出目标时间。
[*] 掩码生成完成：
生成的掩码数量：4
掩码覆盖率：16% (2390986/14344390)
掩码总运行时间：1:34:05
以上所有运行的目标时间均为 600 秒（10 分钟），使用不同的排序模式。根据我们的实验，使用 OptIndex 排序模式生成的掩码可以在大约 10 分钟内破解 56% 的 RockYou 密码。而使用 Occurrence 排序模式生成的掩码覆盖率仅为 16%，并且超出了指定的目标时间超过一小时。
注意：按复杂度排序的掩码在攻击基于策略的列表时可能非常有效。
让我们使用 --showmasks 标志查看 maskgen 在 optindex 模式下生成的某些掩码：
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --showmasks
[*] 正在分析 [rockyou.masks] 中的掩码
[*] 计算时使用 1,000,000,000 keys/sec 速度。
[*] 按 [optindex] 对掩码排序。
[长度:] 掩码: [出现次数] [时间]
...
[ 7] ?l?d?s?l?l?d?d [6 ] [ 0:00:00]
[ 8] ?s?l?l?l?l?l?l?s [3480 ] [ 0:05:36]
[ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30]
[ 8] ?d?l?d?d?d?l?l?l [47 ] [ 0:00:04]
[ 8] ?d?l?l?d?l?d?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?l?d?d?l?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?d?l?d?d?l?l [47 ] [ 0:00:04]
[ 8] ?d?d?l?l?d?l?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?d?d?l?l?l?l [122 ] [ 0:00:11]
[ 8] ?u?u?d?u?d?d?d?d [18 ] [ 0:00:01]
[ 6] ?d?s?s?s?s?s [4 ] [ 0:00:00]
[10] ?l?l?l?l?l?l?l?l?d?d [213109 ] [ 5:48:02]
[!] 超出目标时间。
[*] 掩码生成完成：
生成的掩码数量：3970
掩码覆盖率：74% (10620959/14344390)
掩码总运行时间：16:10:38
显示的掩码遵循非常直观的格式：
[ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30]
\ \ \
\ _ 生成的掩码 \ _ 掩码运行时间
\
_ 掩码长度 _ 掩码出现次数
在上述示例中，你可以看到掩码生成背后的一些逻辑。例如，虽然 '?s?l?l?l?l?l?l?s' 掩码在样本中运行时间最长之一（5 分钟），但由于其出现次数相对高于 '?l?l?l?l?d?d?d?d?s'，因此仍具有更高优先级。同时，虽然 '?l?d?s?l?l?d?d' 的覆盖率相当低，但由于它是一个仅 6 个字符的掩码，执行速度非常快，因此仍比其他掩码获得更高优先级。
你可以通过使用过滤器进一步优化生成的掩码攻击。例如，你可能拥有足够强大的硬件，可以简单地暴力破解所有长度不超过 8 个字符的密码。在这种情况下，你可以使用 --minlength 标志仅生成长度大于 8 个字符的掩码，如下所示：
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --minlength 8
[*] 正在分析 [rockyou.masks] 中的掩码
[*] 计算时使用 1,000,000,000 keys/sec 速度。
[*] 按 [optindex] 对掩码排序。
[!] 超出目标时间。
[*] 掩码生成完成：
生成的掩码数量：585
掩码覆盖率：41% (5905182/14344390)
掩码总运行时间：15:50:36
生成的掩码覆盖率自然会减少，但当你准备用于攻击其他密码列表（而非用于生成它们的列表）的掩码集合时，这些过滤器就会变得有用。
下面列出了你可以使用的其他过滤器：
单个掩码过滤器选项：
--minlength=8 最小密码长度
--maxlength=8 最大密码长度
--mintime=3600 最小掩码运行时间（秒）
--maxtime=3600 最大掩码运行时间（秒）
--mincomplexity=1 最小复杂度
--maxcomplexity=100
最大复杂度
--minoccurrence=1 最小出现次数
--maxoccurrence=100
最大出现次数
Occurrence 和 complexity 标志在使用不同排序模式微调生成的掩码时尤为强大。
一旦你对上述生成的掩码感到满意，可以使用 -o 标志保存它们：
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q -o rockyou.hcmask
[*] 正在分析 [rockyou.masks] 中的掩码
[*] 将生成的掩码保存至 [rockyou.hcmask]
[*] 计算时使用 1,000,000,000 keys/sec 速度。
[*] 按 [optindex] 对掩码排序。
[!] 超出目标时间。
[*] 掩码生成完成：
生成的掩码数量：3970
掩码覆盖率：74% (10620959/14344390)
掩码总运行时间：16:10:38
这将生成 'rockyou.hcmask' 文件，该文件可直接用于 Hashcat 工具套件，或作为自定义脚本的一部分进行循环调用。
了解生成的掩码在已破解列表上的表现通常很有用。Maskgen 可以将一组掩码与另一组进行比较，以查看如果一个密码列表的掩码用于另一个列表时会如何表现。我们来比较一下基于 RockYou 列表生成的掩码在另一个泄露列表（如 Gawker）上的表现：
$ python statsgen.py ../PACK-0.0.3/archive/gawker.dic -o gawker.masks
$ python maskgen.py gawker.masks --checkmasksfile rockyou.hcmask -q
[*] 正在分析 [gawker.masks] 中的掩码
[*] 计算时使用 1,000,000,000 keys/sec 速度。
[*] 检查 [rockyou.hcmask] 中掩码的覆盖率
[*] 掩码匹配完成：
匹配的掩码数量：1775
掩码覆盖率：96% (1048889/1084394)
掩码总运行时间：16:25:44
使用 '--checkmasksfile' 参数，我们尝试用之前生成的 'rockyou.hcmask' 文件中的掩码，来匹配来自样本泄露列表 'gawker.masks' 的掩码。结果获得了 96% 的良好覆盖率，其中 3970 个生成的 RockYou 掩码中有 1775 个与 Gawker 列表中的掩码匹配。
还可以通过在命令行中直接指定一个或多个掩码来查看其覆盖率，如下所示：
$ python maskgen.py gawker.masks --checkmasks="?u?l?l?l?l?l?d,?l?l?l?l?l?d?d" -q
[*] 正在分析 [gawker.masks] 中的掩码
[*] 计算时使用 1,000,000,000 keys/sec 速度。
[*] 检查以下掩码的覆盖率 [?u?l?l?l?l?l?d, ?l?l?l?l?l?d?d]
[*] 掩码匹配完成：
匹配的掩码数量：2
掩码覆盖率：1% (18144/1084394)
掩码总运行时间：0:00:04
指定的两个掩码仅匹配了 1% 的覆盖率。
根据你的具体硬件规格和目标哈希值，你可能需要使用 '--pps' 参数来增加或减少计算时使用的 keys/sec 速度：
$ python maskgen.py rockyou.masks --targettime 43200 --pps 50000000 -q
[*] 正在分析 [rockyou.masks] 中的掩码
[*] 计算时使用 50,000,000 keys/sec 速度。
[*] 按 [optindex] 对掩码排序。
[!] 超出目标时间。
[*] 掩码生成完成：
生成的掩码数量：1192
掩码覆盖率：61% (8754548/14344390)
掩码总运行时间：12:17:31
使用 '--pps' 参数匹配你的实际性能，可以使目标时间更有意义。
许多掩码和字典攻击在企业环境中会失败，因为那里有最低密码复杂度要求。与其求助于纯暴力破解攻击，我们可以利用已知或猜测的密码复杂度规则，避免尝试不符合策略的密码候选词，或者反过来只审计不符合策略的密码。使用 PolicyGen，你将能够生成一组符合密码复杂度的掩码，从而显著缩短破解时间。
以下是一个示例会话，我们为要求至少一个大写字母、一个数字和一个特殊字符的环境生成所有有效的密码掩码。
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o complexity.hcmask
_
PolicyGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected][*] Saving generated masks to [complexity.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Password policy:
Pass Lengths: min:8 max:8
Min strength: l:1 u:1 d:1 s:1
Max strength: l:None u:None d:None s:None
[*] Generating [compliant] masks.
[*] Generating 8 character password masks.
[*] Total Masks: 65536 Time: 76 days, 18:50:04
[*] Policy Masks: 40824 Time: 35 days, 0:33:09
从以上输出可以看出，我们生成了 40824 个符合指定复杂度的掩码，在 1,000,000,000 keys/sec 的速度下大约需要 35 天运行。
如果你只是执行密码审计，并且任务仅需发现不合规的密码，可以指定 --noncompliant 标志来反转生成的掩码：
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o noncompliant.hcmask -q --noncompliant
[*] Saving generated masks to [noncompliant.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Password policy:
Pass Lengths: min:8 max:8
Min strength: l:1 u:1 d:1 s:1
Max strength: l:None u:None d:None s:None
[*] Generating [non-compliant] masks.
[*] Generating 8 character password masks.
[*] Total Masks: 65536 Time: 76 days, 18:50:04
[*] Policy Masks: 24712 Time: 41 days, 18:16:55
让我们看看上述生成的一些不合规掩码，使用 --showmasks 标志：
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o noncompliant.hcmask -q --noncompliant --showmasks
[*] Saving generated masks to [noncompliant.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Password policy:
Pass Lengths: min:8 max:8
Min strength: l:1 u:1 d:1 s:1
Max strength: l:None u:None d:None s:None
[*] Generating [non-compliant] masks.
[*] Generating 8 character password masks.
[ 8] ?d?d?d?d?d?d?d?d [l: 0 u: 0 d: 8 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?l [l: 1 u: 0 d: 7 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?u [l: 0 u: 1 d: 7 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?s [l: 0 u: 0 d: 7 s: 1] [ 0:00:00]
...
[ 8] ?s?s?s?s?s?s?s?d [l: 0 u: 0 d: 1 s: 7] [ 0:07:06]
[ 8] ?s?s?s?s?s?s?s?l [l: 1 u: 0 d: 0 s: 7] [ 0:18:28]
[ 8] ?s?s?s?s?s?s?s?u [l: 0 u: 1 d: 0 s: 7] [ 0:18:28]
[ 8] ?s?s?s?s?s?s?s?s [l: 0 u: 0 d: 0 s: 8] [ 0:23:26]
[*] Total Masks: 65536 Time: 76 days, 18:50:04
[*] Policy Masks: 24712 Time: 41 days, 18:16:55
如你所见，所有掩码都至少缺少一项密码复杂度要求。有趣的是，虽然生成的掩码更少，但攻击时间却更长，因为存在像 ?s?s?s?s?s?s?s?s 这样的长时间运行的掩码。
还可以使用 --maxlower、--maxupper、--maxdigit 和 --maxspecial 标志来指定最大密码复杂度，以便精细调整攻击。例如，下面是一个示例站点，它强制执行密码策略但不允许任何特殊字符：
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --maxspecial 0 -o maxcomplexity.hcmask -q
[*] Saving generated masks to [maxcomplexity.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Password policy:
Pass Lengths: min:8 max:8
Min strength: l:1 u:1 d:1 s:None
Max strength: l:None u:None d:None s:0
[*] Generating [compliant] masks.
[*] Generating 8 character password masks.
[*] Total Masks: 65536 Time: 76 days, 18:50:04
[*] Policy Masks: 5796 Time: 1 day, 20:20:55
rulegen.py 实现了针对 Hashcat 密码破解器的密码分析与规则生成，其原理在论文 Automatic Password Rule Analysis and Generation 中有所描述。请查阅该文档以获取关于规则分析与生成理论的详细讨论。
从已破解密码中反向推导源单词和单词变形规则，对于攻击仍处于加密状态的哈希值非常有效。通过持续循环利用/扩展生成的规则和单词，你可能能够破解更多数量的密码。
有效使用 rulegen.py 需要满足几个前提条件。该工具利用 Enchant 拼写检查库来与多种拼写检查引擎（如 Aspell、MySpell 等）交互。使用前必须安装这些工具。同时，务必为所使用的拼写检查引擎安装字典（也可以使用自定义词表）。此外，为了便于使用，我打包了 PyEnchant，它应能直接与 Enchant 的共享库交互；但如果出现问题，只需删除打包的 enchant 目录，然后安装适用于你发行版的 PyEnchant。
关于特定 Hashcat 规则语法的更多详细信息，请参见 Hashcat Rule Based Attack。
rulegen.py 最基本的用法是分析单个密码并自动检测规则。让我们检测用于生成示例密码 P@55w0rd123 的规则和潜在源单词：
$ python rulegen.py --verbose --password P@55w0rd123
_
RuleGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing password: P@55w0rd123
[-] Pas sword => {edit distance suboptimal: 8 (7)} => P@55w0rd123
[+] Password => sa@ ss5 so0 $1 $2 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 o81 $2 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 i81 o92 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 i81 i92 oA3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 o81 o92 $3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 o81 i92 oA3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 i81 o92 oA3 => P@55w0rd123
在这个示例中，我们使用了几个标志：
密码文件的处理将在下面的章节中介绍；不过，让我们先以单个密码为例，讨论一些可用的微调选项。
注意，我们使用的是 Enchant 的 aspell 模块进行源单词检测。可以使用 --provider 标志更改具体的拼写检查引擎，如下所示：
$ python rulegen.py --verbose --provider myspell --password P@55w0rd123 -q
[*] Using Enchant 'myspell' module. For best results please install
'myspell' module language dictionaries.
...
注意：提供者引擎的优先级可以使用逗号分隔的列表指定（例如 --provider aspell,myspell）。
可以通过 --word 标志指定源单词，从而完全禁用源单词检测引擎：
$ python rulegen.py -q --verbose --word word --password P@55w0rd123
[*] Analyzing password: P@55w0rd123
[+] word => ^5 ^5 ^@ ^P so0 $1 $2 $3 => P@55w0rd123
通过指定不同的源单词，你可以用规则生成引擎进行许多有趣的实验。
不可避免地，你会遇到标准拼写引擎词表不足以生成规则的情况。你可以使用 --wordlist 标志指定自定义词表。这在重复使用之前分析会话中的源单词时尤其有用：
$ python rulegen.py -q --verbose --wordlist rockyou.txt --password 1pa55w0rd1
[*] Using Enchant 'Personal Wordlist' module. For best results please install
'Personal Wordlist' module language dictionaries.
[*] Analyzing password: 1pa55w0rd1
[+] password => ^1 ss5 so0 $1 => 1pa55w0rd1
自定义词表在使用俚语等不常见单词以及使用已破解密码时尤其有用。
虽然 rulegen.py 试图生成并仅记录最佳的源单词和密码，但在某些情况下，你可能对更多结果感兴趣。使用 --morewords 和 --morerules 标志可以生成可能超出最优编辑距离的单词和规则：
$ python rulegen.py -q --verbose --password '$m0n3y$' --morerules --morewords
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing password: $m0n3y$
[+] money => ^$ so0 se3 $$ => $m0n3y$
[+] moneys => ^$ so0 se3 o6$ => $m0n3y$
[+] mingy => ^$ si0 sg3 $$ => $m0n3y$
[+] many => ^$ sa0 i43 $$ => $m0n3y$
[+] Mooney => sM$ o1m so0 se3 $$ => $m0n3y$
可以使用 --maxworddist 和 --maxwords 标志进一步扩展生成的单词。类似地，可以使用 --maxrulelen 和 --maxrules 标志生成更多规则。
rulegen.py 包含多个高级引擎以生成更高质量的单词和规则。如果需要，可以禁用它们以观察差异（或者如果它们导致问题），使用 --simplewords 和 --simplerules 标志。让我们观察启用这些标志后源单词和规则的变化：
$ python rulegen.py -q --verbose --password '$m0n3y$' --simplewords --simplerules
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing password: $m0n3y$
[-] Meany => {edit distance suboptimal: 5 (4)} => $m0n3y$
[+] many => i0$ o20 i43 i6$ => $m0n3y$
[+] mingy => i0$ o20 o43 i6$ => $m0n3y$
[+] money => i0$ o20 o43 i6$ => $m0n3y$
[+] mangy => i0$ o20 o43 i6$ => $m0n3y$
[+] manky => i0$ o20 o43 i6$ => $m0n3y$
注意，生成的单词和规则质量显著下降，像 'manky' 这样的单词与实际源单词 'money' 的关系较弱。同时，生成的规则简化为简单的插入、删除和替换。
现在你已经掌握了所有不同的标志和开关，我们可以尝试为一系列密码生成单词和规则。让我们生成一个包含以下相当复杂测试密码的文本文件 korelogic.txt：
&~defcon
'#(4)\
August19681
'&a123456
10-D'Ann
~|Bailey
Krist0f3r
f@cebOOK
Nuclear$(
zxcvbn2010!
13Hark's
NjB3qqm
Sydney93?
antalya%]
Annl05de
;-Fluffy
现在让我们通过将密码文件作为第一个参数来观察 rulegen.py 的分析：
$ python rulegen.py korelogic.txt -q
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing passwords file: korelogic.txt:
[*] Press Ctrl-C to end execution and generate statistical analysis.
[*] Saving rules to analysis.rule
[*] Saving words to analysis.word
[*] Finished processing 16 passwords in 1.00 seconds at the rate of 15.94 p/sec
[*] Generating statistics for [analysis] rules and words.
[-] Skipped 0 all numeric passwords (0.00%)
[-] Skipped 2 passwords with less than 25% alpha characters (12.50%)
[-] Skipped 0 passwords with non ascii characters (0.00%)
[*] Top 10 rules
[+] ^3 ^1 o4r - 3 (2.00%)
[+] i61 i79 i86 i98 oA1 - 2 (1.00%)
[+] ^- ^0 ^1 i4' o5A - 2 (1.00%)
[+] sS1 i13 T2 - 1 (0.00%)
[+] i61 se9 i86 i98 oA1 - 1 (0.00%)
[+] o61 i79 i86 i98 oA1 - 1 (0.00%)
[+] ^- ^0 ^1 so' i5A - 1 (0.00%)
[+] D3 si0 i55 $e - 1 (0.00%)
[+] i61 i79 se6 i98 oA1 - 1 (0.00%)
[+] i3a o5y o6a i7% o8] - 1 (0.00%)
[*] Top 10 words
[+] Analyze - 1 (0.00%)
[+] defcon - 1 (0.00%)
[+] Kristen - 1 (0.00%)
[+] Bailey - 1 (0.00%)
[+] Augusts - 1 (0.00%)
[+] Annelid - 1 (0.00%)
[+] Hack's - 1 (0.00%)
[+] antlers - 1 (0.00%)
[+] antelope - 1 (0.00%)
[+] xxxv - 1 (0.00%)
使用所有默认设置，我们生成了几个高质量的规则。应用程序显示了基本的前 10 个规则和单词统计信息。所有生成的规则和单词默认保存到基本名 'analysis' 中：
请注意，有些密码（如 #(4)\ 和 &a123456）因为不具备足够的处理特征而被跳过。除了字母字符数量，程序还会跳过所有数字密码和包含非 ASCII 字符的密码。后者是由于 Enchant 引擎的一个 bug，我希望将来能修复它，从而能够处理多种语言的单词。
如前所述，rulegen.py 默认将输出文件保存为 'analysis' 基本名。你可以使用 --basename 或 -b 标志更改文件基本名，如下所示：
$ python rulegen.py korelogic.txt -q -b korelogic
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing passwords file: korelogic.txt:
[*] Press Ctrl-C to end execution and generate statistical analysis.
[*] Saving rules to korelogic.rule
[*] Saving words to korelogic.word
在某些情况下，你可能会遇到为 Hashcat 密码破解器生成规则时的问题。rulegen.py 包含 --hashcat 标志，用于使用 hashcat 自身（以 --stdout 模式运行）验证生成的单词和规则。要让此模式正常工作，你必须下载最新版本的 hashcat-cli 并在源代码中编辑 HASHCAT_PATH 变量。例如，在撰写本文时，我将 hashcat-0.## 文件夹放在了 PACK 目录下，并将 HASHCAT_PATH 定义为 hashcat-0.##/。
你还可以使用 --debug 标志观察规则生成引擎的内部工作原理。不要担心某些规则失败的消息，这是停机问题求解器在尝试寻找最优且有效解时的结果。
虽然本指南介绍了许多分析密码、逆向规则和生成掩码的方法，但还有更多技巧等待你去发现。如果你能告诉我这些工具的某些不寻常的用途或建议，我会非常兴奋。
祝破解愉快！
-Peter