#!/usr/bin/env python3
# -*- coding: utf-8 -*-"
"""
This file is part of the UFONet project, https://ufonet.03c8.net
Copyright (c) 2013/2020 | psy <epsylon@riseup.net>
You should have received a copy of the GNU General Public License along
with UFONet; if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
import ssl, random, re
import urllib.request, urllib.error
from urllib.parse import urlparse as urlparse
# Inspector spidering class
class Inspector(object):
def __init__(self,ufonet):
self.ufonet=ufonet
# set initial counters for objets
self.c_images = 0
self.c_mov = 0
self.c_webm = 0
self.c_avi = 0
self.c_swf = 0
self.c_mpg = 0
self.c_mpeg = 0
self.c_mp3 = 0
self.c_ogg = 0
self.c_ogv = 0
self.c_wmv = 0
self.c_css = 0
self.c_js = 0
self.c_xml = 0
self.c_php = 0
self.c_html = 0
self.c_jsp = 0
self.c_asp = 0
self.c_txt = 0
self.ctx = ssl.create_default_context() # creating context to bypass SSL cert validation (black magic)
self.ctx.check_hostname = False
self.ctx.verify_mode = ssl.CERT_NONE
def proxy_transport(self, proxy):
proxy_url = self.ufonet.extract_proxy(proxy)
proxy = urllib.request.ProxyHandler({'https': proxy_url})
opener = urllib.request.build_opener(proxy)
urllib.request.install_opener(opener)
def inspecting(self, target):
# inspect HTML target's components sizes (ex: http://target.com/foo)
# [images, .mov, .webm, .avi, .swf, .mpg, .mpeg, .mp3, .ogg, .ogv,
# .wmv, .css, .js, .xml, .php, .html, .jsp, .asp, .txt]
biggest_files = {}
if target.endswith(""):
target.replace("", "/")
self.ufonet.user_agent = random.choice(self.ufonet.agents).strip() # shuffle user-agent
headers = {'User-Agent' : self.ufonet.user_agent, 'Referer' : self.ufonet.referer} # set fake user-agent and referer
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target, None, headers)
target_reply = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target, None, headers)
target_reply = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
except:
print('[Error] [AI] Unable to connect to target -> [Exiting!]\n')
return
try: # search for image files
regex_img = []
regex_img1 = "<img src='(.+?)'" # search on target's results using regex with simple quotation
regex_img.append(regex_img1)
regex_img2 = '<img src="(.+?)"' # search on target's results using regex with double quotation
regex_img.append(regex_img2)
#regex_img3 = '<img src=(.+?)>' # search on target's results using regex without quotations
#regex_img.append(regex_img3)
for regimg in regex_img:
pattern_img = re.compile(regimg)
img_links = re.findall(pattern_img, target_reply)
imgs = {}
for img in img_links:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
self.ufonet.user_agent = random.choice(self.ufonet.agents).strip() # shuffle user-agent
headers = {'User-Agent' : self.ufonet.user_agent, 'Referer' : self.ufonet.referer} # set fake user-agent and referer
try:
if img.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
if img.startswith("data:image"):
size = 0
else:
if img.startswith('/'):
img = img.replace("/", "", 1)
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + img, None, headers)
img_file = urllib.request.urlopen(req, context=self.ctx).read()
else:
req = urllib.request.Request(target_url + img, None, headers)
img_file = urllib.request.urlopen(req, context=self.ctx).read()
print('+Image found: ' + target_url + img.split('"')[0])
size = len(img_file)
print('(Size: ' + str(size) + ' Bytes)')
imgs[img] = int(size)
self.c_images = self.c_images + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Image -> [Discarding!]')
size = 0
biggest_image = max(list(imgs.keys()), key=lambda x: imgs[x]) # search/extract biggest image value from dict
if biggest_image:
biggest_files[biggest_image] = imgs[biggest_image] # add biggest image to list
except: # if not any image found, go for next
pass
try: # search for .mov files
regex_mov = []
regex_mov1 = "<a href='(.+?.mov)'" # search on target's results using regex with simple quotation
regex_mov.append(regex_mov1)
regex_mov2 = '<a href="(.+?.mov)"' # search on target's results using regex with double quotation
regex_mov.append(regex_mov2)
#regex_mov3 = '<a href=(.+?.mov)' # search on target's results using regex without quotations
#regex_mov.append(regex_mov3)
for regmov in regex_mov:
pattern_mov = re.compile(regmov)
mov_links = re.findall(pattern_mov, target_reply)
movs = {}
for mov in mov_links:
try:
if mov.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + mov, None, headers)
mov_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + mov, None, headers)
mov_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Video (.mov) found: ' + target_url + mov.split('"')[0])
size = len(mov_file)
movs[mov] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_mov = self.c_mov + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Video -> [Discarding!]')
size = 0
biggest_mov = max(list(movs.keys()), key=lambda x: movs[x]) # search/extract biggest video (.mov) value from dict
if biggest_mov:
biggest_files[biggest_mov] = movs[biggest_mov] # add biggest video (.mov) to list
except: # if not any .mov found, go for next
pass
try: # search for .webm files
regex_webm = []
regex_webm1 = "<a href='(.+?.webm)'" # search on target's results using regex with simple quotation
regex_webm.append(regex_webm1)
regex_webm2 = '<a href="(.+?.webm)"' # search on target's results using regex with double quotation
regex_webm.append(regex_webm2)
#regex_webm3 = '<a href=(.+?.webm)' # search on target's results using regex without quotations
#regex_webm.append(regex_webm3)
for regwebm in regex_webm:
pattern_webm = re.compile(regwebm)
webm_links = re.findall(pattern_webm, target_reply)
webms = {}
for webm in webm_links:
try:
if webm.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + webm, None, headers)
webm_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + webm, None, headers)
webm_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Video (.webm) found: ' + target_url + webm.split('"')[0])
size = len(webm_file)
webms[webm] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_webm = self.c_webm + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Video -> [Discarding!]')
size = 0
biggest_webm = max(list(webms.keys()), key=lambda x: webms[x]) # search/extract biggest video (.webm) value from dict
if biggest_webm:
biggest_files[biggest_webm] = webms[biggest_webm] # add biggest video (.webm) to list
except: # if not any .webm found, go for next
pass
try: # search for .avi files
regex_avi = []
regex_avi1 = "<a href='(.+?.avi)'" # search on target's results using regex with simple quotation
regex_avi.append(regex_avi1)
regex_avi2 = '<a href="(.+?.avi)"' # search on target's results using regex with double quotation
regex_avi.append(regex_avi2)
#regex_avi3 = '<a href=(.+?.avi)' # search on target's results using regex without quotations
#regex_avi.append(regex_avi3)
for regavi in regex_avi:
pattern_avi = re.compile(regavi)
avi_links = re.findall(pattern_avi, target_reply)
avis = {}
for avi in avi_links:
try:
if avi.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + avi, None, headers)
avi_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + avi, None, headers)
avi_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Video (.avi) found: ' + target_url + avi.split('"')[0])
size = len(avi_file)
avis[avi] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_avi = self.c_avi + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Video -> [Discarding!]')
size = 0
biggest_avi = max(list(avis.keys()), key=lambda x: avis[x]) # search/extract biggest video (.avi) value from dict
if biggest_avi:
biggest_files[biggest_avi] = avis[biggest_avi] # add biggest video (.avi) to list
except: # if not any .avi found, go for next
pass
try: # search for .swf files
regex_swf = []
regex_swf1 = "<value='(.+?.swf)'" # search on target's results using regex with simple quotation
regex_swf.append(regex_swf1)
regex_swf2 = '<value="(.+?.swf)"' # search on target's results using regex with double quotation
regex_swf.append(regex_swf2)
#regex_swf3 = '<value=(.+?.swf)' # search on target's results using regex without quotations
#regex_swf.append(regex_swf3)
for regswf in regex_swf:
pattern_swf = re.compile(regswf)
swf_links = re.findall(pattern_swf, target_reply)
swfs = {}
for swf in swf_links:
try:
if swf.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + swf, None, headers)
swf_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + swf, None, headers)
swf_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Flash (.swf) found: ' + target_url + swf.split('"')[0])
size = len(swf_file)
swfs[swf] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_swf = self.c_swf + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Flash -> [Discarding!]')
size = 0
biggest_swf = max(list(swfs.keys()), key=lambda x: swfs[x]) # search/extract biggest flash (.swf) value from dict
if biggest_swf:
biggest_files[biggest_swf] = swfs[biggest_swf] # add biggest flash (.swf) to list
except: # if not any .swf found, go for next
pass
try: # search for .mpg files
regex_mpg = []
regex_mpg1 = "<src='(.+?.mpg)'" # search on target's results using regex with simple quotation
regex_mpg.append(regex_mpg1)
regex_mpg2 = '<src="(.+?.mpg)"' # search on target's results using regex with double quotation
regex_mpg.append(regex_mpg2)
#regex_mpg3 = '<src=(.+?.mpg)' # search on target's results using regex without quotations
#regex_mpg.append(regex_mpg3)
for regmpg in regex_mpg:
pattern_mpg = re.compile(regmpg)
mpg_links = re.findall(pattern_mpg, target_reply)
mpgs = {}
for mpg in mpg_links:
try:
if mpg.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + mpg, None, headers)
mpg_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + mpg, None, headers)
mpg_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Video (.mpg) found: ' + target_url + mpg.split('"')[0])
size = len(mpg_file)
mpgs[mpg] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_mpg = self.c_mpg + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Video -> [Discarding!]')
size = 0
biggest_mpg = max(list(mpgs.keys()), key=lambda x: mpgs[x]) # search/extract biggest video (.mpg) value from dict
if biggest_mpg:
biggest_files[biggest_mpg] = mpgs[biggest_mpg] # add biggest video (.mpg) to list
except: # if not any .mpg found, go for next
pass
try: # search for .mpeg files
regex_mpeg = []
regex_mpeg1 = "<src='(.+?.mpeg)'" # search on target's results using regex with simple quotation
regex_mpeg.append(regex_mpeg1)
regex_mpeg2 = '<src="(.+?.mpeg)"' # search on target's results using regex with double quotation
regex_mpeg.append(regex_mpeg2)
#regex_mpeg3 = '<src=(.+?.mpeg)' # search on target's results using regex without quotations
#regex_mpeg.append(regex_mpeg3)
for regmpeg in regex_mpeg:
pattern_mpeg = re.compile(regmpeg)
mpeg_links = re.findall(pattern_mpeg, target_reply)
mpegs = {}
for mpeg in mpeg_links:
try:
if mpeg.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + mpeg, None, headers)
mpeg_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + mpeg, None, headers)
mpeg_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Video (.mpeg) found: ' + target_url + mpeg.split('"')[0])
size = len(mpeg_file)
mpegs[mpeg] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_mpeg = self.c_mpeg + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Video -> [Discarding!]')
size = 0
biggest_mpeg = max(list(mpegs.keys()), key=lambda x: mpegs[x]) # search/extract biggest video (.mpeg) value from dict
if biggest_mpeg:
biggest_files[biggest_mpeg] = mpegs[biggest_mpeg] # add biggest video (.mpeg) to list
except: # if not any .mpeg found, go for next
pass
try: # search for .mp3 files
regex_mp3 = []
regex_mp31 = "<src='(.+?.mp3)'" # search on target's results using regex with simple quotation
regex_mp3.append(regex_mp31)
regex_mp32 = '<src="(.+?.mp3)"' # search on target's results using regex with double quotation
regex_mp3.append(regex_mp32)
#regex_mp33 = '<src=(.+?.mp3)' # search on target's results using regex without quotations
#regex_mp3.append(regex_mp33)
for regmp3 in regex_mp3:
pattern_mp3 = re.compile(regmp3)
mp3_links = re.findall(pattern_mp3, target_reply)
mp3s = {}
for mp3 in mp3_links:
try:
if mp3.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + mp3, None, headers)
mp3_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + mp3, None, headers)
mp3_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Audio (.mp3) found: ' + target_url + mp3.split('"')[0])
size = len(mp3_file)
mp3s[mp3] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_mp3 = self.c_mp3 + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Audio -> [Discarding!]')
size = 0
biggest_mp3 = max(list(mp3s.keys()), key=lambda x: mp3s[x]) # search/extract biggest audio (.mp3) value from dict
if biggest_mp3:
biggest_files[biggest_mp3] = mp3s[biggest_mp3] # add biggest audio (.mp3) to list
except: # if not any .mp3 found, go for next
pass
try: # search for .mp4 files
regex_mp4 = []
regex_mp41 = "<src='(.+?.mp4)'" # search on target's results using regex with simple quotation
regex_mp4.append(regex_mp41)
regex_mp42 = '<src="(.+?.mp4)"' # search on target's results using regex with double quotation
regex_mp4.append(regex_mp42)
#regex_mp43 = '<src=(.+?.mp4)' # search on target's results using regex without quotations
#regex_mp4.append(regex_mp43)
for regmp4 in regex_mp4:
pattern_mp4 = re.compile(regmp4)
mp4_links = re.findall(pattern_mp4, target_reply)
mp4s = {}
for mp4 in mp4_links:
try:
if mp4.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + mp4, None, headers)
mp4_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + mp4, None, headers)
mp4_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Video (.mp4) found: ' + target_url + mp4.split('"')[0])
size = len(mp4_file)
mp4s[mp4] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_mp4 = self.c_mp4 + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Video -> [Discarding!]')
size = 0
biggest_mp4 = max(list(mp4s.keys()), key=lambda x: mp4s[x]) # search/extract biggest video (.mp4) value from dict
if biggest_mp4:
biggest_files[biggest_mp4] = mp4s[biggest_mp4] # add biggest video (.mp4) to list
except: # if not any .mp4 found, go for next
pass
try: # search for .ogg files
regex_ogg = []
regex_ogg1 = "<src='(.+?.ogg)'" # search on target's results using regex with simple quotation
regex_ogg.append(regex_ogg1)
regex_ogg2 = '<src="(.+?.ogg)"' # search on target's results using regex with double quotation
regex_ogg.append(regex_ogg2)
#regex_ogg3 = '<src=(.+?.ogg)' # search on target's results using regex without quotations
#regex_ogg.append(regex_ogg3)
for regogg in regex_ogg:
pattern_ogg = re.compile(regogg)
ogg_links = re.findall(pattern_ogg, target_reply)
oggs = {}
for ogg in ogg_links:
try:
if ogg.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + ogg, None, headers)
ogg_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + ogg, None, headers)
ogg_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Audio (.ogg) found: ' + target_url + ogg.split('"')[0])
size = len(ogg_file)
oggs[ogg] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_ogg = self.c_ogg + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Audio -> [Discarding!]')
size = 0
biggest_ogg = max(list(oggs.keys()), key=lambda x: oggs[x]) # search/extract biggest video (.ogg) value from dict
if biggest_ogg:
biggest_files[biggest_ogg] = oggs[biggest_ogg] # add biggest video (.ogg) to list
except: # if not any .ogg found, go for next
pass
try: # search for .ogv files
regex_ogv = []
regex_ogv1 = "<src='(.+?.ogv)'" # search on target's results using regex with simple quotation
regex_ogv.append(regex_ogv1)
regex_ogv2 = '<src="(.+?.ogv)"' # search on target's results using regex with double quotation
regex_ogv.append(regex_ogv2)
#regex_ogv3 = '<src=(.+?.ogv)' # search on target's results using regex without quotations
#regex_ogv.append(regex_ogv3)
for regogv in regex_ogv:
pattern_ogv = re.compile(regogv)
ogv_links = re.findall(pattern_ogv, target_reply)
ogvs = {}
for ogv in ogv_links:
try:
if ogv.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + ogv, None, headers)
ogv_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + ogv, None, headers)
ogv_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Video (.ogv) found: ' + target_url + ogv.split('"')[0])
size = len(ogv_file)
ogvs[ogv] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_ogv = self.c_ogv + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Video -> [Discarding!]')
size = 0
biggest_ogv = max(list(ogvs.keys()), key=lambda x: ogvs[x]) # search/extract biggest video (.ogv) value from dict
if biggest_ogv:
biggest_files[biggest_ogv] = ogvs[biggest_ogv] # add biggest video (.ogv) to list
except: # if not any .ogv found, go for next
pass
try: # search for .wmv files
regex_wmv = []
regex_wmv1 = "<src='(.+?.wmv)'" # search on target's results using regex with simple quotation
regex_wmv.append(regex_wmv1)
regex_wmv2 = '<src="(.+?.wmv)"' # search on target's results using regex with double quotation
regex_wmv.append(regex_wmv2)
#regex_wmv3 = '<src=(.+?.wmv)' # search on target's results using regex without quotations
#regex_wmv.append(regex_wmv3)
for regwmv in regex_wmv:
pattern_wmv = re.compile(regwmv)
wmv_links = re.findall(pattern_wmv, target_reply)
wmvs = {}
for wmv in wmv_links:
try:
if wmv.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + wmv, None, headers)
wmv_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + wmv, None, headers)
wmv_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Video (.wmv) found: ' + target_url + wmv.split('"')[0])
size = len(wmv_file)
wmvs[wmv] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_wmv = self.c_wmv + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Video -> [Discarding!]')
size = 0
biggest_wmv = max(list(wmvs.keys()), key=lambda x: wmvs[x]) # search/extract biggest video (.wmv) value from dict
if biggest_wmv:
biggest_files[biggest_wmv] = wmvs[biggest_wmv] # add biggest video (.wmv) to list
except: # if not any .wmv found, go for next
pass
try: # search for .css files
regex_css = []
regex_css1 = "href='(.+?.css[^']*)'" # search on target's results using regex with simple quotation
regex_css.append(regex_css1)
regex_css2 = 'href="(.+?.css[^"]*)"' # search on target's results using regex with double quotation
regex_css.append(regex_css2)
#regex_css3 = "href=(.+?.css[^']*)" # search on target's results using regex without quotations
#regex_css.append(regex_css3)
for regcss in regex_css:
pattern_css = re.compile(regcss)
css_links = re.findall(pattern_css, target_reply)
csss = {}
for css in css_links:
try:
if css.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
if css.startswith("//"):
size = 0
elif "http://" in css or "https://" in css:
size = 0
else:
if css.startswith('/'):
css = css.replace("/", "", 1)
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + css, None, headers)
css_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + css, None, headers)
css_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Style (.css) found: ' + target_url + css.split('"')[0])
size = len(css_file)
csss[css] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_css = self.c_css + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Style -> [Discarding!]')
size = 0
biggest_css = max(list(csss.keys()), key=lambda x: csss[x]) # search/extract biggest style (.css) value from dict
if biggest_css:
biggest_files[biggest_css] = csss[biggest_css] # add biggest style (.css) to list
except: # if not any .css found, go for next
pass
try: # search for .js files
regex_js = []
regex_js1 = "src='(.+?.js[^']*)'" # search on target's results using regex with simple quotation
regex_js.append(regex_js1)
regex_js2 = 'src="(.+?.js[^"]*)"' # search on target's results using regex with double quotation
regex_js.append(regex_js2)
#regex_js3 = "src=(.+?.js[^']*)" # search on target's results using regex without quotations
#regex_js.append(regex_js3)
for regjs in regex_js:
pattern_js = re.compile(regjs)
js_links = re.findall(pattern_js, target_reply)
jss = {}
for js in js_links:
try:
if js.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
if js.startswith("//"):
size = 0
elif "http://" in js or "https://" in js:
size = 0
else:
if js.startswith('/'):
js = js.replace("/", "", 1)
print('+Script (.js) found: ' + target_url + js.split('"')[0])
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + js, None, headers)
js_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + js, None, headers)
js_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
size = len(js_file)
jss[js] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_js = self.c_js + 1
print('-'*12)
except:
print('[Error] [AI] Unable to retrieve info from Script -> [Discarding!]')
size = 0
biggest_js = max(list(jss.keys()), key=lambda x: jss[x]) # search/extract biggest script (.js) value from dict
if biggest_js:
biggest_files[biggest_js] = jss[biggest_js] # add biggest script (.js) to list
except: # if not any .js found, go for next
pass
try: # search for .xml files
regex_xml = []
regex_xml1 = "href='(.+?.xml)'" # search on target's results using regex with simple quotation
regex_xml.append(regex_xml1)
regex_xml2 = 'href="(.+?.xml)"' # search on target's results using regex with double quotation
regex_xml.append(regex_xml2)
#regex_xml3 = 'href=(.+?.xml)' # search on target's results using regex without quotations
#regex_xml.append(regex_xml3)
for regxml in regex_xml:
pattern_xml = re.compile(regxml)
xml_links = re.findall(pattern_xml, target_reply)
xmls = {}
for xml in xml_links:
try:
if xml.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + xml, None, headers)
xml_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + xml, None, headers)
xml_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Script (.xml) found: ' + target_url + xml).split('"')[0]
size = len(xml_file)
xmls[xml] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_xml = self.c_xml + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Script -> [Discarding!]')
size = 0
biggest_xml = max(list(xmls.keys()), key=lambda x: xmls[x]) # search/extract biggest script (.xml) value from dict
if biggest_xml:
biggest_files[biggest_xml] = xmls[biggest_xml] # add biggest script (.xml) to list
except: # if not any .xml found, go for next
pass
try: # search for .php files
regex_php = []
regex_php1 = "href='(.+?.php)'" # search on target's results using regex with simple quotation
regex_php.append(regex_php1)
regex_php2 = 'href="(.+?.php)"' # search on target's results using regex with double quotation
regex_php.append(regex_php2)
#regex_php3 = 'href=(.+?.php)' # search on target's results using regex without quotations
#regex_php.append(regex_php3)
for regphp in regex_php:
pattern_php = re.compile(regphp)
php_links = re.findall(pattern_php, target_reply)
phps = {}
for php in php_links:
try:
if php.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + php, None, headers)
php_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + php, None, headers)
php_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Webpage (.php) found: ' + target_url + php.split('"')[0])
size = len(php_file)
phps[php] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_php = self.c_php + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Webpage -> [Discarding!]')
size = 0
biggest_php = max(list(phps.keys()), key=lambda x: phps[x]) # search/extract biggest file (.php) value from dict
if biggest_php:
biggest_files[biggest_php] = phps[biggest_php] # add biggest file (.php) to list
except: # if not any .php found, go for next
pass
try: # search for .html files
regex_html = []
regex_html1 = "href='(.+?.html)'" # search on target's results using regex with simple quotation
regex_html.append(regex_html1)
regex_html2 = 'href="(.+?.html)"' # search on target's results using regex with double quotation
regex_html.append(regex_html2)
#regex_html3 = 'href=(.+?.html)' # search on target's results using regex without quotations
#regex_html.append(regex_html3)
for reghtml in regex_html:
pattern_html = re.compile(reghtml)
html_links = re.findall(pattern_html, target_reply)
htmls = {}
for html in html_links:
try:
if html.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + html, None, headers)
html_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + html, None, headers)
html_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Webpage (.html) found: ' + target_url + html.split('"')[0])
size = len(html_file)
htmls[html] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_html = self.c_html + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Webpage -> [Discarding!]')
size = 0
biggest_html = max(list(htmls.keys()), key=lambda x: htmls[x]) # search/extract biggest file (.html) value from dict
if biggest_html:
biggest_files[biggest_html] = htmls[biggest_html] # add biggest file (.html) to list
except: # if not any .html found, go for next
pass
try: # search for .jsp files
regex_jsp = []
regex_jsp1 = "href='(.+?.jsp)'" # search on target's results using regex with simple quotation
regex_jsp.append(regex_jsp1)
regex_jsp2 = 'href="(.+?.jsp)"' # search on target's results using regex with double quotation
regex_jsp.append(regex_jsp2)
#regex_jsp3 = 'href=(.+?.jsp)' # search on target's results using regex without quotations
#regex_jsp.append(regex_jsp3)
for regjsp in regex_jsp:
pattern_jsp = re.compile(regjsp)
jsp_links = re.findall(pattern_jsp, target_reply)
jsps = {}
for jsp in jsp_links:
try:
if jsp.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + jsp, None, headers)
jsp_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + jsp, None, headers)
jsp_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Webpage (.jsp) found: ' + target_url + jsp.split('"')[0])
size = len(jsp_file)
jsps[jsp] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_jsp = self.c_jsp + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Webpage -> [Discarding!]')
size = 0
biggest_jsp = max(list(jsps.keys()), key=lambda x: jsps[x]) # search/extract biggest file (.jsp) value from dict
if biggest_jsp:
biggest_files[biggest_jsp] = jsps[biggest_jsp] # add biggest file (.jsp) to list
except: # if not any .jsp found, go for next
pass
try: # search for .asp files
regex_asp = []
regex_asp1 = "href='(.+?.asp)'" # search on target's results using regex with simple quotation
regex_asp.append(regex_asp1)
regex_asp2 = 'href="(.+?.asp)"' # search on target's results using regex with double quotation
regex_asp.append(regex_asp2)
#regex_asp3 = 'href=(.+?.asp)' # search on target's results using regex without quotations
#regex_asp.append(regex_asp3)
for regasp in regex_asp:
pattern_asp = re.compile(regasp)
asp_links = re.findall(pattern_asp, target_reply)
asps = {}
for asp in asp_links:
try:
if asp.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + asp, None, headers)
asp_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + asp, None, headers)
asp_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+Webpage (.asp) found: ' + target_url + asp.split('"')[0])
size = len(asp_file)
asps[asp] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_asp = self.c_asp + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Webpage -> [Discarding!]')
size = 0
biggest_asp = max(list(asps.keys()), key=lambda x: asps[x]) # search/extract biggest file (.asp) value from dict
if biggest_asp:
biggest_files[biggest_asp] = asps[biggest_asp] # add biggest file (.asp) to list
except: # if not any .asp found, go for next
pass
try: # search for .txt files
regex_txt = []
regex_txt1 = "href='(.+?.txt)'" # search on target's results using regex with simple quotation
regex_txt.append(regex_txt1)
regex_txt2 = 'href="(.+?.txt)"' # search on target's results using regex with double quotation
regex_txt.append(regex_txt2)
#regex_txt3 = 'href=(.+?.txt)' # search on target's results using regex without quotations
#regex_txt.append(regex_txt3)
for regtxt in regex_txt:
pattern_txt = re.compile(regtxt)
txt_links = re.findall(pattern_txt, target_reply)
txts = {}
for txt in txt_links:
try:
if txt.startswith('http'):
size = 0
else:
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
try:
if self.ufonet.options.proxy: # set proxy
self.proxy_transport(self.ufonet.options.proxy)
req = urllib.request.Request(target_url + txt, None, headers)
txt_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
else:
req = urllib.request.Request(target_url + txt, None, headers)
txt_file = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
print('+File (.txt) found: ' + target_url + txt.split('"')[0])
size = len(txt_file)
txts[txt] = int(size)
print('(Size: ' + str(size) + ' Bytes)')
self.c_txt = self.c_txt + 1
print('-'*12)
except:
size = 0
except:
print('[Error] [AI] Unable to retrieve info from Text file -> [Discarding!]')
size = 0
biggest_txt = max(list(txts.keys()), key=lambda x: txts[x]) # search/extract biggest file (.txt) value from dict
if biggest_text:
biggest_files[biggest_txt] = txts[biggest_txt] # add biggest file (.txt) to list
except: # if not any .txt found, go for next
pass
print("\n" +'='*80)
total_objects = self.c_images + self.c_mov + self.c_webm + self.c_avi + self.c_swf + self.c_mpg + self.c_mpeg + self.c_mp3 + self.c_ogg + self.c_ogv + self.c_wmv + self.c_css + self.c_js + self.c_xml + self.c_php + self.c_html + self.c_jsp + self.c_asp + self.c_txt
print("Total objects found:", total_objects)
print('-'*20)
print("images:", self.c_images)
print(".mov :", self.c_mov)
print(".jsp :", self.c_jsp)
print(".avi :", self.c_avi)
print(".html :", self.c_html)
print(".mpg :", self.c_mpg)
print(".asp :", self.c_asp)
print(".mp3 :", self.c_mp3)
print(".js :", self.c_js)
print(".ogv :", self.c_ogv)
print(".wmv :", self.c_wmv)
print(".css :", self.c_css)
print(".mpeg :", self.c_mpeg)
print(".xml :", self.c_xml)
print(".php :", self.c_php)
print(".txt :", self.c_txt)
print(".webm :", self.c_webm)
print(".ogg :", self.c_ogg)
print(".swf :", self.c_swf)
print('-'*20)
print('='*80)
if(biggest_files=={}):
print("\n[Info] [AI] Not any link found on target! -> [Exiting!]\n\n")
print('='*80 + '\n')
return
biggest_file_on_target = max(list(biggest_files.keys()), key=lambda x: biggest_files[x]) # search/extract biggest file value from dict
target_host = urlparse(target)
target_url = target_host.scheme + "://" + target_host.netloc + target_host.path
if biggest_file_on_target.startswith('http'): # used for absolute links
for url,size in list(biggest_files.items()): # review all dict values
if url.startswith('http'):
if not target_url in url: # extract/dismiss external links
del biggest_files[url] # remove value from dict
biggest_file_on_target = max(list(biggest_files.keys()), key=lambda x: biggest_files[x]) # extract new value
print('=Biggest File: ' + biggest_file_on_target)
else: # used for relative links
if not target_url.endswith('/'): # add "/" to end of target
target_url = target_url + "/"
print('=Biggest File: ' + target_url + biggest_file_on_target)
print('='*80 + '\n')