2899 lines
75 KiB
Python
2899 lines
75 KiB
Python
#!/usr/bin/python
|
||
# -*- coding: iso-8859-1 -*-
|
||
# -*- coding: utf-8 -*-
|
||
########################################################################################################
|
||
#
|
||
# crackhash.py - v0.01
|
||
#
|
||
# 国外在线破解hash的小脚本。
|
||
#
|
||
#####################################################################################################
|
||
try:
|
||
import sys
|
||
import hashlib
|
||
import urllib2
|
||
import getopt
|
||
from os import path
|
||
from urllib import urlencode
|
||
from re import search, findall
|
||
from random import seed, randint
|
||
from base64 import decodestring, encodestring
|
||
from cookielib import LWPCookieJar
|
||
except:
|
||
print """
|
||
运行出错:
|
||
|
||
以下的python 库尚未安装：
|
||
|
||
该应用程序需要的库：sys, hashlib, urllib, urllib2, os, re, random, getopt, base64 and cookielib.
|
||
|
||
请检查这些依赖库是否安装在您的操作系统上
|
||
|
||
提示：安装这些库的格式为：
|
||
|
||
apt-get install 库名字
|
||
|
||
例如: apt-get install httplib2
|
||
|
||
或者使用以下方式：
|
||
|
||
easy_install httplib2
|
||
|
||
"""
|
||
sys.exit(1)
|
||
|
||
try:
|
||
from httplib2 import Http
|
||
except:
|
||
print """
|
||
运行出错:
|
||
|
||
Python 依赖库： httplib2 尚未被安装在您的系统中.
|
||
|
||
请在使用该程序之前安装该依赖库。
|
||
|
||
"""
|
||
sys.exit(1)
|
||
|
||
try:
|
||
from libxml2 import parseDoc
|
||
except:
|
||
print """
|
||
|
||
运行出错:
|
||
|
||
Python 依赖库： libxml2 尚未被安装在您的系统中.
|
||
|
||
如果缺失该依赖库，部分插件将无法正常工作。
|
||
|
||
请在使用该程序之前安装该依赖库。
|
||
|
||
"""
|
||
|
||
########################################################################################################
|
||
### 定义常量
|
||
########################################################################################################
|
||
|
||
MD4 = "md4"
|
||
MD5 = "md5"
|
||
SHA1 = "sha1"
|
||
SHA224 = "sha224"
|
||
SHA256 = "sha256"
|
||
SHA384 = "sha384"
|
||
SHA512 = "sha512"
|
||
RIPEMD = "rmd160"
|
||
LM = "lm"
|
||
NTLM = "ntlm"
|
||
MYSQL = "mysql"
|
||
CISCO7 = "cisco7"
|
||
JUNIPER = "juniper"
|
||
GOST = "gost"
|
||
WHIRLPOOL = "whirlpool"
|
||
LDAP_MD5 = "ldap_md5"
|
||
LDAP_SHA1 = "ldap_sha1"
|
||
|
||
USER_AGENTS = [
|
||
"Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:2.0b8pre) Gecko/20101213 Firefox/4.0b8pre",
|
||
"Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; Trident/6.0)",
|
||
"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 7.1; Trident/5.0)",
|
||
"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0) chromeframe/10.0.648.205",
|
||
"Opera/9.80 (Windows NT 6.1; U; sv) Presto/2.7.62 Version/11.01",
|
||
"Opera/9.80 (Windows NT 6.1; U; pl) Presto/2.7.62 Version/11.00",
|
||
"Opera/9.80 (X11; Linux i686; U; pl) Presto/2.6.30 Version/10.61",
|
||
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_0) AppleWebKit/535.2 (KHTML, like Gecko) Chrome/15.0.861.0 Safari/535.2",
|
||
"Mozilla/5.0 (Windows NT 5.1) AppleWebKit/535.2 (KHTML, like Gecko) Chrome/15.0.872.0 Safari/535.2",
|
||
"Mozilla/5.0 (Windows NT 6.1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.812.0 Safari/535.1",
|
||
]
|
||
|
||
|
||
########################################################################################################
|
||
### 定义破解网站
|
||
########################################################################################################
|
||
|
||
|
||
class NETMD5CRACK:
|
||
name = "netmd5crack"
|
||
url = "http://www.netmd5crack.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
# 如果成功破解，返回true，如果不能被破解，则返回false
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://www.netmd5crack.com/cgi-bin/Crack.py?InputHash=%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
regexp = r'<tr><td class="border">%s</td><td class="border">[^<]*</td></tr></table>' % (hashvalue)
|
||
match = search(regexp, html)
|
||
|
||
if match:
|
||
match2 = search("Sorry, we don't have that hash in our database", match.group())
|
||
if match2:
|
||
return None
|
||
else:
|
||
return match.group().split('border')[2].split('<')[0][2:]
|
||
|
||
|
||
class BENRAMSEY:
|
||
name = "benramsey"
|
||
url = "http://tools.benramsey.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://tools.benramsey.com/md5/md5.php?hash=%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<string><!\[CDATA\[[^\]]*\]\]></string>', html)
|
||
|
||
if match:
|
||
return match.group().split(']')[0][17:]
|
||
else:
|
||
return None
|
||
|
||
|
||
class GROMWEB:
|
||
name = "gromweb"
|
||
url = "http://md5.gromweb.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5.gromweb.com/query/%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
if response:
|
||
return response.read()
|
||
|
||
return response
|
||
|
||
|
||
class HASHCRACKING:
|
||
name = "hashcracking"
|
||
url = "http://md5.hashcracking.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5.hashcracking.com/search.php?md5=%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'\sis.*', html)
|
||
|
||
if match:
|
||
return match.group()[4:]
|
||
|
||
return None
|
||
|
||
|
||
class VICTOROV:
|
||
name = "hashcracking"
|
||
url = "http://victorov.su"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://victorov.su/md5/?md5e=&md5d=%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r': <b>[^<]*</b><br><form action="">', html)
|
||
|
||
if match:
|
||
return match.group().split('b>')[1][:-2]
|
||
|
||
return None
|
||
|
||
|
||
class THEKAINE:
|
||
name = "thekaine"
|
||
url = "http://md5.thekaine.de"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5.thekaine.de/?hash=%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<td colspan="2"><br><br><b>[^<]*</b></td><td></td>', html)
|
||
|
||
if match:
|
||
|
||
match2 = search(r'not found', match.group())
|
||
|
||
if match2:
|
||
return None
|
||
else:
|
||
return match.group().split('b>')[1][:-2]
|
||
|
||
|
||
class TMTO:
|
||
name = "tmto"
|
||
url = "http://www.tmto.org"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://www.tmto.org/api/latest/?hash=%s&auth=true" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'text="[^"]+"', html)
|
||
|
||
if match:
|
||
return decodestring(match.group().split('"')[1])
|
||
else:
|
||
return None
|
||
|
||
|
||
class MD5_DB:
|
||
name = "md5-db"
|
||
url = "http://md5-db.de"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5-db.de/%s.html" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
if not response:
|
||
return None
|
||
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(
|
||
r'<strong>Es wurden 1 m.gliche Begriffe gefunden, die den Hash \w* verwenden:</strong><ul><li>[^<]*</li>',
|
||
html)
|
||
|
||
if match:
|
||
return match.group().split('li>')[1][:-2]
|
||
else:
|
||
return None
|
||
|
||
|
||
class MY_ADDR:
|
||
name = "my-addr"
|
||
url = "http://md5.my-addr.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5.my-addr.com/md5_decrypt-md5_cracker_online/md5_decoder_tool.php"
|
||
|
||
# Build the parameters
|
||
params = {"md5": hashvalue,
|
||
"x": 21,
|
||
"y": 8}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r"<span class='middle_title'>Hashed string</span>: [^<]*</div>", html)
|
||
|
||
if match:
|
||
return match.group().split('span')[2][3:-6]
|
||
else:
|
||
return None
|
||
|
||
|
||
class MD5PASS:
|
||
name = "md5pass"
|
||
url = "http://md5pass.info"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = self.url
|
||
|
||
# Build the parameters
|
||
params = {"hash": hashvalue,
|
||
"get_pass": "Get Pass"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r"Password - <b>[^<]*</b>", html)
|
||
|
||
if match:
|
||
return match.group().split('b>')[1][:-2]
|
||
else:
|
||
return None
|
||
|
||
|
||
class MD5DECRYPTION:
|
||
name = "md5decryption"
|
||
url = "http://md5decryption.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = self.url
|
||
|
||
# Build the parameters
|
||
params = {"hash": hashvalue,
|
||
"submit": "Decrypt It!"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r"Decrypted Text: </b>[^<]*</font>", html)
|
||
|
||
if match:
|
||
return match.group().split('b>')[1][:-7]
|
||
else:
|
||
return None
|
||
|
||
|
||
class MD5CRACK:
|
||
name = "md5crack"
|
||
url = "http://md5crack.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5crack.com/crackmd5.php"
|
||
|
||
# Build the parameters
|
||
params = {"term": hashvalue,
|
||
"crackbtn": "Crack that hash baby!"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'Found: md5\("[^"]+"\)', html)
|
||
|
||
if match:
|
||
return match.group().split('"')[1]
|
||
else:
|
||
return None
|
||
|
||
|
||
class MD5_DECRYPTER:
|
||
name = "md5-decrypter"
|
||
url = "http://md5-decrypter.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = self.url
|
||
|
||
# Build the parameters
|
||
params = {"data[Row][cripted]": hashvalue}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = findall(r'<b class="res">[^<]*</b>', html)
|
||
|
||
if match:
|
||
return match[1].split('>')[1][:-3]
|
||
else:
|
||
return None
|
||
|
||
|
||
class AUTHSECUMD5:
|
||
name = "authsecu"
|
||
url = "http://www.authsecu.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://www.authsecu.com/decrypter-dechiffrer-cracker-hash-md5/script-hash-md5.php"
|
||
|
||
# Build the parameters
|
||
params = {"valeur_bouton": "dechiffrage",
|
||
"champ1": "",
|
||
"champ2": hashvalue,
|
||
"dechiffrer.x": "78",
|
||
"dechiffrer.y": "7"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = findall(r'<td><p class="chapitre---texte-du-tableau-de-niveau-1">[^<]*</p></td>', html)
|
||
|
||
if len(match) > 2:
|
||
return match[1].split('>')[2][:-3]
|
||
else:
|
||
return None
|
||
|
||
|
||
class HASHCRACK:
|
||
name = "hashcrack"
|
||
url = "http://hashcrack.com"
|
||
supported_algorithm = [MD5, SHA1, MYSQL, LM, NTLM]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://hashcrack.com/indx.php"
|
||
|
||
hash2 = None
|
||
if alg in [LM, NTLM] and ':' in hashvalue:
|
||
if alg == LM:
|
||
hash2 = hashvalue.split(':')[0]
|
||
else:
|
||
hash2 = hashvalue.split(':')[1]
|
||
else:
|
||
hash2 = hashvalue
|
||
|
||
# Delete the possible starting '*'
|
||
if alg == MYSQL and hash2[0] == '*':
|
||
hash2 = hash2[1:]
|
||
|
||
# Build the parameters
|
||
params = {"auth": "8272hgt",
|
||
"hash": hash2,
|
||
"string": "",
|
||
"Submit": "Submit"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(
|
||
r'<div align=center>"[^"]*" resolves to</div><br><div align=center> <span class=hervorheb2>[^<]*</span></div></TD>',
|
||
html)
|
||
|
||
if match:
|
||
return match.group().split('hervorheb2>')[1][:-18]
|
||
else:
|
||
return None
|
||
|
||
|
||
class OPHCRACK:
|
||
name = "ophcrack"
|
||
url = "http://www.objectif-securite.ch"
|
||
supported_algorithm = [LM, NTLM]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# Check if hashvalue has the character ':'
|
||
if ':' not in hashvalue:
|
||
return None
|
||
|
||
# Ophcrack doesn't crack NTLM hashes. It needs a valid LM hash and this one is an empty hash.
|
||
if hashvalue.split(':')[0] == "aad3b435b51404eeaad3b435b51404ee":
|
||
return None
|
||
|
||
# 创建查询URL and the headers
|
||
url = "http://www.objectif-securite.ch/en/products.php?hash=%s" % (hashvalue.replace(':', '%3A'))
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(
|
||
r'<table><tr><td>Hash:</td><td>[^<]*</td></tr><tr><td><b>Password:</b></td><td><b>[^<]*</b></td>', html)
|
||
|
||
if match:
|
||
return match.group().split('b>')[3][:-2]
|
||
else:
|
||
return None
|
||
|
||
|
||
class C0LLISION:
|
||
name = "c0llision"
|
||
url = "http://www.c0llision.net"
|
||
supported_algorithm = [MD5, LM, NTLM]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# Check if hashvalue has the character ':'
|
||
if alg in [LM, NTLM] and ':' not in hashvalue:
|
||
return None
|
||
|
||
# Look for "hash[_csrf_token]" parameter
|
||
response = do_HTTP_request("http://www.c0llision.net/webcrack.php")
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
match = search(r'<input type="hidden" name="hash._csrf_token." value="[^"]*" id="hash__csrf_token" />', html)
|
||
token = None
|
||
if match:
|
||
token = match.group().split('"')[5]
|
||
|
||
# 创建查询URL
|
||
url = "http://www.c0llision.net/webcrack/request"
|
||
|
||
# Build the parameters
|
||
params = {"hash[_input_]": hashvalue,
|
||
"hash[_csrf_token]": token}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = None
|
||
if alg in [LM, NTLM]:
|
||
html = html.replace('\n', '')
|
||
result = ""
|
||
|
||
match = search(r'<table class="pre">.*?</table>', html)
|
||
if match:
|
||
try:
|
||
doc = parseDoc(match.group())
|
||
except:
|
||
print "INFO: You need libxml2 to use this plugin."
|
||
return None
|
||
lines = doc.xpathEval("//tr")
|
||
for l in lines:
|
||
doc = parseDoc(str(l))
|
||
cols = doc.xpathEval("//td")
|
||
|
||
if len(cols) < 4:
|
||
return None
|
||
|
||
if cols[2].content:
|
||
result = " > %s (%s) = %s\n" % (cols[1].content, cols[2].content, cols[3].content)
|
||
|
||
# return ( result and "\n" + result or None )
|
||
return (result and result.split()[-1] or None)
|
||
|
||
else:
|
||
match = search(r'<td class="plaintext">[^<]*</td>', html)
|
||
|
||
if match:
|
||
return match.group().split('>')[1][:-4]
|
||
|
||
return None
|
||
|
||
|
||
class REDNOIZE:
|
||
name = "rednoize"
|
||
url = "http://md5.rednoize.com"
|
||
supported_algorithm = [MD5, SHA1]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = ""
|
||
if alg == MD5:
|
||
url = "http://md5.rednoize.com/?p&s=md5&q=%s&_=" % (hashvalue)
|
||
else:
|
||
url = "http://md5.rednoize.com/?p&s=sha1&q=%s&_=" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
return html
|
||
|
||
|
||
class CMD5:
|
||
name = "cmd5"
|
||
url = "http://www.cmd5.org"
|
||
supported_algorithm = [MD5, NTLM]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# Look for hidden parameters
|
||
response = do_HTTP_request("http://www.cmd5.org/")
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="[^"]*" />', html)
|
||
viewstate = None
|
||
if match:
|
||
viewstate = match.group().split('"')[7]
|
||
|
||
match = search(
|
||
r'<input type="hidden" name="ctl00.ContentPlaceHolder1.HiddenField1" id="ctl00_ContentPlaceHolder1_HiddenField1" value="[^"]*" />',
|
||
html)
|
||
ContentPlaceHolder1 = ""
|
||
if match:
|
||
ContentPlaceHolder1 = match.group().split('"')[7]
|
||
|
||
match = search(
|
||
r'<input type="hidden" name="ctl00.ContentPlaceHolder1.HiddenField2" id="ctl00_ContentPlaceHolder1_HiddenField2" value="[^"]*" />',
|
||
html)
|
||
ContentPlaceHolder2 = ""
|
||
if match:
|
||
ContentPlaceHolder2 = match.group().split('"')[7]
|
||
|
||
# 创建查询URL
|
||
url = "http://www.cmd5.org/"
|
||
|
||
hash2 = ""
|
||
if alg == MD5:
|
||
hash2 = hashvalue
|
||
else:
|
||
if ':' in hashvalue:
|
||
hash2 = hashvalue.split(':')[1]
|
||
|
||
# Build the parameters
|
||
params = {"__EVENTTARGET": "",
|
||
"__EVENTARGUMENT": "",
|
||
"__VIEWSTATE": viewstate,
|
||
"ctl00$ContentPlaceHolder1$TextBoxq": hash2,
|
||
"ctl00$ContentPlaceHolder1$InputHashType": alg,
|
||
"ctl00$ContentPlaceHolder1$Button1": "decrypt",
|
||
"ctl00$ContentPlaceHolder1$HiddenField1": ContentPlaceHolder1,
|
||
"ctl00$ContentPlaceHolder1$HiddenField2": ContentPlaceHolder2}
|
||
|
||
header = {"Referer": "http://www.cmd5.org/"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params, header)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<span id="ctl00_ContentPlaceHolder1_LabelResult">[^<]*</span>', html)
|
||
|
||
if match:
|
||
return match.group().split('>')[1][:-6]
|
||
else:
|
||
return None
|
||
|
||
|
||
class AUTHSECUCISCO7:
|
||
name = "authsecu"
|
||
url = "http://www.authsecu.com"
|
||
supported_algorithm = [CISCO7]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL and the headers
|
||
url = "http://www.authsecu.com/decrypter-dechiffrer-cracker-password-cisco-7/script-password-cisco-7-launcher.php"
|
||
|
||
# Build the parameters
|
||
params = {"valeur_bouton": "dechiffrage",
|
||
"champ1": hashvalue,
|
||
"dechiffrer.x": 43,
|
||
"dechiffrer.y": 16}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = findall(r'<td><p class="chapitre---texte-du-tableau-de-niveau-1">[^<]*</p></td>', html)
|
||
|
||
if match:
|
||
return match[1].split('>')[2][:-3]
|
||
else:
|
||
return None
|
||
|
||
|
||
class CACIN:
|
||
name = "cacin"
|
||
url = "http://cacin.net"
|
||
supported_algorithm = [CISCO7]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL and the headers
|
||
url = "http://cacin.net/cgi-bin/decrypt-cisco.pl?cisco_hash=%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<tr>Cisco password 7: [^<]*</tr><br><tr><th><br>Decrypted password: .*', html)
|
||
|
||
if match:
|
||
return match.group().split(':')[2][1:]
|
||
else:
|
||
return None
|
||
|
||
|
||
class IBEAST:
|
||
name = "ibeast"
|
||
url = "http://www.ibeast.com"
|
||
supported_algorithm = [CISCO7]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL and the headers
|
||
url = "http://www.ibeast.com/content/tools/CiscoPassword/decrypt.php?txtPassword=%s&submit1=Enviar+consulta" % (
|
||
hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<font size="\+2">Your Password is [^<]*<br>', html)
|
||
|
||
if match:
|
||
return match.group().split('is ')[1][:-4]
|
||
else:
|
||
return None
|
||
|
||
|
||
class PASSWORD_DECRYPT:
|
||
name = "password-decrypt"
|
||
url = "http://password-decrypt.com"
|
||
supported_algorithm = [CISCO7, JUNIPER]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL and the parameters
|
||
url = ""
|
||
params = None
|
||
if alg == CISCO7:
|
||
url = "http://password-decrypt.com/cisco.cgi"
|
||
params = {"submit": "Submit",
|
||
"cisco_password": hashvalue,
|
||
"submit": "Submit"}
|
||
else:
|
||
url = "http://password-decrypt.com/juniper.cgi"
|
||
params = {"submit": "Submit",
|
||
"juniper_password": hashvalue,
|
||
"submit": "Submit"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'Decrypted Password: <B>[^<]*</B> </p>', html)
|
||
|
||
if match:
|
||
return match.group().split('B>')[1][:-2]
|
||
else:
|
||
return None
|
||
|
||
|
||
class HASHCHECKER:
|
||
name = "hashchecker"
|
||
url = "http://www.hashchecker.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL and the headers
|
||
url = "http://www.hashchecker.com/index.php"
|
||
|
||
# Build the parameters
|
||
params = {"search_field": hashvalue,
|
||
"Submit": "search"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<td><li>Your md5 hash is :<br><li>[^\s]* is <b>[^<]*</b> used charlist :2</td>', html)
|
||
|
||
if match:
|
||
return match.group().split('b>')[1][:-2]
|
||
else:
|
||
return None
|
||
|
||
|
||
class MD5HASHCRACKER:
|
||
name = "md5hashcracker"
|
||
url = "http://md5hashcracker.appspot.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5hashcracker.appspot.com/crack"
|
||
|
||
# Build the parameters
|
||
params = {"query": hashvalue,
|
||
"submit": "Crack"}
|
||
|
||
# Make the firt request
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# Build the second URL
|
||
url = "http://md5hashcracker.appspot.com/status"
|
||
|
||
# Make the second request
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
match = search(r'<td id="cra[^"]*">not cracked</td>', html)
|
||
|
||
if not match:
|
||
match = search(r'<td id="cra[^"]*">cracked</td>', html)
|
||
regexp = r'<td id="pla_' + match.group().split('"')[1][4:] + '">[^<]*</td>'
|
||
match2 = search(regexp, html)
|
||
if match2:
|
||
return match2.group().split('>')[1][:-4]
|
||
|
||
else:
|
||
return None
|
||
|
||
|
||
class PASSCRACKING:
|
||
name = "passcracking"
|
||
url = "http://passcracking.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://passcracking.com/index.php"
|
||
|
||
# Build the parameters
|
||
boundary = "-----------------------------" + str(
|
||
randint(1000000000000000000000000000, 9999999999999999999999999999))
|
||
params = ['--' + boundary,
|
||
'Content-Disposition: form-data; name="admin"',
|
||
'',
|
||
'false',
|
||
|
||
'--' + boundary,
|
||
'Content-Disposition: form-data; name="admin2"',
|
||
'',
|
||
'77.php',
|
||
|
||
'--' + boundary,
|
||
'Content-Disposition: form-data; name="datafromuser"',
|
||
'',
|
||
'%s' % (hashvalue),
|
||
|
||
'--' + boundary + '--', '']
|
||
body = '\r\n'.join(params)
|
||
|
||
# Build the headers
|
||
headers = {"Content-Type": "multipart/form-data; boundary=%s" % (boundary),
|
||
"Content-length": len(body)}
|
||
|
||
# 进行http 网络查询
|
||
request = urllib2.Request(url)
|
||
request.add_header("Content-Type", "multipart/form-data; boundary=%s" % (boundary))
|
||
request.add_header("Content-length", len(body))
|
||
request.add_data(body)
|
||
try:
|
||
response = urllib2.urlopen(request)
|
||
except:
|
||
return None
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<td>md5 Database</td><td>[^<]*</td><td bgcolor=.FF0000>[^<]*</td>', html)
|
||
|
||
if match:
|
||
return match.group().split('>')[5][:-4]
|
||
else:
|
||
return None
|
||
|
||
|
||
class ASKCHECK:
|
||
name = "askcheck"
|
||
url = "http://askcheck.com"
|
||
supported_algorithm = [MD4, MD5, SHA1, SHA256]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://askcheck.com/reverse?reverse=%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'Reverse value of [^\s]* hash <a[^<]*</a> is <a[^>]*>[^<]*</a>', html)
|
||
|
||
if match:
|
||
return match.group().split('>')[3][:-3]
|
||
else:
|
||
return None
|
||
|
||
|
||
class FOX21:
|
||
name = "fox21"
|
||
url = "http://cracker.fox21.at"
|
||
supported_algorithm = [MD5, LM, NTLM]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
hash2 = None
|
||
if alg in [LM, NTLM] and ':' in hashvalue:
|
||
if alg == LM:
|
||
hash2 = hashvalue.split(':')[0]
|
||
else:
|
||
hash2 = hashvalue.split(':')[1]
|
||
else:
|
||
hash2 = hashvalue
|
||
|
||
# 创建查询URL
|
||
url = "http://cracker.fox21.at/api.php?a=check&h=%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
xml = None
|
||
if response:
|
||
try:
|
||
doc = parseDoc(response.read())
|
||
except:
|
||
print "INFO: You need libxml2 to use this plugin."
|
||
return None
|
||
else:
|
||
return None
|
||
|
||
result = doc.xpathEval("//hash/@plaintext")
|
||
|
||
if result:
|
||
return result[0].content
|
||
else:
|
||
return None
|
||
|
||
|
||
class NICENAMECREW:
|
||
name = "nicenamecrew"
|
||
url = "http://crackfoo.nicenamecrew.com"
|
||
supported_algorithm = [MD5, SHA1, LM]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
hash2 = None
|
||
if alg in [LM] and ':' in hashvalue:
|
||
hash2 = hashvalue.split(':')[0]
|
||
else:
|
||
hash2 = hashvalue
|
||
|
||
# 创建查询URL
|
||
url = "http://crackfoo.nicenamecrew.com/?t=%s" % (alg)
|
||
|
||
# Build the parameters
|
||
params = {"q": hash2,
|
||
"sa": "Crack"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'The decrypted version of [^\s]* is:<br><strong>[^<]*</strong>', html)
|
||
|
||
if match:
|
||
return match.group().split('strong>')[1][:-2].strip()
|
||
else:
|
||
return None
|
||
|
||
|
||
class JOOMLAAA:
|
||
name = "joomlaaa"
|
||
url = "http://joomlaaa.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://joomlaaa.com/component/option,com_md5/Itemid,31/"
|
||
|
||
# Build the parameters
|
||
params = {"md5": hashvalue,
|
||
"decode": "Submit"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r"<td class='title1'>not available</td>", html)
|
||
|
||
if not match:
|
||
match2 = findall(r"<td class='title1'>[^<]*</td>", html)
|
||
return match2[1].split('>')[1][:-4]
|
||
else:
|
||
return None
|
||
|
||
|
||
class MD5_LOOKUP:
|
||
name = "md5-lookup"
|
||
url = "http://md5-lookup.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5-lookup.com/livesearch.php?q=%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<td width="250">[^<]*</td>', html)
|
||
|
||
if match:
|
||
return match.group().split('>')[1][:-4]
|
||
else:
|
||
return None
|
||
|
||
|
||
class SHA1_LOOKUP:
|
||
name = "sha1-lookup"
|
||
url = "http://sha1-lookup.com"
|
||
supported_algorithm = [SHA1]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://sha1-lookup.com/livesearch.php?q=%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<td width="250">[^<]*</td>', html)
|
||
|
||
if match:
|
||
return match.group().split('>')[1][:-4]
|
||
else:
|
||
return None
|
||
|
||
|
||
class SHA256_LOOKUP:
|
||
name = "sha256-lookup"
|
||
url = "http://sha-256.sha1-lookup.com"
|
||
supported_algorithm = [SHA256]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://sha-256.sha1-lookup.com/livesearch.php?q=%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<td width="250">[^<]*</td>', html)
|
||
|
||
if match:
|
||
return match.group().split('>')[1][:-4]
|
||
else:
|
||
return None
|
||
|
||
|
||
class RIPEMD160_LOOKUP:
|
||
name = "ripemd-lookup"
|
||
url = "http://www.ripemd-lookup.com"
|
||
supported_algorithm = [RIPEMD]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://www.ripemd-lookup.com/livesearch.php?q=%s" % (hashvalue)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<td width="250">[^<]*</td>', html)
|
||
|
||
if match:
|
||
return match.group().split('>')[1][:-4]
|
||
else:
|
||
return None
|
||
|
||
|
||
class MD5_COM_CN:
|
||
name = "md5.com.cn"
|
||
url = "http://md5.com.cn"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5.com.cn/md5reverse"
|
||
|
||
# Build the parameters
|
||
params = {"md": hashvalue,
|
||
"submit": "MD5 Crack"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<b style="color:red;">[^<]*</b><br/><span', html)
|
||
|
||
if match:
|
||
return match.group().split('>')[1][:-3]
|
||
else:
|
||
return None
|
||
|
||
|
||
class DIGITALSUN:
|
||
name = "digitalsun.pl"
|
||
url = "http://md5.digitalsun.pl"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5.digitalsun.pl/"
|
||
|
||
# Build the parameters
|
||
params = {"hash": hashvalue}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<b>[^<]*</b> == [^<]*<br>\s*<br>', html)
|
||
|
||
if match:
|
||
return match.group().split('b>')[1][:-2]
|
||
else:
|
||
return None
|
||
|
||
|
||
class MYINFOSEC:
|
||
name = "myinfosec"
|
||
url = "http://md5.myinfosec.net"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5.myinfosec.net/md5.php"
|
||
|
||
# Build the parameters
|
||
params = {"md5hash": hashvalue}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<center></center>[^<]*<font color=green>[^<]*</font><br></center>', html)
|
||
|
||
if match:
|
||
return match.group().split('>')[3][:-6]
|
||
else:
|
||
return None
|
||
|
||
|
||
class MD5_NET:
|
||
name = "md5.net"
|
||
url = "http://md5.net"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://www.md5.net/cracker.php"
|
||
|
||
# Build the parameters
|
||
params = {"hash": hashvalue}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<input type="text" id="hash" size="32" value="[^"]*"/>', html)
|
||
|
||
if match:
|
||
return match.group().split('"')[7]
|
||
else:
|
||
return None
|
||
|
||
|
||
class NOISETTE:
|
||
name = "noisette.ch"
|
||
url = "http://md5.noisette.ch"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5.noisette.ch/index.php"
|
||
|
||
# Build the parameters
|
||
params = {"hash": hashvalue}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<p>String to hash : <input name="text" value="[^"]+"/>', html)
|
||
|
||
if match:
|
||
return match.group().split('"')[3]
|
||
else:
|
||
return None
|
||
|
||
|
||
class MD5HOOD:
|
||
name = "md5hood"
|
||
url = "http://md5hood.com"
|
||
supported_algorithm = [MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://md5hood.com/index.php/cracker/crack"
|
||
|
||
# Build the parameters
|
||
params = {"md5": hashvalue,
|
||
"submit": "Go"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<div class="result_true">[^<]*</div>', html)
|
||
|
||
if match:
|
||
return match.group().split('>')[1][:-5]
|
||
else:
|
||
return None
|
||
|
||
|
||
class XANADREL:
|
||
name = "99k.org"
|
||
url = "http://xanadrel.99k.org"
|
||
supported_algorithm = [MD4, MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://xanadrel.99k.org/hashes/index.php?k=search"
|
||
|
||
# Build the parameters
|
||
params = {"hash": hashvalue,
|
||
"search": "ok"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<p>Hash : [^<]*<br />Type : [^<]*<br />Plain : "[^"]*"<br />', html)
|
||
|
||
if match:
|
||
return match.group().split('"')[1]
|
||
else:
|
||
return None
|
||
|
||
|
||
class SANS:
|
||
name = "sans"
|
||
url = "http://isc.sans.edu"
|
||
supported_algorithm = [MD5, SHA1]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://isc.sans.edu/tools/reversehash.html"
|
||
|
||
# Build the Headers with a random User-Agent
|
||
headers = {"User-Agent": USER_AGENTS[randint(0, len(USER_AGENTS)) - 1]}
|
||
|
||
# Build the parameters
|
||
response = do_HTTP_request(url, httpheaders=headers)
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
match = search(r'<input type="hidden" name="token" value="[^"]*" />', html)
|
||
token = ""
|
||
if match:
|
||
token = match.group().split('"')[5]
|
||
else:
|
||
return None
|
||
|
||
params = {"token": token,
|
||
"text": hashvalue,
|
||
"word": "",
|
||
"submit": "Submit"}
|
||
|
||
# Build the Headers with the Referer header
|
||
headers["Referer"] = "http://isc.sans.edu/tools/reversehash.html"
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params, headers)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'... hash [^\s]* = [^\s]*\s*</p><br />', html)
|
||
|
||
if match:
|
||
print "hola mundo"
|
||
return match.group().split('=')[1][:-10].strip()
|
||
else:
|
||
return None
|
||
|
||
|
||
class BOKEHMAN:
|
||
name = "bokehman"
|
||
url = "http://bokehman.com"
|
||
supported_algorithm = [MD4, MD5]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
# 创建查询URL
|
||
url = "http://bokehman.com/cracker/"
|
||
|
||
# Build the parameters from the main page
|
||
response = do_HTTP_request(url)
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
match = search(r'<input type="hidden" name="PHPSESSID" id="PHPSESSID" value="[^"]*" />', html)
|
||
phpsessnid = ""
|
||
if match:
|
||
phpsessnid = match.group().split('"')[7]
|
||
else:
|
||
return None
|
||
match = search(r'<input type="hidden" name="key" id="key" value="[^"]*" />', html)
|
||
key = ""
|
||
if match:
|
||
key = match.group().split('"')[7]
|
||
else:
|
||
return None
|
||
|
||
params = {"md5": hashvalue,
|
||
"PHPSESSID": phpsessnid,
|
||
"key": key,
|
||
"crack": "Try to crack it"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<tr><td>[^<]*</td><td>[^<]*</td><td>[^s]*seconds</td></tr>', html)
|
||
|
||
if match:
|
||
return match.group().split('td>')[1][:-2]
|
||
else:
|
||
return None
|
||
|
||
|
||
class GOOG_LI:
|
||
name = "goog.li"
|
||
url = "http://goog.li"
|
||
supported_algorithm = [MD5, MYSQL, SHA1, SHA224, SHA384, SHA256, SHA512, RIPEMD, NTLM, GOST, WHIRLPOOL, LDAP_MD5,
|
||
LDAP_SHA1]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
hash2 = None
|
||
if alg in [NTLM] and ':' in hashvalue:
|
||
hash2 = hashvalue.split(':')[1]
|
||
else:
|
||
hash2 = hashvalue
|
||
|
||
# Confirm the initial '*' character
|
||
if alg == MYSQL and hash2[0] != '*':
|
||
hash2 = '*' + hash2
|
||
|
||
# 创建查询URL
|
||
url = "http://goog.li/?q=%s" % (hash2)
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<br />cleartext[^:]*: [^<]*<br />', html)
|
||
|
||
if match:
|
||
return match.group().split(':')[1].strip()[:-6]
|
||
else:
|
||
return None
|
||
|
||
|
||
class WHREPORITORY:
|
||
name = "Windows Hashes Repository"
|
||
url = "http://nediam.com.mx"
|
||
supported_algorithm = [LM, NTLM]
|
||
|
||
def isSupported(self, alg):
|
||
"""Return True if HASHCRACK can crack this type of algorithm and
|
||
False if it cannot."""
|
||
|
||
if alg in self.supported_algorithm:
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def crack(self, hashvalue, alg):
|
||
"""Try to crack the hash.
|
||
@param hashvalue Hash to crack.
|
||
@param alg Algorithm to crack."""
|
||
|
||
# 检查是否支持该种算法
|
||
if not self.isSupported(alg):
|
||
return None
|
||
|
||
hash2 = None
|
||
if ':' in hashvalue:
|
||
if alg == LM:
|
||
hash2 = hashvalue.split(':')[0]
|
||
else:
|
||
hash2 = hashvalue.split(':')[1]
|
||
else:
|
||
hash2 = hashvalue
|
||
|
||
# 创建查询URL, parameters and headers
|
||
url = ""
|
||
params = None
|
||
headers = None
|
||
if alg == LM:
|
||
url = "http://nediam.com.mx/winhashes/search_lm_hash.php"
|
||
params = {"lm": hash2,
|
||
"btn_go": "Search"}
|
||
headers = {"Referer": "http://nediam.com.mx/winhashes/search_lm_hash.php"}
|
||
else:
|
||
url = "http://nediam.com.mx/winhashes/search_nt_hash.php"
|
||
params = {"nt": hash2,
|
||
"btn_go": "Search"}
|
||
headers = {"Referer": "http://nediam.com.mx/winhashes/search_nt_hash.php"}
|
||
|
||
# 进行http 网络查询
|
||
response = do_HTTP_request(url, params, headers)
|
||
|
||
# 分析响应
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
return None
|
||
|
||
match = search(r'<tr><td align="right">PASSWORD</td><td>[^<]*</td></tr>', html)
|
||
|
||
if match:
|
||
return match.group().split(':')[1]
|
||
else:
|
||
return None
|
||
|
||
|
||
CRAKERS = [
|
||
NETMD5CRACK,
|
||
BENRAMSEY,
|
||
GROMWEB,
|
||
HASHCRACKING,
|
||
VICTOROV,
|
||
THEKAINE,
|
||
TMTO,
|
||
REDNOIZE,
|
||
MD5_DB,
|
||
MY_ADDR,
|
||
MD5PASS,
|
||
MD5DECRYPTION,
|
||
MD5CRACK,
|
||
MD5_DECRYPTER,
|
||
AUTHSECUMD5,
|
||
HASHCRACK,
|
||
OPHCRACK,
|
||
C0LLISION,
|
||
CMD5,
|
||
AUTHSECUCISCO7,
|
||
CACIN,
|
||
IBEAST,
|
||
PASSWORD_DECRYPT,
|
||
HASHCHECKER,
|
||
MD5HASHCRACKER,
|
||
PASSCRACKING,
|
||
ASKCHECK,
|
||
FOX21,
|
||
NICENAMECREW,
|
||
JOOMLAAA,
|
||
MD5_LOOKUP,
|
||
SHA1_LOOKUP,
|
||
SHA256_LOOKUP,
|
||
RIPEMD160_LOOKUP,
|
||
MD5_COM_CN,
|
||
DIGITALSUN,
|
||
MYINFOSEC,
|
||
MD5_NET,
|
||
NOISETTE,
|
||
MD5HOOD,
|
||
XANADREL,
|
||
SANS,
|
||
BOKEHMAN,
|
||
GOOG_LI,
|
||
WHREPORITORY ]
|
||
|
||
|
||
|
||
########################################################################################################
|
||
### GENERAL METHODS
|
||
########################################################################################################
|
||
|
||
def configureCookieProcessor (cookiefile='/tmp/searchmyhash.cookie'):
|
||
'''Set a Cookie Handler to accept cookies from the different Web sites.
|
||
|
||
@param cookiefile Path of the cookie store.'''
|
||
|
||
cookieHandler = LWPCookieJar()
|
||
if cookieHandler is not None:
|
||
if path.isfile (cookiefile):
|
||
cookieHandler.load (cookiefile)
|
||
|
||
opener = urllib2.build_opener ( urllib2.HTTPCookieProcessor(cookieHandler) )
|
||
urllib2.install_opener (opener)
|
||
|
||
|
||
|
||
def do_HTTP_request (url, params={}, httpheaders={}):
|
||
'''
|
||
Send a GET or POST HTTP Request.
|
||
@return: HTTP Response
|
||
'''
|
||
|
||
data = {}
|
||
request = None
|
||
|
||
# If there is parameters, they are been encoded
|
||
if params:
|
||
data = urlencode(params)
|
||
|
||
request = urllib2.Request ( url, data, headers=httpheaders )
|
||
else:
|
||
request = urllib2.Request ( url, headers=httpheaders )
|
||
|
||
# Send the request
|
||
try:
|
||
response = urllib2.urlopen (request)
|
||
except:
|
||
return ""
|
||
|
||
return response
|
||
|
||
|
||
def printSyntax ():
|
||
"""Print application syntax."""
|
||
|
||
print """%s 0.1 ( https://github.com/ym2011/penetration )
|
||
|
||
Usage:
|
||
------
|
||
|
||
python %s <加密算法> 选项
|
||
|
||
|
||
目前支持的算法是:
|
||
--------------------------------------------
|
||
|
||
MD4 - RFC 1320
|
||
MD5 - RFC 1321
|
||
SHA1 - RFC 3174 (FIPS 180-3)
|
||
SHA224 - RFC 3874 (FIPS 180-3)
|
||
SHA256 - FIPS 180-3
|
||
SHA384 - FIPS 180-3
|
||
SHA512 - FIPS 180-3
|
||
RMD160 - RFC 2857
|
||
GOST - RFC 5831
|
||
WHIRLPOOL - ISO/IEC 10118-3:2004
|
||
LM - Microsoft Windows hash
|
||
NTLM - Microsoft Windows hash
|
||
MYSQL - MySQL 3, 4, 5 hash
|
||
CISCO7 - Cisco IOS type 7 encrypted passwords
|
||
JUNIPER - Juniper Networks $9$ encrypted passwords
|
||
LDAP_MD5 - MD5 Base64 encoded
|
||
LDAP_SHA1 - SHA1 Base64 encoded
|
||
|
||
NOTE: for LM / NTLM it is recommended to introduce both values with this format:
|
||
python %s LM -h 9a5760252b7455deaad3b435b51404ee:0d7f1f2bdeac6e574d6e18ca85fb58a7
|
||
python %s NTLM -h 9a5760252b7455deaad3b435b51404ee:0d7f1f2bdeac6e574d6e18ca85fb58a7
|
||
|
||
|
||
Valid OPTIONS are:
|
||
------------------
|
||
|
||
-h <hash_value> If you only want to crack one hash, specify its value with this option.
|
||
|
||
-f <file> If you have several hashes, you can specify a file with one hash per line.
|
||
NOTE: All of them have to be the same type.
|
||
|
||
-g If your hash cannot be cracked, search it in Google and show all the results.
|
||
NOTE: This option ONLY works with -h (one hash input) option.
|
||
|
||
|
||
Examples:
|
||
---------
|
||
|
||
-> Try to crack only one hash.
|
||
python %s MD5 -h 098f6bcd4621d373cade4e832627b4f6
|
||
|
||
-> Try to crack a JUNIPER encrypted password escaping special characters.
|
||
python %s JUNIPER -h "\$9\$LbHX-wg4Z"
|
||
|
||
-> If the hash cannot be cracked, it will be searched in Google.
|
||
python %s LDAP_SHA1 -h "{SHA}cRDtpNCeBiql5KOQsKVyrA0sAiA=" -g
|
||
|
||
-> Try to crack multiple hashes using a file (one hash per line).
|
||
python %s MYSQL -f mysqlhashesfile.txt
|
||
|
||
|
||
source:
|
||
-----------------------------------
|
||
https://github.com/ym2011/penetration
|
||
|
||
""" % ( (sys.argv[0],) * 8 )
|
||
|
||
|
||
|
||
def crackHash (algorithm, hashvalue=None, hashfile=None):
|
||
"""Crack a hash or all the hashes of a file.
|
||
|
||
@param alg Algorithm of the hash (MD5, SHA1...).
|
||
@param hashvalue Hash value to be cracked.
|
||
@param hashfile Path of the hash file.
|
||
@return If the hash has been cracked or not."""
|
||
|
||
global CRAKERS
|
||
|
||
# Cracked hashes will be stored here
|
||
crackedhashes = []
|
||
|
||
# Is the hash cracked?
|
||
cracked = False
|
||
|
||
# Only one of the two possible inputs can be setted.
|
||
if (not hashvalue and not hashfile) or (hashvalue and hashfile):
|
||
return False
|
||
|
||
# hashestocrack depends on the input value
|
||
hashestocrack = None
|
||
if hashvalue:
|
||
hashestocrack = [ hashvalue ]
|
||
else:
|
||
try:
|
||
hashestocrack = open (hashfile, "r")
|
||
except:
|
||
print "\nIt is not possible to read input file (%s)\n" % (hashfile)
|
||
return cracked
|
||
|
||
|
||
# Try to crack all the hashes...
|
||
for activehash in hashestocrack:
|
||
hashresults = []
|
||
|
||
# Standarize the hash
|
||
activehash = activehash.strip()
|
||
if algorithm not in [JUNIPER, LDAP_MD5, LDAP_SHA1]:
|
||
activehash = activehash.lower()
|
||
|
||
# Initial message
|
||
print "\nCracking hash: %s\n" % (activehash)
|
||
|
||
# Each loop starts for a different start point to try to avoid IP filtered
|
||
begin = randint(0, len(CRAKERS ) -1)
|
||
|
||
for i in range(len(CRAKERS)):
|
||
|
||
# Select the cracker
|
||
cr = CRAKERS[ ( i +begin ) %len(CRAKERS) ]()
|
||
|
||
# Check if the cracker support the algorithm
|
||
if not cr.isSupported ( algorithm ):
|
||
continue
|
||
|
||
# Analyze the hash
|
||
print "Analyzing with %s (%s)..." % (cr.name, cr.url)
|
||
|
||
# Crack the hash
|
||
result = None
|
||
try:
|
||
result = cr.crack ( activehash, algorithm )
|
||
# If it was some trouble, exit
|
||
except:
|
||
print "\nSomething was wrong. Please, contact with us to report the bug:\n\nbloglaxmarcaellugar@gmail.com\n"
|
||
if hashfile:
|
||
try:
|
||
hashestocrack.close()
|
||
except:
|
||
pass
|
||
return False
|
||
|
||
# If there is any result...
|
||
cracked = 0
|
||
if result:
|
||
|
||
# If it is a hashlib supported algorithm...
|
||
if algorithm in [MD4, MD5, SHA1, SHA224, SHA384, SHA256, SHA512, RIPEMD]:
|
||
# Hash value is calculated to compare with cracker result
|
||
h = hashlib.new (algorithm)
|
||
h.update (result)
|
||
|
||
# If the calculated hash is the same to cracker result, the result is correct (finish!)
|
||
if h.hexdigest() == activehash:
|
||
hashresults.append (result)
|
||
cracked = 2
|
||
|
||
# If it is a half-supported hashlib algorithm
|
||
elif algorithm in [LDAP_MD5, LDAP_SHA1]:
|
||
alg = algorithm.split('_')[1]
|
||
ahash = decodestring ( activehash.split('}')[1] )
|
||
|
||
# Hash value is calculated to compare with cracker result
|
||
h = hashlib.new (alg)
|
||
h.update (result)
|
||
|
||
# If the calculated hash is the same to cracker result, the result is correct (finish!)
|
||
if h.digest() == ahash:
|
||
hashresults.append (result)
|
||
cracked = 2
|
||
|
||
# If it is a NTLM hash
|
||
elif algorithm == NTLM or (algorithm == LM and ':' in activehash):
|
||
# NTLM Hash value is calculated to compare with cracker result
|
||
candidate = hashlib.new('md4', result.split()[-1].encode('utf-16le')).hexdigest()
|
||
|
||
# It's a LM:NTLM combination or a single NTLM hash
|
||
if (':' in activehash and candidate == activehash.split(':')[1]) or \
|
||
(':' not in activehash and candidate == activehash):
|
||
hashresults.append(result)
|
||
cracked = 2
|
||
|
||
# If it is another algorithm, we search in all the crackers
|
||
else:
|
||
hashresults.append(result)
|
||
cracked = 1
|
||
|
||
# Had the hash cracked?
|
||
if cracked:
|
||
print "\n***** HASH CRACKED!! *****\nThe original string is: %s\n" % (result)
|
||
# If result was verified, break
|
||
if cracked == 2:
|
||
break
|
||
else:
|
||
print "... hash not found in %s\n" % (cr.name)
|
||
|
||
# Store the result/s for later...
|
||
if hashresults:
|
||
|
||
# With some hash types, it is possible to have more than one result,
|
||
# Repited results are deleted and a single string is constructed.
|
||
resultlist = []
|
||
for r in hashresults:
|
||
# if r.split()[-1] not in resultlist:
|
||
# resultlist.append (r.split()[-1])
|
||
if r not in resultlist:
|
||
resultlist.append(r)
|
||
|
||
finalresult = ""
|
||
if len(resultlist) > 1:
|
||
finalresult = ', '.join(resultlist)
|
||
else:
|
||
finalresult = resultlist[0]
|
||
|
||
# Valid results are stored
|
||
crackedhashes.append((activehash, finalresult))
|
||
|
||
# Loop is finished. File can need to be closed
|
||
if hashfile:
|
||
try:
|
||
hashestocrack.close()
|
||
except:
|
||
pass
|
||
|
||
# Show a resume of all the cracked hashes
|
||
print "\nThe following hashes were cracked:\n----------------------------------\n"
|
||
print crackedhashes and "\n".join(
|
||
"%s -> %s" % (hashvalue, result.strip()) for hashvalue, result in crackedhashes) or "NO HASH WAS CRACKED."
|
||
print
|
||
|
||
return cracked
|
||
|
||
|
||
def searchHash(hashvalue):
|
||
'''Google the hash value looking for any result which could give some clue...
|
||
|
||
@param hashvalue The hash is been looking for.'''
|
||
|
||
start = 0
|
||
finished = False
|
||
results = []
|
||
|
||
sys.stdout.write("\nThe hash wasn't found in any database. Maybe Google has any idea...\nLooking for results...")
|
||
sys.stdout.flush()
|
||
|
||
while not finished:
|
||
|
||
sys.stdout.write('.')
|
||
sys.stdout.flush()
|
||
|
||
# 创建查询URL
|
||
url = "http://www.google.com/search?hl=en&q=%s&filter=0" % (hashvalue)
|
||
if start:
|
||
url += "&start=%d" % (start)
|
||
|
||
# Build the Headers with a random User-Agent
|
||
headers = {"User-Agent": USER_AGENTS[randint(0, len(USER_AGENTS)) - 1]}
|
||
|
||
# Send the request
|
||
response = do_HTTP_request(url, httpheaders=headers)
|
||
|
||
# Extract the results ...
|
||
html = None
|
||
if response:
|
||
html = response.read()
|
||
else:
|
||
continue
|
||
|
||
resultlist = findall(r'<a href="[^"]*?" class=l', html)
|
||
|
||
# ... saving only new ones
|
||
new = False
|
||
for r in resultlist:
|
||
url_r = r.split('"')[1]
|
||
|
||
if not url_r in results:
|
||
results.append(url_r)
|
||
new = True
|
||
|
||
start += len(resultlist)
|
||
|
||
# If there is no a new result, finish
|
||
if not new:
|
||
finished = True
|
||
|
||
# Show the results
|
||
if results:
|
||
print "\n\nGoogle has some results. Maybe you would like to check them manually:\n"
|
||
|
||
results.sort()
|
||
for r in results:
|
||
print " *> %s" % (r)
|
||
print
|
||
|
||
else:
|
||
print "\n\nGoogle doesn't have any result. Sorry!\n"
|
||
|
||
|
||
########################################################################################################
|
||
### MAIN CODE
|
||
########################################################################################################
|
||
|
||
def main():
|
||
"""Main method."""
|
||
|
||
###################################################
|
||
# Syntax check
|
||
if len(sys.argv) < 4:
|
||
printSyntax()
|
||
sys.exit(1)
|
||
|
||
else:
|
||
try:
|
||
opts, args = getopt.getopt(sys.argv[2:], "gh:f:")
|
||
except:
|
||
printSyntax()
|
||
sys.exit(1)
|
||
|
||
###################################################
|
||
# Load input parameters
|
||
algorithm = sys.argv[1].lower()
|
||
hashvalue = None
|
||
hashfile = None
|
||
googlesearch = False
|
||
|
||
for opt, arg in opts:
|
||
if opt == '-h':
|
||
hashvalue = arg
|
||
elif opt == '-f':
|
||
hashfile = arg
|
||
else:
|
||
googlesearch = True
|
||
|
||
###################################################
|
||
# Configure the Cookie Handler
|
||
configureCookieProcessor()
|
||
|
||
# Initialize PRNG seed
|
||
seed()
|
||
|
||
cracked = 0
|
||
|
||
###################################################
|
||
# Crack the hash/es
|
||
cracked = crackHash(algorithm, hashvalue, hashfile)
|
||
|
||
###################################################
|
||
# Look for the hash in Google if it was not cracked
|
||
if not cracked and googlesearch and not hashfile:
|
||
searchHash(hashvalue)
|
||
|
||
# App is finished
|
||
sys.exit()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|