CTF之——密码破解工具hashcat，零基础入门到精通，看完这篇就足够了~

hashcat号称世界上最快的密码破解，世界上第一个和唯一的基于GPU的规则引擎，免费多GPU（高达128个GPU），多哈希，多操作系统（Linux和Windows本地二进制文件），多平台（OpenCL和CUDA支持），多算法，资源利用率低，基于字典攻击，支持分布式破解等等，hashcat目前支持各类公开算法高达247类，市面上面公开的密码加密算法基本都支持！在渗透测试中我们往往会得到很多hash

前端开发小司机

1292人浏览 · 2024-10-21 17:51:01

前端开发小司机 · 2024-10-21 17:51:01 发布

HashCat密码破解工具介绍

hashcat支持多种计算核心：



1.  `GPU`
    
2.  `CPU`
    
3.  `APU`
    
4.  `DSP`
    
5.  `FPGA`
    
6.  `Coprocessor`

GPU的驱动要求



1.   `AMD GPUs on Linux require "RadeonOpenCompute (ROCm)" Software Platform (1.6.180 or later)`
    
2.   `AMD GPUs on Windows require "AMD Radeon Software Crimson Edition" (15.12 or later)`
    
3.   `Intel CPUs require "OpenCL Runtime for Intel Core and Intel Xeon Processors" (16.1.1 or later)`
    
4.   `Intel GPUs on Linux require "OpenCL 2.0 GPU Driver Package for Linux" (2.0 or later)`
    
5.   `Intel GPUs on Windows require "OpenCL Driver for Intel Iris and Intel HD Graphics"`
    
6.   `NVIDIA GPUs require "NVIDIA Driver" (367.x or later)`

就目前市面的笔记本完全够用，比如：

下面是这个工具的下载和官网：
官网: https://hashcat.net/hashcat/
Wiki: https://hashcat.net/wiki/
下载地址:https://hashcat.net/files/hashcat-5.1.0.7z

HashCat常见使用参数



1.  `-a 指定要使用的破解模式，其值参考后面对参数。“-a 0”字典攻击，“-a 1” 组合攻击；“-a 3”掩码攻击。`
    
2.  `-m 指定要破解的hash类型，如果不指定类型，则默认是MD5`
    
3.  `-o 指定破解成功后的hash及所对应的明文密码的存放位置,可以用它把破解成功的hash写到指定的文件中`
    
4.  `--force 忽略破解过程中的警告信息,跑单条hash可能需要加上此选项`
    
5.  `--show 显示已经破解的hash及该hash所对应的明文`
    
6.  `--increment 启用增量破解模式,你可以利用此模式让hashcat在指定的密码长度范围内执行破解过程`
    
7.  `--increment-min 密码最小长度,后面直接等于一个整数即可,配置increment模式一起使用`
    
8.  `--increment-max 密码最大长度,同上`
    
9.  `--outfile-format 指定破解结果的输出格式id,默认是3`
    
10.  `-r 使用自定义破解规则`

破解模式有：



1.  `# | Mode`
    

3.   `0 | Straight（字典破解） ：基于字典进行破解`
    
4.   `1 | Combination（组合破解） ：基于多个字典进行破解`
    
5.   `3 | Brute-force（掩码暴力破解） ：基于掩码设置进行破解`
    
6.   `6 | Hybrid Wordlist + Mask（字典+掩码破解）`
    
7.   `7 | Hybrid Mask + Wordlist（掩码+字典破解）`

输出格式：



1.  `1 = hash[:salt]`
    
2.  `2 = plain`
    
3.  `3 = hash[:salt]:plain`
    
4.  `4 = hex_plain`
    
5.  `5 = hash[:salt]:hex_plain`
    
6.  `6 = plain:hex_plain`
    
7.  `7 = hash[:salt]:plain:hex_plain`
    
8.  `8 = crackpos`
    
9.  `9 = hash[:salt]:crackpos`
    
10.  `10 = plain:crackpos`
    
11.  `11 = hash[:salt]:plain:crackpos`
    
12.  `12 = hex_plain:crackpos`
    
13.  `13 = hash[:salt]:hex_plain:crackpos`
    
14.  `14 = plain:hex_plain:crackpos`
    
15.  `15 = hash[:salt]:plain:hex_plain:crackpos`

支持破解的hash：

因为比较多所以就不一一列举，可以hashcat64.exe –help查看



1.  `- [ Hash modes ] -`
    

3.   `# | Name | Category`
    
4.   `======+==================================================+======================================`
    
5.   `900 | MD4 | Raw Hash`
    
6.   `0 | MD5 | Raw Hash`
    
7.   `5100 | Half MD5 | Raw Hash`
    
8.   `100 | SHA1 | Raw Hash`
    
9.   `1300 | SHA2-224 | Raw Hash`
    
10.   `1400 | SHA2-256 | Raw Hash`
    
11.   `10800 | SHA2-384 | Raw Hash`
    
12.   `1700 | SHA2-512 | Raw Hash`
    
13.   `17300 | SHA3-224 | Raw Hash`
    
14.   `17400 | SHA3-256 | Raw Hash`
    
15.   `17500 | SHA3-384 | Raw Hash`
    
16.   `17600 | SHA3-512 | Raw Hash`
    
17.   `10 | md5($pass.$salt) | Raw Hash, Salted and/or Iterated`
    
18.   `20 | md5($salt.$pass) | Raw Hash, Salted and/or Iterated`
    
19.   `30 | md5(utf16le($pass).$salt) | Raw Hash, Salted and/or Iterated`
    
20.   `40 | md5($salt.utf16le($pass)) | Raw Hash, Salted and/or Iterated`
    
21.   `3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and/or Iterated`
    
22.   `3710 | md5($salt.md5($pass)) | Raw Hash, Salted and/or Iterated`
    
23.   `4010 | md5($salt.md5($salt.$pass)) | Raw Hash, Salted and/or Iterated`
    
24.   `4110 | md5($salt.md5($pass.$salt)) | Raw Hash, Salted and/or Iterated`
    
25.   `2600 | md5(md5($pass)) | Raw Hash, Salted and/or Iterated`
    
26.   `3910 | md5(md5($pass).md5($salt)) | Raw Hash, Salted and/or Iterated`
    
27.   `4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and/or Iterated`
    
28.   `4400 | md5(sha1($pass)) | Raw Hash, Salted and/or Iterated`
    
29.   `110 | sha1($pass.$salt) | Raw Hash, Salted and/or Iterated`
    
30.   `120 | sha1($salt.$pass) | Raw Hash, Salted and/or Iterated`
    
31.   `130 | sha1(utf16le($pass).$salt) | Raw Hash, Salted and/or Iterated`
    
32.   `140 | sha1($salt.utf16le($pass)) | Raw Hash, Salted and/or Iterated`
    
33.   `4500 | sha1(sha1($pass)) | Raw Hash, Salted and/or Iterated`
    
34.   `4520 | sha1($salt.sha1($pass)) | Raw Hash, Salted and/or Iterated`
    
35.   `4700 | sha1(md5($pass)) | Raw Hash, Salted and/or Iterated`
    
36.   `4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and/or Iterated`
    
37.   `14400 | sha1(CX) | Raw Hash, Salted and/or Iterated`
    
38.   `1410 | sha256($pass.$salt) | Raw Hash, Salted and/or Iterated`
    
39.   `1420 | sha256($salt.$pass) | Raw Hash, Salted and/or Iterated`
    
40.   `1430 | sha256(utf16le($pass).$salt) | Raw Hash, Salted and/or Iterated`
    
41.   `1440 | sha256($salt.utf16le($pass)) | Raw Hash, Salted and/or Iterated`
    
42.   `1710 | sha512($pass.$salt) | Raw Hash, Salted and/or Iterated`
    
43.   `1720 | sha512($salt.$pass) | Raw Hash, Salted and/or Iterated`
    
44.   `1730 | sha512(utf16le($pass).$salt) | Raw Hash, Salted and/or Iterated`
    
45.   `1740 | sha512($salt.utf16le($pass)) | Raw Hash, Salted and/or Iterated`
    
46.   `14000 | DES (PT = $salt, key = $pass) | Raw Cipher, Known-Plaintext attack`
    
47.   `14100 | 3DES (PT = $salt, key = $pass) | Raw Cipher, Known-Plaintext attack`
    
48.   `14900 | Skip32 (PT = $salt, key = $pass) | Raw Cipher, Known-Plaintext attack`
    
49.   `15400 | ChaCha20 | Raw Cipher, Known-Plaintext attack`
    
50.   `2500 | WPA-EAPOL-PBKDF2 | Network Protocols`
    
51.   `2501 | WPA-EAPOL-PMK | Network Protocols`
    
52.   `16800 | WPA-PMKID-PBKDF2 | Network Protocols`
    
53.   `16801 | WPA-PMKID-PMK | Network Protocols`
    
54.   `7300 | IPMI2 RAKP HMAC-SHA1 | Network Protocols`
    
55.   `7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network Protocols`
    
56.   `8300 | DNSSEC (NSEC3) | Network Protocols`
    
57.   `10200 | CRAM-MD5 | Network Protocols`
    
58.   `11100 | PostgreSQL CRAM (MD5) | Network Protocols`
    
59.   `11200 | MySQL CRAM (SHA1) | Network Protocols`
    
60.   `16100 | TACACS+ | Network Protocols`

掩码设置



1.  `l | abcdefghijklmnopqrstuvwxyz 纯小写字母`
    
2.  `u | ABCDEFGHIJKLMNOPQRSTUVWXYZ 纯大写字母`
    
3.  `d | 0123456789 纯数字`
    
4.  `h | 0123456789abcdef 常见小写字母和数字`
    
5.  `H | 0123456789ABCDEF 常见大写字母和数字`
    
6.  ``s | !"#$%&'()*+,-./:;<=>?@[]^_`{|}~ 特殊字符``
    
7.  `a | ?l?u?d?s 键盘上所有可见的字符`
    
8.  `b | 0x00 - 0xff 可能是用来匹配像空格这种密码的`

下面举几个简单的例子来了解一下掩码的设置



1.  `八位数字密码：?d?d?d?d?d?d?d?d`
    
2.  `八位未知密码：?a?a?a?a?a?a?a?a`
    
3.  `前四位为大写字母，后面四位为数字：?u?u?u?u?d?d?d?d`
    
4.  `前四位为数字或者是小写字母，后四位为大写字母或者数字：?h?h?h?h?H?H?H?H`
    
5.  `前三个字符未知，中间为admin，后三位未知：?a?a?aadmin?a?a?a`
    
6.  `6-8位字母密码：--increment --increment-min 6 --increment-max 8 ?l?l?l?l?l?l?l?l`
    
7.  `6-8位数字+小写字母密码：--increment --increment-min 6 --increment-max 8 ?h?h?h?h?h?h?h?h`

再看几个例子

一、数字破解(8位:12345678)



1.  `hashcat64.exe -m 0 -a 3 25d55ad283aa400af464c76d713c07ad ?d?d?d?d?d?d?d?d`

二、小写字母(6位:abcdef)



1.  `hashcat64.exe -m 0 -a 3 e80b5017098950fc58aad83c8c14978e ?l?l?l?l?l?l`

三、字母+数字(8位:1a31fa1c)



1.  `hashcat64.exe -a 3 -m 0 --force b54e53e2f21b7260df895bc885ceaa3e --increment --increment-min 1 --increment-max 8 ?h?h?h?h?h?h?h?h`

四、字典破解
-a 0是指定字典破解模式，-o是输出结果到文件中



1.  `hashcat64.exe -a 0 ede900ac1424436b55dc3c9f20cb97a8 password.txt -o result.txt`

五、字典破解密码：



1.  `hashcat64.exe -m 0 -a 0 ./dict/hash.txt ./dict/password.txt -o result.txt`

字典组合破解：



1.  `hashcat64.exe -a 1 25f9e794323b453885f5181f1b624d0b pwd1.txt pwd2.txt`

字典+掩码破解



1.  `hashcat64.exe -a 6 9dc9d5ed5031367d42543763423c24ee password.txt ?l?l?l?l?l`

Mysql4.1/5的PASSWORD函数



1.  `hashcat64.exe -a 3 -m 300 --force 6BB4837EB74329105EE4568DDA7DC67ED2CA2AD9 ?d?d?d?d?d?d`

mssql



1.  `hashcat64.exe -a 3 -m 132 --force 0x01008c8006c224f71f6bf0036f78d863c3c4ff53f8c3c48edafb ?l?l?l?l?l?d?d?d`

wordpress密码hash破解
具体加密脚本在./wp-includes/class-phpass.php的HashPassword函数



1.  `hashcat64.exe -a 3 -m 400 --force $P$BYEYcHEj3vDhV1lwGBv6rpxurKOEWY/ ?d?d?d?d?d?d`

discuz用户密码hash破解
其密码加密方式md5(md5( p a s s ) . pass). pass).salt)



1.  `hashcat64.exe -a 3 -m 2611 --force 14e1b600b1fd579f47433b88e8d85291: ?d?d?d?d?d?d`

Zip压缩包破解
使用zip2john获取密码哈希值

设置hash类型：win-zip 扫描模式：掩码模式



1.  `hashcat64.exe -m 13600 -a 3 $zip2$*0*3*0*b71633a9a7fc15682a0dad00d17f1a43*2cee*1d*4c55a370878091d08bd637730ae11c1abdcdbcdbe099d14c166826216d*770b0e7ff9bbc5e4149c*$/zip2$ ?d?d?d?d?d?d --show`

破解Windows hash

使用mimikatz获取windows hash：
需要管理员权限



1.  `mimikatz.exe log`
    
2.  `mimikatz # privilege::debug`
    
3.  `mimikatz # sekurlsa::logonpasswords`
    
4.  `mimikatz # exit`

NT-hash:



1.  `hashcat64.exe -a 3 -m 1000 b4814903533072474831d4791b7d4a9c ?l?l?l?d?d?d?s`

破解RAR压缩密码
首先rar2john获取rar文件hash值下载地址

获取rar文件的hash值：rar2john.exe 1.rar
结果：



1.  `rar:$rar5$16$639e9ce8344c680da12e8bdd4346a6a3$15$a2b056a21a9836d8d48c2844d171b73d$8$04a52d2224ad082e`



1.  `hashcat64.exe -a 3 -m 13000 --force $rar5$16$639e9ce8344c680da12e8bdd4346a6a3$15$a2b056a21a9836d8d48c2844d171b73d$8$04a52d`

破解office密码

获取office的hash值：python office2john.py 1.docx(这个脚本可以去github上下)
结果：



1.  `1.docx:$office$*2013*100000*256*16*e4a3eb62e8d3576f861f9eded75e0525*9eeb35f0849a7800d48113440b4bbb9c*577f8d8b2e1c5f60fed76e62327b38d28f25230f6c7dfd66588d9ca8097aabb9`



1.  `hashcat64.exe -a 3 -m 9600 $office$*2013*100000*256*16*e4a3eb62e8d3576f861f9eded75e0525*9eeb35f0849a7800d48113440b4bbb9c*577f8d8b2e1c5f60fed76e62327b38d28f25230f6c7dfd66588d9ca8097aabb9 --force ?d?d?d?d?d?d`

破解WIFI密码
首先先把我们的握手包转化为hccapx格式，现在最新版的hashcat只支持hccapx格式了，以前的hccap格式已经不支持了

官方在线转化https://hashcat.net/cap2hccapx/



1.  `hashcat64.exe -a 3 -m 2500 1.hccapx 1391040?d?d?d?d`

最后：
里面的工具zip2john，rar2john，office2john在johntheripper里面都有，可以在这里下载：链接：https://pan.baidu.com/s/1yKmm4birQapA7Sx9I_VIaQ
提取码：q2jf

hashcat规则编写知识

只要有效利用Hashcat的规则，就可对长度超过8个字符的密码进行高效破解，但是，尝试编写自己的规则可能会令人生畏。因为它太过灵活，可配置性很高，需要了解很多知识。官方提供了一些规则的说明，在此我也会提供一些自己的总结。
基础和调试
我们要做的第一件事就是学习如何测试我们自己编写的规则。首先，创建一个包含spring的简单字典：
echo spring> dict.txt
创建一个新文件，这将是我们的规则文件（我命名为test.rule）。在规则文件中输入c并保存。注意，c规则将单词的第一个字母大写，其余字母小写，因此spring应该成为Spring。测试如下：
hashcat64.exe -r test.rule --stdout dict.txt
Spring

以下是某些规则的基本说明：

基础

请注意其中的大写规则，如果字符串为!spring或!SPRING，处理后仍然是!spring，因为这个规则对数字或特殊字符（第一个字符）没有任何作用。

可能我们最有用的规则是将字符附加到单词的开头或结尾。让我们看看以下这个规则，它会对字典中的密码先全部小写，再在末尾追加2019：
c $2$0$1$9

其中c和$之间的空格只是为了便于阅读。如果在我们的test.rule文件中保存以上规则，然后运行它，将会得到：
hashcat64.exe -r test.rule --stdout dict.txt
Spring2019

将字符添加到字符串的开头则有点不同，乍一眼可能看起来很奇怪。例如，要将123添加到单词的开头，则规则为：
^3^2^1

你需要先反转要附加的字符串。如果你将上述规则添加到规则文件中，然后运行，就可以获得123spring。如果你想和其他规则结合起来，那么你需要非常小心。因为，如果你的规则是^3^2^1 c，那么输出仍然是123spring，因为此时首字符是1。要获得123Spring的输出，需要使用规则c ^3^2^1。

复制

在需要设定很长的密码时，人们通常会通过复制来解决这个问题。而且我发现这个重复次数经常是2次或是3次，再配合上述的附加规则生成的密码往往非常有效。以下是针对“spring”一词中使用重复规则的一些示例：



1.  `c d $2$0$1$9 --> SpringSpring2019`
    
2.  `d c $2$0$1$9 --> Springspring2019`
    
3.  `c $2$0$1$9 d --> Spring2019Spring2019`
    
4.  `$2$0$1$9 d c --> Spring2019spring2019`

替换

你当然也可以使用替换规则替换字符。Hashcat自带的leetspeak.rule文件有一些简单的例子，而Incisive-leetspeak.rule文件中有更多的示例。规则ss$会将password转换为pa$$word。

其他规则

还有很多其他规则可以用来构建你的字典，但上述几个应该就能解决你的大部分问题（根据我的经验）。

规则融合

下一步，我们需要对我们的规则有一个明确的要求，它通常涉及某种模式。例如，在某次破解密码的过程中，我们率先知道密码是有一个固定的格式的，例如像Spring2019那种模式，第一个字符大写，后面字符小写，最后以数字结尾，通常是年份或日期。因此，如果我们想要生成这样模式的字典，我们需要将第一个字符大写，然后追加年份。
最终规则看起来就像这样：c $2$0$1$9
运行后，我们会得到：Spring2019

但是如果我们想要生成很多年份，而不仅仅是2019年呢？好吧，我们必须遍历写出另我们想要的年份所对应规则。它们可能看起来像下面这样：



1.  `# Example: spring --> Spring2019`
    
2.  `c $1$9$8$1`
    
3.  `c $1$9$8$2`
    
4.  `c $1$9$8$3`
    
5.  `c $1$9$8$4`
    
6.  `c $1$9$8$5`
    
7.  `c $2$0$1$5`
    
8.  `c $2$0$1$6`
    
9.  `c $2$0$1$7`
    
10.  `c $2$0$1$8`
    
11.  `c $2$0$1$9`

但后来你又想在最后添加一个特殊字符，因为你记得人们经常也这样做，例如问号和感叹号，于是你写了更多的规则：



1.  `# Example: spring --> Spring2019!`
    
2.  `c $1$9$8$1$!`
    
3.  `c $1$9$8$2$!`
    
4.  `c $1$9$8$3$!`
    
5.  `c $1$9$8$4$!`
    
6.  `c $1$9$8$5$!`
    
7.  `c $2$0$1$5$!`
    
8.  `c $2$0$1$6$!`
    
9.  `c $2$0$1$7$!`
    
10.  `c $2$0$1$8$!`
    
11.  `c $2$0$1$9$!`

此时，你可能会强迫自己停止思考，因为这样下去没完没了。因此，你可能需要一些自动化的方法。在继续下一章自动规则生成前，如下是我经常使用的一些规则以及示例：



1.  `# Example: thanksgiving --> thanksgiving1234`
    
2.  `$1$2$3$4`
    
3.  `$1$q$a$z`
    
4.  `$z$a$q$1`
    
5.  `$!$@$#$$`
    

7.  `# Example: thanksgiving --> Thanksgiving1234`
    
8.  `c $1$2$3$4`
    
9.  `c $1$q$a$z`
    
10.  `c $z$a$q$1`
    
11.  `c $!$@$#$$`
    

13.  `# Example: winter --> WinterWinter!`
    
14.  `c d $!`
    

16.  `# Example: winter --> Winter!Winter!`
    
17.  `c $! d`
    

19.  `# Example: winter --> Winterwinter!`
    
20.  `d $! c`
    

22.  `# Example: winter --> Winter!winter!`
    
23.  `$! d c`

请记住，通常我还会创建上述规则的许多变种，例如在前面添加字符等。

自动生成规则-date_rule.py

用脚本去生成脚本通常是在明确知道所需的规则类型的情况下，为了减轻手动操作，节约时间而执行的操作。

我自己编写了一个脚本文件，能将各种格式的日期附加到每个规则中，并且还能在每个字符串的开头或结尾添加字符。我能使用包括00-99，0101-13131，010180-12312019甚至01011980-12312019中的所有内容，同时又排除不是日期的数字，最后还拥有足够的灵活性。我把这个脚本放在date_rule.py。

我不会在此深入代码的工作原理，你只需知道它能构建一个复杂的规则文件，使得最后生成的密码既包含日期，又有指定的字符串。

以上这些只需要一点创造力和编程能力即可完成。如果你不擅长编程，那就从现在开始锻炼吧。

规则生成器——Maskprocessor

Hashcat团队中的某个开发人员开发了一个名为maskprocessor的工具，可以让你轻松创建复杂的规则文件。可以点击这里下载。

我们可以通过Maskprocessor利用掩码的方式帮助我们编写混合了众多规则的规则文件。下面是如何使用maskprocessor生成规则文件的示例，最后生成的规则文件的具体作用分别是：
1.为字典中的每个密码的结尾附加一个任意字符（列出所有情况）；
2.为字典中的每个密码的结尾附加两个任意字符（列出所有情况）；
3.在结尾附加一个任意字符，两个任意字母或特殊字符（列出所有情况）



1.  `mp64.exe -o test.rule "$?a"`
    
2.  `mp64.exe -o test.rule "$?a $?a"`
    
3.  `mp64.exe -o test.rule -1 ?s?d "$?a $?1 $?1"`

现在我们执行的基于规则的攻击，相当于同时运行三种不同的攻击。

此时基于规则的攻击：



1.  `hashcat64.exe -a 0 -m 0 md5_hashes.txt wordlist.txt -r test_rule.rule`

等效于下面的三种攻击：



1.  `hashcat64.exe -a 6 -m 0 md5_hashes.txt wordlist.txt ?a`
    
2.  `hashcat64.exe -a 6 -m 0 md5_hashes.txt wordlist.txt ?a?a`
    
3.  `hashcat64.exe -a 6 -m 0 md5_hashes.txt wordlist.txt -1 ?s?d ?a?1?1`

虽然看起来更加简洁了，但它并没有赋予我们新能力。但是，我们还是可以发现它有两种非常重要的能力：

1）我们可以在密码的两侧放置掩码。例如，假设您想要将数字（?d）添加到字符串的开头，将任何字符（?a）添加到结尾，包括所有情况。
生成这种规则的命令如下：mp64.exe -o test1.rule "^?d $?a"

2）你还想让字符串的首字母大写吗？
以下是生成规则文件的命令：mp64.exe -o test1.rule "c ^?d $?a"

也许你还想先首字母大写，再复制一次，然后在开头添加数字，最后在结尾添加任何字符，生成这样的规则文件的命令如下：
mp64.exe -o test1.rule "c d ^?d $?a"

你可以进行你想要的任何操作，当然，产生的规则越多，攻击所需的时间就越长。以下是我最喜欢的几个规则生成命令（注意：可能需要很长时间）：



1.  `mp64.exe -o jake.rule "c $?a"`
    
2.  `mp64.exe -o jake.rule "c $?a $?a"`
    
3.  `mp64.exe -o jake.rule -1 ?s?d "c $?a $?1 $?1"`
    
4.  `mp64.exe -o jake.rule "c $?d $?d $?d"`
    
5.  `mp64.exe -o jake.rule "c $?d $?d $?d $?d"`
    
6.  `mp64.exe -o jake.rule "c $?d $?d $?d $?d $?d"`
    
7.  `mp64.exe -o jake.rule "c $?d $?d $?d $?d $?d $?d"`
    
8.  `mp64.exe -o jake.rule "c $?d $?d $?d $?d $?s"`
    
9.  `mp64.exe -o jake.rule -1 ?s?d "c ^?1"`
    
10.  `mp64.exe -o jake.rule -1 ?s?d "c ^?1 $?a"`
    
11.  `mp64.exe -o jake.rule -1 ?s?d "c $?1 $?d $?d $?1"`
    
12.  `mp64.exe -o jake.rule -1 ?s?d "c $?1 $?d $?d $?d $?d"`

申明：所分享内容仅用于网络安全技术讨论，切勿用于违法途径，