def atom(self, host):
import bsd
import linux
import mac
import solaris
import unix
import windows
import urllib
from core.urli import sansor
host = sansor().fransor(host)
hostp = sansor().pransor(host)
if sansor().cransor(hostp):
header = urllib.urlopen(host).headers
final = []
bsd = bsd.Bsd().run(header)
lnx = linux.Linux().run(header)
mac = mac.Mac().run(header)
slr = solaris.Solaris().run(header)
unx = unix.Unix().run(header)
win = windows.Windows().run(header)
eve = [bsd, lnx, mac, slr, unx, win]
for key in eve:
if key:
final.append(key)
if final == []:
final.append('none')
return final
else:
return None
def atom(self, host):
import drupal
import joomla
import wordpress
import magento
import concrete5
import bolt
import typo3
import vbulletin
import urllib
from core.urli import sansor
host = sansor().fransor(host)
hostp = sansor().pransor(host)
if sansor().cransor(hostp):
cont = urllib.urlopen(host).read()
final = []
drp = drupal.Drupal().run(cont)
jml = joomla.Joomla().run(cont)
wps = wordpress.Wordpress().run(cont)
mgt = magento.Magento().run(cont)
cr5 = concrete5.Concrete5().run(cont)
blt = bolt.Bolt().run(cont)
tp3 = typo3.Typo3().run(cont)
vbn = vbulletin.Vbulletin().run(cont)
eve = [drp, jml, wps, mgt, cr5, blt, tp3, vbn]
for key in eve:
if key:
final.append(key)
if final == []:
final.append('none')
return final
else:
return None
def atom(self, host):
import cakephp
import cherrypy
import django
import flask
import fuelphp
import grails
import larvel
import mvc
import nette
import phalcon
import rails
import symfony
import yii
import zend
import googleanalytics
import jquery
import urllib
from core.urli import sansor
host = sansor().fransor(host)
hostp = sansor().pransor(host)
if sansor().cransor(hostp):
header = urllib.urlopen(host).headers
cont = urllib.urlopen(host).read()
final = []
ckp = cakephp.Cakephp().run(header)
cpy = cherrypy.Cherrypy().run(header)
djo = django.Django().run(header)
fls = flask.Flask().run(header)
flp = fuelphp.Fuelphp().run(header, cont)
grl = grails.Grails().run(header)
lrv = larvel.Larvel().run(header)
mvc = mvc.Mvc().run(header)
nte = nette.Nette().run(header)
pcn = phalcon.Phalcon().run(header)
rls = rails.Rails().run(header)
sfy = symfony.Symfony().run(header)
yii = yii.Yii().run(header, cont)
znd = zend.Zend().run(header)
gas = googleanalytics.Googleanalytics().run(cont)
jqr = jquery.Jquery().run(cont)
eve = [
ckp, cpy, djo, fls, flp, grl, lrv, mvc, nte, pcn, rls, sfy,
yii, znd, gas, jqr
]
for key in eve:
if key:
final.append(key)
if final == []:
final.append('none')
return final
else:
return None
def atom(self, host):
import urllib
import header
from core.urli import sansor
host = sansor().pransor(host)
if sansor().cransor(host):
content = urllib.urlopen('http://' + host).headers
header = header.Headers.run(content)
return header
else:
return None
def atom(self, host):
import urllib
from core.urli import sansor
host = sansor().pransor(host)
if sansor().cransor(host) and sansor().cransor(
'api.hackertarget.com/dnslookup'):
wread = urllib.urlopen(
'https://api.hackertarget.com/dnslookup/?q=' + host).read()
return wread
else:
return None
def atom(self, host):
import bingMailClass
from core.urli import sansor
host = sansor().pransor(host)
if sansor().cransor(host):
s = bingMailClass.bingMailClass(host)
s.explore()
emails = s.emails()
return emails
else:
return None
def atom(self, host):
import urllib
from bs4 import BeautifulSoup
from core.urli import sansor
host = sansor().pransor(host)
if sansor().cransor(host) and sansor().cransor('viewdns.info'):
wread = urllib.urlopen('http://www.viewdns.info/reversens/?ns=' +
host).read()
content = BeautifulSoup(wread, 'html.parser').find('table',
border='1')
return content
else:
return None
def atom(self, host):
import urllib
from bs4 import BeautifulSoup
from core.urli import sansor
host = sansor().pransor(host)
if sansor().cransor(host) and sansor().cransor('viewdns.info'):
wread = urllib.urlopen('http://www.viewdns.info/whois/?domain=' +
host).read()
content = BeautifulSoup(wread, 'html.parser').find('font',
face='Courier')
return content
else:
return None
def atom(self, host, fname):
import urllib
from core.urli import sansor
host = sansor().pransor(host)
if sansor().cransor(host) and sansor().cransor('dnsdumpster.com'):
try:
content = urllib.urlretrieve(
'https://dnsdumpster.com/static/map/' + host + '.png',
fname)
return True
except BaseException:
return "\tUnfortunately, the file could not be saved"
else:
return None
def atom(self, host):
import yahooHostClass
import re
from core.urli import sansor
from socket import gethostbyname
host = sansor().pransor(host)
if sansor().cransor(host):
s = yahooHostClass.yahooHostClass(str(host).replace('.', '\.'))
s.explore()
hosts = s.hosts()
return hosts
else:
return None
def atom(self, host):
import master
from core.urli import sansor
host = sansor().pransor(host)
if sansor().cransor(host):
cloudflare = master.dns_explore.cloud_flare().atom(host)
extractlinks = master.dns_explore.extract_links().atom(host)
whoisip = master.whois_ip.whois_ip().atom(host)
cms = master.foot_printing.cms.cms().atom(host)
os = master.foot_printing.os.os().atom(host)
framework = master.foot_printing.framework.framework().atom(host)
language = master.foot_printing.language.language().atom(host)
waf = master.foot_printing.waf.waf().atom(host)
httpheader = master.foot_printing.httpheader.httpheader().atom(host)
allmail = master.search_engine.all_mail().atom(host)
allhost = master.search_engine.all_host().atom(host)
robotstxt = master.panel_brute.robots_txt().atom(host)
cloudflare = 'cloudflare or dns : {' + self.clean(
cloudflare) + ' } <br><br>'
extractlinks = 'all links page : {' + self.clean(
extractlinks) + ' } <br><br>'
whoisip = 'information ip : {' + \
self.clean(whoisip) + ' } <br><br>'
allmail = 'all emails : {' + self.clean(allmail) + ' } <br><br>'
allhost = 'all subdomain : {' + self.clean(allhost) + ' } <br><br>'
robotstxt = 'robots.txt : {' + \
self.clean(robotstxt) + ' } <br><br>'
cms = 'foot printing : {<br>cms this web is ' + self.clean(
cms) + '<br>'
os = 'os this web is ' + self.clean(os) + '<br> '
language = 'language this web is ' + \
self.clean(language) + '<br>framework : '
framework = self.clean(framework) + '<br>waf : '
waf = self.clean(waf) + '<br>'
httpheader = self.clean(httpheader) + ' }<br><br>'
result = {'cloud_flare': cloudflare, 'extract_links': extractlinks,
'whois_ip': whoisip, 'cms': cms,
'os': os, 'framework': framework, 'language': language,
'waf': waf, 'httpheader': httpheader, 'allmail': allmail,
'allhost': allhost, 'robots_txt': robotstxt
}
return result
else:
return None
def atom(self, host):
import urllib
from bs4 import BeautifulSoup
from core.urli import sansor
host = sansor().pransor(host)
if sansor().cransor(host) and sansor().cransor('viewdns.info'):
wread = urllib.urlopen(
'http://www.viewdns.info/iphistory/?domain=' + host).read()
content = BeautifulSoup(
wread, 'html.parser').find(
'font', face='Courier')
content = str(content).replace('''<script class="stripe-button" data-amount="19900" data-currency="usd" data-description="Full report for 'google.com'" data-image="/images/ok.GIF" data-key="pk_live_ey9TT0KvaFQoLWRyDYg9oqQd" data-label="Download The Full Report for $199" data-name="" src="https://checkout.stripe.com/checkout.js"></script>''', '')
return content
else:
return None
def atom(self, host):
import urllib
from core.urli import sansor
import re
host = sansor().pransor(host)
if sansor().cransor(host):
wread = urllib.urlopen('http://' + host).read()
search = re.compile(host + r'/[\w\/\-.\?=%]+')
content = search.findall(wread)
if content == []:
content.append('none')
return content
else:
return None
def atom(self, host):
import requests
from core.urli import sansor
from socket import gethostbyname
host = sansor().pransor(host)
if sansor().cransor(host) and sansor().cransor('ipapi.co'):
url = gethostbyname(host)
ipapi = 'https://ipapi.co/' + url + '/json'
usage = {'user-agent': 'ipapi/ipapi-python/0.5.1'}
rqs = requests.get(ipapi, headers=usage).json()
return rqs
else:
return None
def atom(self, host):
import urllib
from core.urli import sansor
from socket import gethostbyname
def check(host):
try:
return urllib.urlopen('http://' + str(host)).code
except BaseException:
return None
subs = [
'news.', 'download.', '', 'cpanel.', 'ftp.', 'email.', 'server1.',
'cdn.', 'cdn2.', 'ns.', 'ns1.', 'mail.', 'webmail.', 'direct.',
'direct-connect.', 'record.', 'ssl.', 'dns.', 'help.', 'blog.',
'irc.', 'forum.', 'admin.', 'server.', 'client.', 'shop.',
'panel.', 'android.', 'dld.', 'adm.', 'map.', 'file.', 'dll.',
'login.', 'ns1.', 'ns2.', 'ns3.', 'ns4.', 'ns5.', 'ns6.', 'ns7.',
'ns8.', 'ns9.', "admins.", "user.", "users.", "files.", "upload."
]
host = sansor().pransor(host)
if sansor().cransor(host):
ret = []
def psend(host, sub):
host = sub + host
send = check(host)
if send == 200:
ip = gethostbyname(host)
return host + ' : ' + str(ip)
for sub in subs:
recv = psend(host, sub)
if recv:
ret.append(recv)
if ret != []:
return ret
else:
return ['none']
else:
return None
def atom(self, host):
import bingHostClass
import googleHostClass
import yahooHostClass
from core.urli import sansor
sans = sansor()
host = sans.pransor(host)
if sans.cransor(host):
this = []
host = str(host).replace('.', '\.')
a = bingHostClass.bingHostClass(host)
a.explore()
hosts1 = a.hosts()
b = googleHostClass.googleHostClass(host)
b.explore()
hosts2 = b.hosts()
c = yahooHostClass.yahooHostClass(host)
c.explore()
hosts3 = c.hosts()
for hs1 in hosts1:
if hs1 not in this:
this.append(hs1)
for hs2 in hosts2:
if hs2 not in this:
this.append(hs2)
for hs3 in hosts3:
if hs3 not in this:
this.append(hs3)
return this
else:
return None
def atom(self, host):
import bingMailClass
import googleMailClass
import yahooMailClass
from core.urli import sansor
sans = sansor()
host = sans.pransor(host)
if sans.cransor(host):
this = []
a = bingMailClass.bingMailClass(host)
a.explore()
emails1 = a.emails()
b = googleMailClass.googleMailClass(host)
b.explore()
emails2 = b.emails()
c = yahooMailClass.yahooMailClass(host)
c.explore()
emails3 = c.emails()
for em1 in emails1:
if em1 not in this:
this.append(em1)
for em2 in emails2:
if em2 not in this:
this.append(em2)
for em3 in emails3:
if em3 not in this:
this.append(em3)
return this
else:
return None
def atom(self, host, tag):
from urllib import urlopen, unquote
from bs4 import BeautifulSoup
from core.urli import sansor
def _reading(html, tag):
soup = BeautifulSoup(html, 'html.parser').find_all(tag)
if soup == []:
soup.append('none')
else:
return soup
def _script(html):
soup = BeautifulSoup(html, 'html.parser').find_all('script',
src=True)
if soup == []:
soup.append('none')
else:
script = []
for link in soup:
link = link.get('src')
script.append(unquote(link))
return script
def _link(html):
soup = BeautifulSoup(html, 'html.parser').find_all('link',
href=True)
if soup == []:
soup.append('none')
else:
link = []
for key in soup:
key = key.get('href')
link.append(unquote(key))
return link
def _img(html):
soup = BeautifulSoup(html, 'html.parser').find_all('img', src=True)
if soup == []:
soup.append('none')
else:
img = []
for key in soup:
key = key.get('src')
img.append(unquote(key))
return img
host = sansor().pransor(host)
if sansor().cransor(host):
html = urlopen('http://' + host).read()
if tag == 'img':
wread = _img(html)
elif tag == 'link':
wread = _link(html)
elif tag == 'script':
wread = _script(html)
else:
wread = _reading(html, tag)
return wread
else:
return None
def atom(self, host):
import airlock
import anquanboa
import aws
import baidu
import barracuda
import bigip
import binarysec
import blockdos
import chinacache
import ciscoacexml
import cloudflare
import cloudfront
import denyall
import dotdefender
import expressionengine
import edgecast
import fortiweb
import hyperguard
import incapsula
import isaserver
import jiasule
import knownsec
import kona
import modsecurity
import netcontinuum
import paloalto
import profense
import radware
import requestvalidationmode
import safedog
import secureiis
import senginx
import sitelock
import sonicwall
import sucuri
import teros
import trafficshield
import urlscan
import uspses
import varnish
import wallarm
import webknight
import urllib
from core.urli import sansor
host = sansor().fransor(host)
hostp = sansor().pransor(host)
if sansor().cransor(hostp):
target = urllib.urlopen(host)
header = target.headers
cont = target.read()
code = target.code
final = []
air = airlock.Airlock().run(header)
anq = anquanboa.Anquanboa().run(header)
aws = aws.Aws().run(header)
bid = baidu.Baidu().run(header)
brc = barracuda.Barracuda().run(header)
bgp = bigip.Bigip().run(header)
brs = binarysec.Binarysec().run(header)
bkd = blockdos.Blockdos().run(header)
chi = chinacache.Chinacache().run(header)
cix = ciscoacexml.Ciscoacexml().run(header)
cdl = cloudflare.Cloudflare().run(header)
cdr = cloudfront.Cloudfront().run(header)
dna = denyall.Denyall().run(cont, code, header)
dfn = dotdefender.Dotdefender().run(header)
exp = expressionengine.Expressionengine().run(cont)
edg = edgecast.Edgecast().run(header)
fwb = fortiweb.Fortiweb().run(header)
hpg = hyperguard.Hyperguard().run(header)
ics = incapsula.Incapsula().run(header)
isv = isaserver.Isaserver().run(cont)
jsl = jiasule.Jiasule().run(cont, header)
kns = knownsec.Knownsec().run(cont)
kna = kona.Kona().run(cont, code)
msc = modsecurity.Modsecurity().run(header)
ncm = netcontinuum.Netcontinuum().run(header)
pto = paloalto.Paloalto().run(header)
pfs = profense.Profense().run(header)
rdw = radware.Radware().run(header)
rvm = requestvalidationmode.Requestvalidationmode().run(cont)
sfd = safedog.Safedog().run(header)
sci = secureiis.Secureiis().run(cont)
snx = senginx.Senginx().run(cont)
slk = sitelock.Sitelock().run(cont)
swl = sonicwall.Sonicwall().run(cont)
scr = sucuri.Sucuri().run(header)
trs = teros.Teros().run(header)
tfs = trafficshield.Trafficshield().run(header)
usc = urlscan.Urlscan().run(header)
usp = uspses.Uspses().run(header)
vns = varnish.Varnish().run(header)
wlm = wallarm.Wallarm().run(header)
wkt = webknight.Webknight().run(header)
eve = [
air, anq, aws, bid, brc, bgp, brs, bkd, chi, cix, cdl, cdr,
dfn, dna, exp, edg, fwb, hpg, ics, isv, jsl, kns, kna, msc,
ncm, pto, pfs, rdw, rvm, sfd, sci, snx, slk, swl, scr, trs,
tfs, usc, usp, vns, wlm, wkt
]
for key in eve:
if key:
final.append(key)
if final == []:
final.append('none')
return final
else:
return None
