最新消息：
    你的位置：jinglingshu的博客 > Python > 暴力破解测试工具–Patator 源码分析

    暴力破解测试工具–Patator 源码分析

    Python admin 2780浏览 0评论

    转自：http://blog.csdn.net/yueguanghaidao/article/details/9473559

    说到暴力破解大家首先想到的肯定是hydra,的确hydra的确非常强大，支持几乎所有的弱密码破解。hydra本身使用C语言开发，性能很高，很适合学习。

    但今天我们使用的是Patator,Patator本身使用Python开发，最新版本也就4000行左右，可以说小到极致，这主要多亏了Python库的丰富和强大。

    Patator下载地址：http://code.google.com/p/patator/downloads/list。

    比较遗憾的是需要自己提供密码字典，下面我们就揭开Patator的真面目。

    先来扫个telnet弱密码，看下效果：

    其中telnet_login,意思是扫telnet,其中user.txt是用户名字典，passwd.txt是密码字典

     

     

    Patator和hydra都会交叉用户名和密码文件，通过上诉比较我们可以看出，两者最大不同点在于，hydra直接可以输出成功的用户名和密码，但Patator只输出认证后信息。

    这也导致了hydra比Patator更好用，但难免会有误报。

    其中telnet模块源码如下：

     

    [python] view plaincopy

    1. # Telnet {{{
    2. from telnetlib import Telnet
    3. class Telnet_login(TCP_Cache):
    4.   ””’Brute-force Telnet”’
    6.   usage_hints = (
    7.     “””%prog host=10.0.0.1 inputs=’FILE0\\nFILE1′ 0=logins.txt 1=passwords.txt persistent=0″””
    8.     “”” prompt_re=’Username:|Password:’ -x ignore:egrep=’Login incorrect.+Username:'”””,
    9.     )
    11.   available_options = (
    12.     (‘host’, ‘target host’),
    13.     (‘port’, ‘target port [23]’),
    14.     (‘inputs’, ‘list of values to input’),
    15.     (‘prompt_re’, ‘regular expression to match prompts [\w+]’),
    16.     (‘timeout’, ‘seconds to wait for a response and for prompt_re to match received data [20]’),
    17.     )
    18.   available_options += TCP_Cache.available_options
    20.   Response = Response_Base
    22.   def connect(self, host, port, timeout):
    23.     self.prompt_count = 0
    24.     fp = Telnet(host, int(port), int(timeout))
    26.     return TCP_Connection(fp)
    28.   def execute(self, host, port=’23’, inputs=None, prompt_re=’\w+:’, timeout=’20’, persistent=’1′):
    30.     fp, _ = self.bind(host, port, timeout=timeout)
    32.     trace = ”
    33.     timeout = int(timeout)
    35.     if self.prompt_count == 0:
    36.       _, _, raw = fp.expect([prompt_re], timeout=timeout)
    37.       logger.debug(‘raw banner: %s’ % repr(raw))
    38.       trace += raw
    39.       self.prompt_count += 1
    41.     if inputs is not None:
    42.       for val in inputs.split(r’\n’):
    43.         logger.debug(‘input: %s’ % val)
    44.         cmd = val + ‘\n’ #’\r\x00′
    45.         fp.write(cmd)
    46.         trace += cmd
    48.         _, _, raw = fp.expect([prompt_re], timeout=timeout)
    49.         logger.debug(‘raw %d: %s’ % (self.prompt_count, repr(raw)))
    50.         trace += raw
    51.         self.prompt_count += 1
    53.     if persistent == ‘0’:
    54.       self.reset()
    56.     mesg = repr(raw)[1:-1] # strip enclosing single quotes
    57.     return self.Response(0, mesg, trace)
    59. # }}}

    把核心部分抽出来，流程是这样的。

     

    创建一个连接到telnetlib.Telnet对象fp  –>> 等待出现匹配正则(\w+:)字符出现（如 login:,username等)

    –>> 发送用户名 –>>继续等待(\w+:)出现（如passwd:,Password:) –>> 发送密码  ->> 等待(\w+:)出现，输出返回字符串

     

    过程就是这么简单，其中expect函数接受二个参数，第一个是正则表达式的列表，可以是编译好的，也可以是字符串，第二个是超时时间。

    返回一个三项的tuple，第一个是匹配到的正则序号（从0开始），第二个是匹配match的对象，第三个是直到正则的返回数据(包括匹配内容)

    这说的有点抽象。

    请看下面：

    从上面我们可以很明显看出，匹配的正则是按顺序的，虽然返回数据中，‘bo’在’lo’之前，但由于在正则列表中‘lo’在前，所以数据一致读到’lo’。

    到这里为止，大家应该对Patator如何去爆telnet弱密码基本了解了。

    但如果我们想直接得出破解的用户名和密码，这该怎么办呢？

    有一种思路就是提供一个错误的用户名和密码，保存返回的内容，然后每次获取要测试的用户名和密码的回内容，通过比较两次的结果就可以结果了。但由于返回内容会千奇百怪，所以要做较多的特殊处理。

    如以下代码：

     

    [python] view plaincopy

    1. import telnetlib
    3. class telnet_check:
    4.     def __init__(self,host,port=23,timeout=10):
    5.         self.host=host
    6.         self.port=port
    7.         self.timeout=timeout
    8.         self.promote=’\w+:’
    9.         self.errmsg=”
    10.         self.geterrmsg()
    12.     def connect(self):
    13.         return telnetlib.Telnet(self.host,self.port,self.timeout)
    15.     def geterrmsg(self):
    16.         f=self.connect()
    17.         f.expect([self.promote],self.timeout)
    18.         f.write(‘nullnull\r’)
    19.         f.expect([self.promote],self.timeout)
    20.         f.write(‘nullnull\r’)
    21.         _,_,self.errmsg=f.expect([self.promote],self.timeout)
    22.         self.errmsg=self.errmsg.strip()
    25.     def check(self,User,Passwd):
    26.         t=self.connect()
    27.         t.expect([self.promote],self.timeout)
    28.         t.write(User+’\r’)
    29.         _,_,p=t.expect([self.promote],self.timeout)
    30.         if p.strip() == self.errmsg:
    31.             return False
    32.         t.write(Passwd+’\r’)
    33.         _,_,loginmsg=t.expect([self.promote],self.timeout)
    34.         loginmsg=loginmsg.strip()
    35.         if self.errmsg != ” and self.errmsg != loginmsg:
    36.             return True
    37.         else:
    38.             return False
    41. if __name__==’__main__’:
    42.     tn=telnet_check(‘127.0.0.1’)
    43.     print tn.check(‘yihaibo’,’1′)
    44.     print tn.check(‘root’,’root’)
    45.     print tn.check(‘admin’,’admin’)

    运行结果如下：

     

    我们发现这的确是一种可行的办法。这也给hydra误报带来了解决办法。

    由于每次都创建telnetlib.Telnet对象比较浪费资源，patator使用了缓存来解决这个问题，但这里我一直有一个疑问，为啥Telnet对象可以缓存，如果亲明白，教教我吧！

    Telnet_login的父类TCP_Cache简化代码如下：

     

    [python] view plaincopy

    1. class TCP_Cache:
    2.   def __init__(self):
    3.     self.cache = {} # {‘10.0.0.1:22’: (‘root’, conn1), ‘10.0.0.2:22’: (‘admin’, conn2),
    4.     self.curr = None
    6.   def __del__(self):
    7.     for _, (_, c) in self.cache.items():
    8.       c.close()
    9.     self.cache.clear()
    11.   def bind(self, host, port, *args, **kwargs):
    13.     hp = ‘%s:%s’ % (host, port)
    14.     key = ‘:’.join(args)
    16.     if hp in self.cache:
    17.       k, c = self.cache[hp]
    19.       if key == k:
    20.         self.curr = hp, k, c
    21.         return c.fp, c.banner
    23.       else:
    24.         c.close()
    25.         del self.cache[hp]
    27.     self.curr = None
    29.     conn = self.connect(host, port, *args, **kwargs)
    31.     self.cache[hp] = (key, conn)
    32.     self.curr = hp, key, conn
    34.     return conn.fp, conn.banner

    我们可以看到，当开始新建一Telnet_login对象时，将把host:port信息加入cache,以后每次都会现在cache中寻找，如果有就直接返回连接对象(使用先前fp,fp.expect返回信息怎么还可用？？？)。

     

     

    Patator基于模块化的设计，啥模块化的设计？因为支持多种协议，而各个协议之间都是独立的。举个简单的例子，你想测试telnet弱密码，使用的是 telnetlib库，属于标准库，所以你完全可以扫telnet弱密码，即使你没有安装pycurl(扫http弱密码使用的库，是curl库的 python封装)。哇塞，挺强大啊，那这又是怎么实现的呢？

    不看不知道，一看吓一跳，相当的简单。

     

    [python] view plaincopy

    1. warnings = []
    3. try:
    4.   import pycurl
    5. except ImportError:
    6.   warnings.append(‘pycurl’)
    8. dependencies = {
    9.   ‘paramiko’: [(‘ssh_login’,), ‘http://www.lag.net/paramiko/’, ‘1.7.7.1’],
    10.   ‘pycurl’: [(‘http_fuzz’,), ‘http://pycurl.sourceforge.net/’, ‘7.19.0’],
    11.   ‘openldap’: [(‘ldap_login’,), ‘http://www.openldap.org/’, ‘2.4.24’],
    12.   ‘impacket’: [(‘smb_login’,’smb_lookupsid’,’mssql_login’), ‘http://oss.coresecurity.com/projects/impacket.html’, ‘svn#765’],
    13.   ‘cx_Oracle’: [(‘oracle_login’,), ‘http://cx-oracle.sourceforge.net/’, ‘5.1.1’],
    14.   ‘mysql-python’: [(‘mysql_login’,), ‘http://sourceforge.net/projects/mysql-python/’, ‘1.2.3’],
    15.   ‘psycopg’: [(‘pgsql_login’,), ‘http://initd.org/psycopg/’, ‘2.4.5’],
    16.   ‘pycrypto’: [(‘vnc_login’,), ‘http://www.dlitz.net/software/pycrypto/’, ‘2.3’],
    17.   ‘dnspython’: [(‘dns_reverse’, ‘dns_forward’), ‘http://www.dnspython.org/’, ‘1.10.0’],
    18.   ‘IPy’: [(‘dns_reverse’, ‘dns_forward’), ‘https://github.com/haypo/python-ipy’, ‘0.75’],
    19.   ‘pysnmp’: [(‘snmp_login’,), ‘http://pysnmp.sf.net/’, ‘4.2.1’],
    20.   ‘unzip’: [(‘unzip_pass’,), ‘http://www.info-zip.org/’, ‘6.0’],
    21.   ‘java’: [(‘keystore_pass’,), ‘http://www.oracle.com/technetwork/java/javase/’, ‘6’],
    22.   ‘python’: [(‘ftp_login’,), ‘http://www.python.org/’, ‘2.7’],
    23.  }
    25.  for w in set(warnings):
    26.     mods, url, ver = dependencies[w]
    27.     if name in mods:
    28.       print(‘ERROR: %s %s (%s) is required to run %s.’ % (w, ver, url, name))
    29.       abort = True

    上面这是我简化后的代码，从中可以看出，有一个全局变量列表warning，每次导入需要的库时，如果导入失败，则将库名加入warning,当我们通过 命令行传递使用哪个模块时，如我们使用pycurl，这时我们发现在warnings中含有“pycurl”,所以就提示我们需要安装库，而且很智能的将 库的地址也给我们了。

     

    由于是弱密码扫描，字典肯定不小，那么为了追求速度，肯定要使用线程，patator默认使用10个线程去跑，这部分代码主要在控制部分中(class Controller)，代码还是有点小复杂的。

     

    [python] view plaincopy

    1. gqueues = [Queue(maxsize=10000) for _ in range(self.num_threads)]
    3.   # consumers
    4.   for num in range(self.num_threads):
    5.     pqueue = Queue(maxsize=1000)
    6.     t = Thread(target=self.consume, args=(gqueues[num], pqueue))
    7.     t.daemon = True
    8.     t.start()
    9.     self.thread_report.append(pqueue)
    10.     self.thread_progress.append(Progress())
    12.   # producer
    13.   t = Thread(target=self.produce, args=(gqueues,))
    14.   t.daemon = True
    15.   t.start()

     

    正如你所看到的，启用了两个最经典的线程，一个produce,一个consume，两者通信使用的是Queue。self.num_threads是可配的，通过命名行中指定 -t，否则将是默认的10个线程。

    到这里就要和大家说再见了，Patator源码还是值得一读的，剩下的就交给你们自己行动了。

    转载请注明：jinglingshu的博客 » 暴力破解测试工具–Patator 源码分析

    与本文相关的文章

    发表我的评论
    取消评论

    表情

    Hi，您需要填写昵称和邮箱！

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址