Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- # -*- coding: iso-8859-1 -*-
- ########################################################################################################
- ### LICENSE
- ########################################################################################################
- #
- # findmyhash.py - v 1.1.2a
- #
- # This script is under GPL v3 License (http://www.gnu.org/licenses/gpl-3.0.html).
- #
- # Only this source code is under GPL v3 License. Web services used in this script are under
- # different licenses.
- #
- # If you know some clause in one of these web services which forbids to use it inside this script,
- # please contact me to remove the web service as soon as possible.
- #
- # Developed by JulGor ( http://laxmarcaellugar.blogspot.com/ )
- # Mail: bloglaxmarcaellugar AT gmail DOT com
- # twitter: @laXmarcaellugar
- #
- ########################################################################################################
- ### IMPORTS
- ########################################################################################################
- 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 """
- Execution error:
- You required some basic Python libraries.
- This application use: sys, hashlib, urllib, urllib2, os, re, random, getopt, base64 and cookielib.
- Please, check if you have all of them installed in your system.
- """
- sys.exit(1)
- try:
- from httplib2 import Http
- except:
- print """
- Execution error:
- The Python library httplib2 is not installed in your system.
- Please, install it before use this application.
- """
- sys.exit(1)
- try:
- from libxml2 import parseDoc
- except:
- print """
- Execution error:
- The Python library libxml2 is not installed in your system.
- Because of that, some plugins aren't going to work correctly.
- Please, install it before use this application.
- """
- ########################################################################################################
- ### CONSTANTS
- ########################################################################################################
- 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/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; Crazy Browser 1.0.5)",
- "curl/7.7.2 (powerpc-apple-darwin6.0) libcurl 7.7.2 (OpenSSL 0.9.6b)",
- "Mozilla/5.0 (X11; U; Linux amd64; en-US; rv:5.0) Gecko/20110619 Firefox/5.0",
- "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",
- "Mozilla/5.0 (compatible; MSIE 8.0; Windows NT 5.1; Trident/4.0; InfoPath.2; SLCC1; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729; .NET CLR 2.0.50727)",
- "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",
- "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
- ]
- ########################################################################################################
- ### CRACKERS DEFINITION
- ########################################################################################################
- class SCHWETT:
- name = "schwett"
- url = "http://schwett.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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://schwett.com/md5/index.php?md5value=%s&md5c=Hash+Match" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- html = None
- if response:
- html = response.read()
- else:
- return None
- match = search (r"<h3><font color='red'>No Match Found</font></h3><br />", html)
- if match:
- return None
- else:
- return "The hash is broken, please contact with La X marca el lugar and send it the hash value to add the correct regexp."
- class NETMD5CRACK:
- name = "netmd5crack"
- url = "http://www.netmd5crack.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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://www.netmd5crack.com/cgi-bin/Crack.py?InputHash=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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 MD5_CRACKER:
- name = "md5-cracker"
- url = "http://www.md5-cracker.tk"
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://www.md5-cracker.tk/xml.php?md5=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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("//data")
- if len(result):
- return result[0].content
- else:
- return None
- class BENRAMSEY:
- name = "benramsey"
- url = "http://tools.benramsey.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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://tools.benramsey.com/md5/md5.php?hash=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://md5.gromweb.com/query/%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://md5.hashcracking.com/search.php?md5=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://victorov.su/md5/?md5e=&md5d=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://md5.thekaine.de/?hash=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://www.tmto.org/api/latest/?hash=%s&auth=true" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://md5-db.de/%s.html" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the 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 }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = self.url
- # Build the parameters
- params = { "hash" : hashvalue,
- "get_pass" : "Get Pass" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = self.url
- # Build the parameters
- params = { "hash" : hashvalue,
- "submit" : "Decrypt It!" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://md5crack.com/crackmd5.php"
- # Build the parameters
- params = { "term" : hashvalue,
- "crackbtn" : "Crack that hash baby!" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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 MD5ONLINE:
- name = "md5online"
- url = "http://md5online.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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = self.url
- # Build the parameters
- params = { "pass" : hashvalue,
- "option" : "hash2text",
- "send" : "Submit" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- html = None
- if response:
- html = response.read()
- else:
- return None
- match = search (r'<center><p>md5 :<b>\w*</b> <br>pass : <b>[^<]*</b></p></table>', html)
- if match:
- return match.group().split('b>')[3][:-2]
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = self.url
- # Build the parameters
- params = { "data[Row][cripted]" : hashvalue }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the 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" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the 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" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- 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
- # Build the URL and the headers
- url = "http://www.objectif-securite.ch/en/products.php?hash=%s" % (hashvalue.replace(':', '%3A'))
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- 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]
- # Build the URL
- url = "http://www.c0llision.net/webcrack/request"
- # Build the parameters
- params = { "hash[_input_]" : hashvalue,
- "hash[_csrf_token]" : token }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the 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)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- 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]
- # Build the 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/" }
- # Make the request
- response = do_HTTP_request ( url, params, header )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the 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 }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL and the headers
- url = "http://cacin.net/cgi-bin/decrypt-cisco.pl?cisco_hash=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL and the headers
- url = "http://www.ibeast.com/content/tools/CiscoPassword/decrypt.php?txtPassword=%s&submit1=Enviar+consulta" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the 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" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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 BIGTRAPEZE:
- name = "bigtrapeze"
- url = "http://www.bigtrapeze.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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL and the headers
- url = "http://www.bigtrapeze.com/md5/index.php"
- # Build the parameters
- params = { "query" : hashvalue,
- " Crack " : "Enviar consulta" }
- # Build the Headers with a random User-Agent
- headers = { "User-Agent" : USER_AGENTS[randint(0, len(USER_AGENTS))-1] }
- # Make the request
- response = do_HTTP_request ( url, params, headers )
- # Analyze the response
- html = None
- if response:
- html = response.read()
- else:
- return None
- match = search (r'Congratulations!<li>The hash <strong>[^<]*</strong> has been deciphered to: <strong>[^<]*</strong></li>', html)
- if match:
- return match.group().split('strong>')[3][:-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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL and the headers
- url = "http://www.hashchecker.com/index.php"
- # Build the parameters
- params = { "search_field" : hashvalue,
- "Submit" : "search" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the 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 )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the 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) }
- # Make the request
- 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
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://askcheck.com/reverse?reverse=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- 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
- # Build the URL
- url = "http://cracker.fox21.at/api.php?a=check&h=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- hash2 = None
- if alg in [LM] and ':' in hashvalue:
- hash2 = hashvalue.split(':')[0]
- else:
- hash2 = hashvalue
- # Build the URL
- url = "http://crackfoo.nicenamecrew.com/?t=%s" % (alg)
- # Build the parameters
- params = { "q" : hash2,
- "sa" : "Crack" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://joomlaaa.com/component/option,com_md5/Itemid,31/"
- # Build the parameters
- params = { "md5" : hashvalue,
- "decode" : "Submit" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://md5-lookup.com/livesearch.php?q=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://sha1-lookup.com/livesearch.php?q=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://sha-256.sha1-lookup.com/livesearch.php?q=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://www.ripemd-lookup.com/livesearch.php?q=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://md5.com.cn/md5reverse"
- # Build the parameters
- params = { "md" : hashvalue,
- "submit" : "MD5 Crack" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://md5.digitalsun.pl/"
- # Build the parameters
- params = { "hash" : hashvalue }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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 DRASEN:
- name = "drasen.net"
- url = "http://md5.drasen.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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://md5.drasen.net/search.php?query=%s" % (hashvalue)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- html = None
- if response:
- html = response.read()
- else:
- return None
- match = search (r'Hash: [^<]*<br />Plain: [^<]*<br />', html)
- if match:
- return match.group().split('<br />')[1][7:]
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://md5.myinfosec.net/md5.php"
- # Build the parameters
- params = { "md5hash" : hashvalue }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://www.md5.net/cracker.php"
- # Build the parameters
- params = { "hash" : hashvalue }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://md5.noisette.ch/index.php"
- # Build the parameters
- params = { "hash" : hashvalue }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://md5hood.com/index.php/cracker/crack"
- # Build the parameters
- params = { "md5" : hashvalue,
- "submit" : "Go" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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 STRINGFUNCTION:
- name = "stringfunction"
- url = "http://www.stringfunction.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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = ""
- if alg == MD5:
- url = "http://www.stringfunction.com/md5-decrypter.html"
- else:
- url = "http://www.stringfunction.com/sha1-decrypter.html"
- # Build the parameters
- params = { "string" : hashvalue,
- "submit" : "Decrypt",
- "result" : "" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- html = None
- if response:
- html = response.read()
- else:
- return None
- match = search (r'<textarea class="textarea-input-tool-b" rows="10" cols="50" name="result"[^>]*>[^<]+</textarea>', html)
- if match:
- return match.group().split('>')[1][:-10]
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the URL
- url = "http://xanadrel.99k.org/hashes/index.php?k=search"
- # Build the parameters
- params = { "hash" : hashvalue,
- "search" : "ok" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the 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"
- # Make the request
- response = do_HTTP_request ( url, params, headers )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- if not self.isSupported (alg):
- return None
- # Build the 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" }
- # Make the request
- response = do_HTTP_request ( url, params )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- 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
- # Build the URL
- url = "http://goog.li/?q=%s" % (hash2)
- # Make the request
- response = do_HTTP_request ( url )
- # Analyze the response
- 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."""
- # Check if the cracker can crack this kind of algorithm
- 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
- # Build the 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" }
- # Make the request
- response = do_HTTP_request ( url, params, headers )
- # Analyze the response
- 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 = [ SCHWETT,
- NETMD5CRACK,
- MD5_CRACKER,
- BENRAMSEY,
- GROMWEB,
- HASHCRACKING,
- VICTOROV,
- THEKAINE,
- TMTO,
- REDNOIZE,
- MD5_DB,
- MY_ADDR,
- MD5PASS,
- MD5DECRYPTION,
- MD5CRACK,
- MD5ONLINE,
- MD5_DECRYPTER,
- AUTHSECUMD5,
- HASHCRACK,
- OPHCRACK,
- C0LLISION,
- CMD5,
- AUTHSECUCISCO7,
- CACIN,
- IBEAST,
- PASSWORD_DECRYPT,
- BIGTRAPEZE,
- HASHCHECKER,
- MD5HASHCRACKER,
- PASSCRACKING,
- ASKCHECK,
- FOX21,
- NICENAMECREW,
- JOOMLAAA,
- MD5_LOOKUP,
- SHA1_LOOKUP,
- SHA256_LOOKUP,
- RIPEMD160_LOOKUP,
- MD5_COM_CN,
- DIGITALSUN,
- DRASEN,
- MYINFOSEC,
- MD5_NET,
- NOISETTE,
- MD5HOOD,
- STRINGFUNCTION,
- 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 1.1.2 ( http://code.google.com/p/findmyhash/ )
- Usage:
- ------
- python %s <algorithm> OPTIONS
- Accepted algorithms are:
- ------------------------
- 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)
- Examples:
- ---------
- -> Try to crack only one hash.
- python %s MD5 -h 098f6bcd4621d373cade4e832627b4f6
- -> Try to crack hashes on a webpage
- python %s MD5 -u http://pastebin.com/ddWYY634
- python %s SHA1 -u http://pastebin.com/1YbcH2k5
- -> 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
- Contact:
- --------
- [Web] http://laxmarcaellugar.blogspot.com/
- [Mail/Google+] bloglaxmarcaellugar@gmail.com
- [twitter] @laXmarcaellugar
- """ % ( (sys.argv[0],) * 10 )
- 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()
- # Build the 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:u:")
- except:
- printSyntax()
- sys.exit(1)
- ###################################################
- # Load input parameters
- algorithm = sys.argv[1].lower()
- hashvalue = None
- hashfile = None
- retrieveUrl = None
- googlesearch = False
- for opt, arg in opts:
- if opt == '-h':
- hashvalue = arg
- elif opt == '-f':
- hashfile = arg
- elif opt == '-u':
- retrieveUrl = arg
- else:
- googlesearch = True
- ###################################################
- # Configure the Cookie Handler
- configureCookieProcessor()
- # Initialize PRNG seed
- seed()
- cracked = 0
- md5list = []
- if retrieveUrl:
- response = do_HTTP_request ( retrieveUrl )
- html = None
- if response:
- html = response.read()
- else:
- return None
- if(algorithm=="md5"):
- match = findall (r'(?i)(?<![a-z0-9])[a-f0-9]{32}(?![a-z0-9])', html)
- print match
- for hashvalue in match:
- cracked = crackHash (algorithm, hashvalue, hashfile)
- if not cracked and googlesearch and not hashfile:
- searchHash (hashvalue)
- sys.exit(1)
- if(algorithm=="sha1"):
- match = findall (r'(?i)(?<![a-z0-9])[a-f0-9]{40}(?![a-z0-9])', html)
- for hashvalue in match:
- cracked = crackHash (algorithm, hashvalue, hashfile)
- if not cracked and googlesearch and not hashfile:
- searchHash (hashvalue)
- sys.exit(1)
- ###################################################
- # 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()
Add Comment
Please, Sign In to add comment