def app_lookup(url):
# input validation
if not isinstance(url, (str, unicode)):
abort(400)
# resolve entries
active = get_active()
if not active or not active['mtime']:
abort(503)
try:
sbl = SafeBrowsingList(gsb_api_key, active['name'], True)
resp = sbl.lookup_url(url)
except:
app.logger.exception("exception handling [" + url + "]")
abort(500)
else:
if resp:
matches = [{
'threat': x.threat_type,
'platform': x.platform_type,
'threat_entry': x.threat_entry_type
} for x in resp]
return jsonify({'url': url, 'matches': matches})
else:
abort(404)
def main():
key = sys.argv[1]
db = "../gsb_v4.db"
platforms = ["WINDOWS"]
sbl = SafeBrowsingList(key, db_path=db, platforms=platforms)
#sbl.update_hash_prefix_cache()
print(sbl.storage.get_threat_lists())
url = sys.argv[2]
u = URL(url)
print(u.url)
print(u.canonical)
for i in u.url_permutations(u.canonical):
print(i)
print(u.digest(i))
url_hashes = u.hashes
print(url_hashes)
full_hashes = list(url_hashes)
print(full_hashes)
cues = [to_hex(fh[0:4]) for fh in full_hashes]
print(cues)
print(sbl.storage.lookup_hash_prefix(cues))
bl = sbl.lookup_url(url)
print(bl)
def main():
sbl = SafeBrowsingList(config.gsb_key, db_path=config.gsb_db_path)
#result = sbl.lookup_url('http://www.amazon.esp.bravaidea.com/AWS/mobil/signin.php?https://www.amazon.com/gp/product/B00DBYBNEE/ref=nav_prime_try_btn')
#print(result)
dbo = db_operations.DBOperator()
while True:
slds = dbo.get_gsb_queryable_slds()
urls = dbo.get_gsb_queryable_urls()
domain_urls = slds+urls
print(len(domain_urls))
query_time = datetime.now()
print ("GSB Update time:", str(query_time))
run_sync(sbl)
print ("Got updated GSB list. Now looking up %s domains: %s" % (
len(domain_urls), str(datetime.now())))
for d in domain_urls:
print(d)
try:
result = sbl.lookup_url(d)
print(result)
result = "%s" % (result,)
dbo.update_gsb_table(d, result, query_time)
except Exception as e:
print ("Exception. Skipping this domain: ", d, e)
#print result
print ("Done inserting into DB. Will update GSB list again", str(datetime.now()))
time.sleep(3600)
def main():
total_attacks = 0
sbl = SafeBrowsingList(gsb_key, db_path=gsb_db_path)
all_home_domains = set()
counted_hashes = set()
for name, labels in se_categories.iteritems():
camp_domains = set()
camp_gsb_clusters = 0
camp_total_count = 0
home_domains_campaign_set = set()
for label in labels:
cluster_gsb = False
cluster_domains = set()
ad_objs = get_ad_objects(str(label))
# camp_total_count += len(ad_objs)
for ad_obj in ad_objs:
domain = extractor(ad_obj.ad_url).registered_domain
e = extractor(ad_obj.ad_url)
land_fqd = '.'.join(part for part in e if part)
# home_domain = extractor(ad_obj.home_url).registered_domain
e = extractor(seed_domain_data[ad_obj.log_id][0])
home_domain = '.'.join(part for part in e if part)
# camp_domains.add(domain)
if ad_obj.screenshot_hash in image_domain_dict:
# if domain in all_land_tlds:
if ad_obj.screenshot_hash not in counted_hashes:
mal_ad_hashes.add(ad_obj.screenshot_hash)
camp_total_count += image_hash_count[ad_obj.screenshot_hash]
counted_hashes.add(ad_obj.screenshot_hash)
# home_domains_campaign_set = home_domains_campaign_set.union(image_home_domain_dict[ad_obj.screenshot_hash])
home_domains_campaign_set = home_domains_campaign_set.union(image_seed_domain_dict[ad_obj.screenshot_hash])
camp_domains = camp_domains.union(image_domain_dict[ad_obj.screenshot_hash])
cluster_domains = cluster_domains.union(image_domain_dict[ad_obj.screenshot_hash])
# all_home_domains = all_home_domains.union(image_home_domain_dict[ad_obj.screenshot_hash])
all_home_domains = all_home_domains.union(image_seed_domain_dict[ad_obj.screenshot_hash])
else:
print "!!Not here!!"
camp_domains.add(land_fqd)
cluster_domains.add(land_fqd)
camp_total_count += 1
# import ipdb; ipdb.set_trace()
all_home_domains.add(home_domain)
for domain in cluster_domains:
if not domain:
continue
# print "domain:", domain
result = sbl.lookup_url(domain.strip())
if result:
cluster_gsb = True
if cluster_gsb:
camp_gsb_clusters += 1
# print result
print name, '\t&', camp_total_count, '\t&', len(camp_domains), '\t&', len(labels), '\t&', camp_gsb_clusters, '\\\\'
print len(home_domains_campaign_set)
total_attacks += camp_total_count
print "# of mal ad hashes:", len(mal_ad_hashes)
print "# of unique publisher domains associated with SE ads:", len(all_home_domains)
print "# of total SE attacks:", total_attacks
# get_category_stats(all_home_domains)
get_popularity_stats(all_home_domains)
def safebrowsingcheck(url):
from gglsbl import SafeBrowsingList
sbl = SafeBrowsingList('')
if sbl.lookup_url(url) is None:
return ':D Not in blacklist'
else:
return '@@ In the blacklist'
def google_sb_check(url):
import ConfigParser
config_file = "conf/parser.cfg"
config = ConfigParser.RawConfigParser()
config.read(config_file)
apikey = config.get('url', 'gsb_api_key')
from gglsbl import SafeBrowsingList
sbl = SafeBrowsingList(apikey)
if sbl.lookup_url(url) is None:
return 'URL is not in the blacklist.'
else:
return '@@ URL is in the blacklist.'
class SafeBrowsing(object):
TYPE = "GoogleSBCheck"
CP_FMT = '{scheme}://{netloc}/{path}'
def __init__(self,
name=None,
api_key=None,
db_path='/tmp/gsb_4.db',
update_hash_prefix_cache=False):
self.api_key = api_key
self.db_path = db_path
self.sbl = SafeBrowsingList(api_key, db_path=db_path)
self.update_hash_prefix_cache = update_hash_prefix_cache
try:
os.stat(db_path)
except:
self.update_hash_prefix_cache = True
if self.update_hash_prefix_cache:
# this may take a while so be patient (over 1600MB of data)
self.sbl.update_hash_prefix_cache()
def is_blacklisted(self, url):
return not SafeBrowsing.thread_safe_lookup(url) is None
def lookup_url(self, url):
up = urlparse(url)
cp = self.CP_FMT.format(**{
'scheme': up.scheme,
'netloc': up.netloc,
'path': up.path
}).strip('/') + '/'
return self.sbl.lookup_url(cp)
def handle_domain(self, domain):
return self.handle_domains([
domain,
])
def handle_domains(self, domains):
results = {}
for domain in domains:
t = "https://" + domain
u = "http://" + domain
results[domain] = False
if self.lookup_url(t) or self.lookup_url(u):
results[domain] = True
continue
return results
def _lookup(url, api_key, retry=1):
# perform lookup
global sbl, last_api_key
try:
if api_key != last_api_key:
app.logger.info('re-opening database')
sbl = SafeBrowsingList(api_key, dbfile, True)
last_api_key = api_key
return sbl.lookup_url(url)
except:
app.logger.exception("exception handling [" + url + "]")
if retry >= max_retries:
sbl = None
last_api_key = None
abort(500)
else:
return _lookup(url, api_key, retry + 1)
class SafeBrowsing(object):
def __init__(self,
api_key,
db_path=LINUX_DFT_PATH,
update_hash_prefix_cache=False):
global API_KEY, DB_PATH
API_KEY = api_key
DB_PATH = db_path
self.sbl = SafeBrowsingList(api_key, db_path=db_path)
self.update_hash_prefix_cache = update_hash_prefix_cache
try:
os.stat(db_path)
except:
self.update_hash_prefix_cache = True
if self.update_hash_prefix_cache:
# this may take a while so be patient (over 1600MB of data)
self.sbl.update_hash_prefix_cache()
def is_blacklisted(self, url):
return not SafeBrowsing.thread_safe_lookup(url) is None
def lookup_url(self, url):
# cp_fmt = '{scheme}://{netloc}/{path}'
# up = URLPARSE(url)
# cp = cp_fmt.format(**{'scheme':up.scheme, 'netloc':up.netloc, 'path':up.path}).strip('/')+'/'
return self.sbl.lookup_url(url)
@classmethod
def init(cls, api_key):
return SafeBrowsing(api_key)
@staticmethod
def set_global(api_key, db_path='/tmp/gsb_4.db'):
global SB_CHECK, API_KEY, DB_PATH
API_KEY = api_key, db_path
SB_CHECK = SafeBrowsing(api_key, db_path=db_path)
@staticmethod
def thread_safe_lookup(url):
global SB_CHECK
sbl = SafeBrowsing(API_KEY, db_path=DB_PATH)
return sbl.lookup_url(url)
def main():
args_parser = setupArgsParser()
args = args_parser.parse_args()
setupLogger(args.log, args.debug)
storage_backend = None
storage_config = None
if args.mysql_db:
storage_config = {
'user': args.mysql_user,
'password': args.mysql_password,
'host': args.mysql_host,
'database': args.mysql_db
}
storage_backend = SafeBrowsingList.STORAGE_BACKEND_MYSQL
if args.check_url:
sbl = SafeBrowsingList(args.api_key,
db_path=args.db_path,
timeout=args.timeout,
storage_backend=storage_backend,
storage_config=storage_config)
bl = sbl.lookup_url(args.check_url)
if bl is None:
print('{} is not blacklisted'.format(args.check_url))
else:
print('{} is blacklisted in {}'.format(args.check_url, bl))
sys.exit(args.blacklisted_return_code)
sys.exit(0)
if args.onetime:
sbl = SafeBrowsingList(args.api_key,
db_path=args.db_path,
discard_fair_use_policy=True,
timeout=args.timeout,
storage_backend=storage_backend,
storage_config=storage_config)
run_sync(sbl)
else:
sbl = SafeBrowsingList(args.api_key,
db_path=args.db_path,
timeout=args.timeout,
storage_backend=storage_backend,
storage_config=storage_config)
run_sync(sbl)
def main():
args_parser = setupArgsParser()
args = args_parser.parse_args()
setupLogger(args.log, args.debug)
if args.check_url:
sbl = SafeBrowsingList(args.api_key, db_path=args.db_path)
bl = sbl.lookup_url(args.check_url)
if bl is None:
print('{} is not blacklisted'.format(args.check_url))
else:
print('{} is blacklisted in {}'.format(args.check_url, bl))
sys.exit(0)
if args.onetime:
sbl = SafeBrowsingList(args.api_key, db_path=args.db_path, discard_fair_use_policy=True)
run_sync(sbl)
else:
sbl = SafeBrowsingList(args.api_key, db_path=args.db_path)
while True:
run_sync(sbl)
def main():
args_parser = setupArgsParser()
args = args_parser.parse_args()
setupLogger(args.log, args.debug)
if args.check_url:
sbl = SafeBrowsingList(args.api_key, db_path=args.db_path, timeout=args.timeout)
bl = sbl.lookup_url(args.check_url)
if bl is None:
print('{} is not blacklisted'.format(args.check_url))
else:
print('{} is blacklisted in {}'.format(args.check_url, bl))
sys.exit(0)
if args.onetime:
sbl = SafeBrowsingList(args.api_key, db_path=args.db_path, discard_fair_use_policy=True, timeout=args.timeout)
run_sync(sbl)
else:
sbl = SafeBrowsingList(args.api_key, db_path=args.db_path, timeout=args.timeout)
while True:
run_sync(sbl)
def find_blacklisted_domains(urls):
total_count=0
count=0
start_time = time.time()
sbl = SafeBrowsingList('AIzaSyBHPCVVk-tbM0iC93uvulfEFTyBfmKecVA')
#sbl = SafeBrowsingList('AIzaSyCj6PXcG8IuHW3cpVB5dZHVWHb2QnALWSU')
for url in urls:
threat_list = sbl.lookup_url(url)
if threat_list:
count+=1
with open(r'blacklist.txt', 'a') as f:
f.write(url)
total_count+=1
elapsed_time = time.time() - start_time
print("Number of URLS:"+str(total_count))
print("Phishing URLS:"+str(count))
print(time.strftime("%H:%M:%S", time.gmtime(elapsed_time)))
fields=[str(total_count),str(count)]
with open(r'results.csv', 'a') as f:
writer = csv.writer(f)
writer.writerow(fields)
class Security:
def __init__(self):
self.sbl = SafeBrowsingList(GoogleConfig.SAFEBROWSINGAPIKEY)
self.sbl.update_hash_prefix_cache()
pass
def validate_referer(self, url):
threat_list = self.sbl.lookup_url(url)
if threat_list is None:
return None
return threat_list
def get_referer(self):
referer = request.referrer
if not referer:
return None
return referer
@staticmethod
def is_safe_url(url):
ref_url = urlparse(request.host_url)
test_url = urlparse(urljoin(request.host_url, url))
return test_url.scheme in ('http', 'https') and \
ref_url.netloc == test_url.netloc
def scrapper(url):
url = url.strip()
url = "https://www.stuffnice.com/"
url5 = url
if "www" in url:
url = url.replace("www.", "")
print(url)
else:
pass
headers = {
'User-Agent':
'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.76 Safari/537.36',
"Upgrade-Insecure-Requests": "1",
"DNT": "1",
"Accept":
"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.5",
"Accept-Encoding": "gzip, deflate"
}
final_report = []
final_score = 0
from .result_dict import result_dict
domain = tldextract.extract(url).domain
suffix = tldextract.extract(url).suffix
subdomain = tldextract.extract(url).subdomain
pattern = '<a [^>]*href=[\'|"](.*?)[\'"].*?>'
# row 15 HTTPS test
result = {'name': 'https_test', 'message': '', 'marks': ''}
if "https" in url or "http" in url:
print("if worked")
a = url.split(":")
a[0] = "https:"
web = "".join(a)
print("This is web ", web)
try:
print("try of if worked")
r = requests.get(web, headers=headers)
url = web
result[
'message'] = 'Félicitations. Votre site les données transitants par votre site sont sécurisées avec un certificat SSL'
result['marks'] = 4
except:
a = url.split(":")
a[0] = "http:"
url3 = "".join(a)
print("try of except worked")
r = requests.get(url3, headers=headers, verify=False)
url = url3
# req = urllib.request.Request(url, headers=headers)
# r = urllib.request.urlopen(req)
result['message'] = '''
Votre site ne dispose pas de certificat SSL. Les données qui y transitent peuvent donc être récupérés par des parties malveillantes. Google donne une grande importance à la sécurité des visiteurs.
'''
result['marks'] = 0
print("HTTPS didn't worked")
else:
print("else worked")
try:
url2 = 'https://' + url
r = requests.get(url2, headers=headers)
url = url2
# req = urllib.request.Request(url, headers=headers)
# r = urllib.request.urlopen(req)
result[
'message'] = 'Félicitations. Votre site les données transitants par votre site sont sécurisées avec un certificat SSL'
result['marks'] = 4
except:
url1 = 'http://' + url
print("from else except ", url1)
r = requests.get(url1, headers=headers, verify=False)
url = url1
# req = urllib.request.Request(url, headers=headers)
# r = urllib.request.urlopen(req)
result['message'] = '''
Votre site ne dispose pas de certificat SSL. Les données qui y transitent peuvent donc être récupérés par des parties malveillantes. Google donne une grande importance à la sécurité des visiteurs.
'''
result['marks'] = 0
print(result)
result_dict['https_test'] = result
final_score = final_score + result['marks']
soup = BeautifulSoup(r.text, "lxml")
# This is for row 1 (title)
try:
title_content = soup.find('title').text
title_ln = len(title_content)
if title_ln < 70:
result = {
'name': 'title',
'message':
'Félicitations votre site dispose d’un titre avec un nombre de caractères optimale soit moins de 70 caractères',
'title_length': title_ln,
'title_content': title_content,
'marks': 5
}
final_score = final_score + 5
result_dict['title'] = result
elif title_ln > 70:
result = {
'name': 'title',
'message':
'Votre titre est trop long, le nombre de caractères optimal est de 70 caractères, essayez de le raccourcir',
'title_length': title_ln,
'title_content': title_content,
'marks': 2
}
final_score = final_score + 2
result_dict['title'] = result
except:
result = {
'name': 'title',
'message':
'Votre site ne dispose pas de balise meta title. La balise <title> correspond au titre de votre page web. Il s’agit d’un champ essentiel à ne pas négliger dans le cadre d’une bonne stratégie d’optimisation du référencement naturel puisqu’elle est l’un des critères les plus importants pour les moteurs de recherche (Google, Bing...)',
'title_length': 0,
'marks': 0
}
final_score = final_score + 0
result_dict['title'] = result
# This is for row 2 (meta @description)
name = 'meta_description'
length_var_name = 'meta_desc_len'
try:
meta_tag = soup.find("meta", {"name": "description"})
desc_content = meta_tag['content']
#desc_text_ln = len(desc_content)
desc_text_ln = int(desc_text_ln)
if desc_text_ln < 150:
result = {
'name': name,
'message':
'Votre méta-description est trop courte, le nombre de caractère optimale doit être entre 150 et 250 caractères.',
length_var_name: desc_text_ln,
'desc_content': desc_content,
'marks': 1
}
final_score = final_score + result['marks']
result_dict['meta_description'] = result
print('try worked1')
elif desc_text_ln > 150 and desc_text_ln < 250:
result = {
'name': name,
'message':
'Félicitations votre site dispose d’une méta-description avec un nombre de caractère optimal entre 150 et 250 caractères',
length_var_name: desc_text_ln,
'desc_content': desc_content,
'marks': 5
}
final_score = final_score + result['marks']
result_dict['meta_description'] = result
print('try worked2')
elif desc_text_ln > 250:
result = {
'name': name,
'message':
' Votre méta-description est trop longue, essayez de la raccourcir, le nombre optimal est entre 150 et 250 caractères, le reste risque d’être tronqué sur l’affichage du résultat sur les moteurs de recherche.',
length_var_name: desc_text_ln,
'desc_content': desc_content,
'marks': 2
}
final_score = final_score + result['marks']
result_dict['meta_description'] = result
print('try worked3')
except:
result1 = {
'name': name,
'message':
'Votre site ne dispose pas de méta-description, La balise meta description manque sur votre page. Vous devez inclure cette balise afin de fournir une brève description de votre page pouvant être utilisée par les moteurs de recherche. Des méta-descriptions bien écrites et attrayantes peuvent également aider les taux de clics sur votre site dans les résultats de moteur de recherche.',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['meta_description'] = result1
print('except worked')
# This is for row 3 (meta @keywords)
name = 'meta_keywords'
length_var_name = 'meta_key_len'
try:
meta_tag = soup.find("meta", {"name": "keywords"})
meta_key_content_ln = len(meta_tag['content'])
# title_ln = int(meta_key_content_ln)
if meta_key_content_ln:
result = {
'name': name,
'message':
'Bravo vous avez spécifié des meta keywords . Vos mots-clés principaux doivent apparaître dans vos méta-tags pour vous aider à identifier le sujet de votre page Web dans les moteurs de recherche.',
length_var_name: meta_key_content_ln,
'marks': 1
}
final_score = final_score + result['marks']
result_dict['meta_keywords'] = result
print('try worked1')
except:
result = {
'name': name,
'message':
'Vos mots-clés principaux doivent apparaître dans vos méta-tags pour vous aider à identifier le sujet de votre page Web dans les moteurs de recherche.',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result['marks']
result_dict['meta_keywords'] = result
print('except worked')
# This is for row 4 (meta @robots)
name = 'meta_robots'
length_var_name = 'meta_robots_len'
try:
meta_tag = soup.find("meta", {"name": "robots"})
meta_robots_content = len(meta_tag['content'])
# title_ln = int(desc_text_ln)
if meta_robots_content:
result = {
'name': name,
'message': "Votre site dispose d'un fichier robots.txt",
length_var_name: meta_robots_content,
'marks': 4
}
final_score = final_score + result['marks']
result_dict['meta_robots'] = result
print('try worked1')
except:
result1 = {
'name': name,
'message': '''
Votre site n’a pas de robot.txt
Le robots.txt est un fichier texte utilisant un format précis qui permet à un Webmaster de contrôler quelles zones de son site un robot d'indexation est autorisé à analyser. Ce fichier texte sera disponible à une URL bien précise pour un site donné, par exemple http://www.monsite.com/robots.txt
Pour bien comprendre à quoi sert un robots.txt, il faut comprendre la manière dont fonctionnent les robots d'indexation des moteurs de recherche (appelés aussi Web spiders, Web crawlers ou Bots) tels que Google, Yahoo ou Bing. Voici leurs actions lorsqu'ils analysent un site tel que www.monsite.com : ils commencent par télécharger et analyser le fichier http://www.monsite.com/robots.txt.
''',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['meta_robots'] = result1
print('except worked')
# This is for row 5 (html lang)
name = 'html_lang'
length_var_name = 'html_lang'
try:
meta_tag = soup.find("html", {"lang": True})
lang_text = meta_tag['lang']
result = {
'name': name,
'message':
"Félicitations. Vous avez spécifié une langue à votre page.",
length_var_name: lang_text,
'marks': 3
}
final_score = final_score + result['marks']
result_dict['html_lang'] = result
print('try worked1')
except:
result1 = {
'name': name,
'message': '''
Vous devriez spécifier une langue pour votre site, les moteurs de recherches ne comprennent pas quand un site dispose de plusieurs langues par exemple ayant des mots techniques en anglais et un contenu texte en français. Il faut donc bien spécifier la langue.
''',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['html_lang'] = result1
print('except worked')
# This is for row 6 (sitemap)
url = url.strip()
sitemap_url = url + '/sitemap.xml'
print("Sitemap url ", sitemap_url)
try:
code = requests.get(sitemap_url, headers=headers).status_code
name = 'sitemap'
if code == 200:
result = {
'name': name,
'message':
"Félicitations, votre site dispose d’un fichier sitemap",
'marks': 2
}
final_score = final_score + result['marks']
result_dict['sitemap'] = result
else:
result = {
'name': name,
'message':
"Votre site Web ne dispose pas d'un fichier sitemap. Les sitemaps peuvent aider les robots à indexer votre contenu de manière plus complète et plus rapide. ",
'marks': 0
}
final_score = final_score + result['marks']
result_dict['sitemap'] = result
except:
result = {
'name': name,
'message':
"Votre site Web ne dispose pas d'un fichier sitemap. Les sitemaps peuvent aider les robots à indexer votre contenu de manière plus complète et plus rapide. ",
'marks': 0
}
final_score = final_score + result['marks']
result_dict['sitemap'] = result
# This is for row 7 (google Analytics)
searched_word = 'google-analytics'
name = 'google_analytics'
if searched_word in str(soup):
print("Google analytics found")
result = {
'name': name,
'message':
"Félicitations, votre site dispose de l'outil Google Analytics",
'marks': 2
}
final_score = final_score + result['marks']
result_dict['google_analytics'] = result
else:
result = {
'name': name,
'message':
"Votre site ne dispose pas de l'outil Google Analytics.",
'marks': 0
}
final_score = final_score + result['marks']
result_dict['google_analytics'] = result
# This is for row 8 (page_cache)
name = 'page_cache'
length_var_name = 'page_cache_desc'
try:
meta_tag = soup.find("meta", {"http-equiv": "Cache-control"})
lang_text = meta_tag['content']
result = {
'name': name,
'message':
"Vous avez activé le cache sur votre page, c'est très bien.",
length_var_name: lang_text,
'marks': 3
}
final_score = final_score + result['marks']
result_dict['page_cache'] = result
print('try worked1')
except:
result1 = {
'name': name,
'message':
"Vous n'avez pas activé la mise en cache sur vos pages. La mise en cache permet un chargement plus rapide des pages.",
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['page_cache'] = result1
print('except worked')
# API_KEY = AIzaSyD_RLUOcTN1JAq8PL8zJ79X6-kmHIDy_uM
# This is for row 9 (Google safe browsing api)
api_key = 'AIzaSyCVylpWnsOwzUoeTGg7akZRod-4YbhXoPU'
sbl = SafeBrowsingList(api_key)
bl = sbl.lookup_url(url)
name = 'google_safe_browsing'
print("google_safe_browsing ", url)
if bl is None:
print("Website is safe")
result = {
'name': name,
'message': "Votre site est considéré comme sécurisé.",
'marks': 2
}
final_score = final_score + result['marks']
result_dict['google_safe_browsing'] = result
else:
result = {
'name': name,
'message':
"Votre site n'est pas considéré comme sécurisé. Google et les autres moteurs de recherche prennent en compte le niveau de sécurité de votre site pour garantir la sécurité des visiteurs.",
'marks': 0,
'threats': bl
}
final_score = final_score + result['marks']
result_dict['google_safe_browsing'] = result
# This is for row 10 (responsive website test)
#name = 'responsive_test'
#length_var_name = 'responsive_test_desc'
try:
meta_tag = soup.find("meta", {"name": "viewport"})
lang_text = meta_tag['content']
result = {
'name': name,
'message': "Félicitations. Votre site est responsive.",
length_var_name: lang_text,
'marks': 4
}
final_score = final_score + result['marks']
result_dict['responsive_test'] = result
print('try worked1')
except:
result1 = {
'name': name,
'message': '''
Nous n'avons pas détécté que votre site internet était responsive, soit adapté au mobile. Google prend énormément en compte ce critère pour un bon référencement.
''',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['responsive_test'] = result1
print('except worked')
def worker(self, id, queue):
with open(r'config\gglsbl.auth', 'r') as auth_file:
gglsbl_key = auth_file.read().strip()
sbl = SafeBrowsingList(gglsbl_key,
db_path=r"dataset\google_safe_browisng_db")
# sbl.update_hash_prefix_cache()
turn = True
while True:
# Update Google SBL database every 12 hours at time X (e.g. 3 AM and 3 PM)
hour = datetime.datetime.today().hour
if hour % 12 == 3 and turn:
sbl.update_hash_prefix_cache()
turn = False
elif hour % 12 != 3:
turn = True
today = get_date()
with open(os.path.join('results', today + '.ioc.csv'),
'a+',
encoding='utf_8') as output_file:
tweet = queue.get()
try:
if hasattr(tweet, 'retweeted_status') and hasattr(
tweet.retweeted_status, 'extended_tweet'
) and 'full_text' in tweet.retweeted_status.extended_tweet:
text = tweet.retweeted_status.extended_tweet[
'full_text']
elif hasattr(tweet, 'extended_tweet'
) and 'full_text' in tweet.extended_tweet:
text = tweet.extended_tweet['full_text']
elif not hasattr(tweet, 'text'):
text = tweet['text']
else:
text = tweet.text
if hasattr(tweet, 'retweeted_status'):
if hasattr(tweet.retweeted_status, 'extended_tweet'):
final_urls = tweet.retweeted_status.extended_tweet[
'entities']['urls']
else:
final_urls = tweet.retweeted_status.entities[
'urls']
else:
if hasattr(tweet, 'extended_tweet'):
final_urls = tweet.extended_tweet['entities'][
'urls']
else:
final_urls = tweet.entities['urls']
for final_url in final_urls:
# If a pastebin URL, get the raw content and append it to the tweet content
if final_url['expanded_url'].startswith(
'https://pastebin.com/'):
pastebin = final_url['expanded_url']
if 'raw' not in pastebin:
pastebin = pastebin.replace(
'https://pastebin.com/',
'https://pastebin.com/raw/')
req = requests.get(pastebin)
text += '\n' + req.content
user_type = 'top'
if tweet.user.id_str in self.rand_users:
user_type = 'rand'
print(
"###########################$$$$$$$$$$$$$$$$$$$$$$$$$$$"
)
print(text)
# classifier must be retrained with new data
# vector = vectorize(text, self.wordlist)
# vector.append(len(tweet.entities['hashtags']))
# vector.append(len(tweet.entities['user_mentions']))
# vector = numpy.array(vector).reshape(1, -1)
# estimates = []
# for i in range(number_of_classifiers):
# y_estimate = self.classifiers[i].predict(vector)
# estimates.append(y_estimate)
# vote = statistics.mode([x[0] for x in estimates])
# print("Prediction: "+vote)
ips = list(iocextract.extract_ips(text, refang=True))
for ip in ips:
if ip not in text:
output_file.write('{},{},{},{},{},ip,{}\n'.format(
tweet.id, tweet.created_at, user_type,
tweet.user.id_str, tweet.user.screen_name, ip))
urls = list(iocextract.extract_urls(text, refang=True))
for url in urls:
if url not in text:
result = sbl.lookup_url(url.rstrip('.'))
if result is not None:
output_file.write(
'{},{},{},{},{},url,{},{}\n'.format(
tweet.id, tweet.created_at, user_type,
tweet.user.id_str,
tweet.user.screen_name,
url.rstrip('.'), result))
else:
output_file.write(
'{},{},{},{},{},url,{},benign\n'.format(
tweet.id, tweet.created_at, user_type,
tweet.user.id_str,
tweet.user.screen_name,
url.rstrip('.')))
emails = list(iocextract.extract_emails(text, refang=True))
for email in emails:
if email not in text:
output_file.write(
'{},{},{},{},{},email,{}\n'.format(
tweet.id, tweet.created_at, user_type,
tweet.user.id_str, tweet.user.screen_name,
email))
hashes = list(iocextract.extract_hashes(text))
for hash in hashes:
output_file.write('{},{},{},{},{},hash,{}\n'.format(
tweet.id, tweet.created_at, user_type,
tweet.user.id_str, tweet.user.screen_name, hash))
except Exception as exp:
print(exp)
queue.task_done()
def main():
# 引数の解釈の準備
p = argparse.ArgumentParser()
p.add_argument("domain_name")
p.add_argument('-g', '--http', action="store_true", help="Get http response by each candidate domains")
p.add_argument('--safe_site', default="", help="Get google safe sites tool information. must be followed by api key ")
p.add_argument('--virustotal', default="", help="Get VirusTotal tool information. must be followed by api key. VERY SLOW ")
p.add_argument('--ip', action="store_true", help="Get IP address for each candidate domains")
p.add_argument('--debug', action="store_true", help="For debug. It restlicts the length of domain list.")
# `$ dscan google.com --genlist qr typo` などとして使う
p.add_argument('--genlist', nargs='+', help="Specify using generators as list.")
p.add_argument('--in_use', action="store_true", help="It shows only domains in use.")
args = p.parse_args()
# URL候補を取得
generator_dict = {}
template_generator_names = ["qr", "suffix", "bit", "typo", "h**o", "combo"]
generator_names = []
# 使うgeneratorが指定された場合
if not args.genlist is None:
for generator_name in args.genlist:
if generator_name in template_generator_names:
generator_names.append(generator_name)
else:
print("error: \""+ generator_name +"\" is not generator name.", file=sys.stderr)
else:
generator_names = template_generator_names
for generator_name in generator_names:
print_progress("generating "+ generator_name +" ...")
list_slice = ""
if args.debug:
# in debug mode, length of domain list is restricted
list_slice = "[:1]"
generator_dict[generator_name] = eval(generator_name +".near_urls(args.domain_name)" + list_slice)
print_progress("generated: " + str(len(generator_dict[generator_name])))
print_progress("fetching domain info ...")
# 辞書形式でドメインの情報らを持つ
domains_dict = {}
for generate_type_name, domain_list in generator_dict.items():
for domain_name in domain_list:
if domain_name not in domains_dict:
domains_dict[domain_name] = {}
# 冗長だがあとでjsonに変換するときに必要
domains_dict[domain_name]["domain_name"] = domain_name
if "generate_type" not in domains_dict[domain_name] :
domains_dict[domain_name]["generate_type"] = []
domains_dict[domain_name]["generate_type"].append(generate_type_name)
# ドメインに関する情報を調べ、記録していく
for domain_name, domain_info_dict in tqdm( domains_dict.items() ):
# httpレスポンス情報を付加する
if args.http:
http_status_code = 0
try:
# 200番台のステータスコードを取得
http_status_code = urllib.request.urlopen("http://" + domain_name,
timeout=0.5).status
except urllib.error.HTTPError as e:
# 200番台以外のステータスコードを取得
http_status_code = e.code
# connection refusedなどになった場合。後でもっとうまく変えたほうがよいかも
except urllib.error.URLError as e:
http_status_code = -1
except socket.timeout:
http_status_code = -1
except ConnectionResetError:
http_status_code = -1
domain_info_dict["http_status_code"] = http_status_code
# Google Safe Brawsingの情報を取得
if len(args.safe_site)>0:
api_key_gsb = args.safe_site
sbl = SafeBrowsingList(api_key_gsb)
threat_list = sbl.lookup_url(domain_name)
if threat_list == None:
domain_info_dict["site_threat"] = []
else:
domain_info_dict["site_threat"] = threat_list
# VirusTotalの情報を取得
if len(args.virustotal)>0:
api_key_vt = args.virustotal
# TODO:関数とかに後でする
interval_seconds_virustotal = 60/4
retry_max_time = 2
retry_sleep_seconds_virustotal = 1
for _ in range(retry_max_time):
try:
info_virustotal = fetch_pdns_domain_info(domain_name, api_key_vt)
except:
# virustotalがrate limitなどなどで取得に失敗した場合はすこし待つ
time.sleep(retry_sleep_seconds_virustotal)
else:
try:
domain_info_dict["virus_total"] = info_virustotal["Webutation domain info"]
except KeyError:
domain_info_dict["virus_total"] = {}
# virustotalのrate limitにかからないように60/4 = 15秒ほど寝る
# 制限は1分間に4クエリなのだから、1クエリにつき15秒まつのではなく、4クエリ投げたら1分待つ方が正当だが面倒なのでこうした
time.sleep(interval_seconds_virustotal)
break
if args.ip:
try:
# 生成したドメインの IP アドレスを取得
ip = socket.gethostbyname(domain_name)
except socket.gaierror:
ip = ''
finally:
domain_info_dict["ip"] = ip
# 追加例：
# geoip情報を付加する
# if args.geoip:
# domain_info_dict["geoip"] = country
if args.in_use:
domains_dict = domain_filter_only_in_use(domains_dict)
print_list = []
for domain_info_dict in domains_dict.values():
print_list.append(domain_info_dict)
print(json.dumps(print_list, indent=4, separators=(',', ': ')) )
def scrapper():
final_report = []
final_score = 0
url = 'google.com'
a1 = url.split(':')
# row 15 HTTPS test
result = {'name': 'https_test', 'message': '', 'marks': ''}
if a1[0] == 'https' or a1[0] == 'http':
if a1[0] != 'https':
a1[0] = 'https'
a2 = a1.insert(1, ':')
print(a1)
web = ''.join(a1)
print("This is web ", web)
try:
r = requests.get(web)
result[
'message'] = 'Félicitations. Votre site les données transitants par votre site sont sécurisées avec un certificat SSL'
result['marks'] = 4
except:
result['message'] = '''
Votre site ne dispose pas de certificat SSL. Les données qui y transitent peuvent donc être récupérés par des parties malveillantes. Google donne une grande importance à la sécurité des visiteurs.
'''
result['marks'] = 0
print("HTTPS didn't worked")
else:
try:
url = 'https://' + url
r = requests.get(url)
result[
'message'] = 'Félicitations. Votre site les données transitants par votre site sont sécurisées avec un certificat SSL'
result['marks'] = 4
except:
url = 'http://' + url
r = requests.get(url)
result['message'] = '''
Votre site ne dispose pas de certificat SSL. Les données qui y transitent peuvent donc être récupérés par des parties malveillantes. Google donne une grande importance à la sécurité des visiteurs.
'''
result['marks'] = 0
final_report.append(result)
final_score = final_score + result['marks']
soup = BeautifulSoup(r.text, "lxml")
# This is for row 1 (title)
try:
title_ln = len(soup.find('title').text)
if title_ln < 70:
result = {
'name': 'title',
'message':
'Félicitations votre site dispose d’un titre avec un nombre de caractères optimale soit moins de 70 caractères',
'title_length': title_ln,
'marks': 5
}
final_score = final_score + 5
final_report.append(result)
elif title_ln > 70:
result = {
'name': 'title',
'message':
'Votre titre est trop long, le nombre de caractères optimal est de 70 caractères, essayez de le raccourcir',
'title_length': title_ln,
'marks': 2
}
final_score = final_score + 2
final_report.append(result)
except:
result = {
'name': 'title',
'message':
'Votre site ne dispose pas de balise meta title. La balise <title> correspond au titre de votre page web. Il s’agit d’un champ essentiel à ne pas négliger dans le cadre d’une bonne stratégie d’optimisation du référencement naturel puisqu’elle est l’un des critères les plus importants pour les moteurs de recherche (Google, Bing...)',
'title_length': 0,
'marks': 0
}
final_score = final_score + 0
final_report.append(result)
# This is for row 2 (meta @description)
name = 'meta_description'
length_var_name = 'meta_desc_len'
try:
meta_tag = soup.find("meta", {"name": "description"})
desc_text_ln = len(meta_tag['content'])
title_ln = int(desc_text_ln)
if title_ln < 150:
result = {
'name': name,
'message':
'Votre méta-description est trop courte, le nombre de caractère optimale doit être entre 150 et 250 caractères.',
length_var_name: desc_text_ln,
'marks': 1
}
final_score = final_score + result['marks']
final_report.append(result)
print('try worked1')
elif title_ln > 150 and title_ln < 250:
result = {
'name': name,
'message':
'Félicitations votre site dispose d’une méta-description avec un nombre de caractère optimal entre 150 et 155 caractères',
length_var_name: desc_text_ln,
'marks': 3
}
final_score = final_score + result['marks']
final_report.append(result)
print('try worked2')
elif title_ln > 250:
result = {
'name': name,
'message':
' Votre méta-description est trop longue, essayez de la raccourcir, le nombre optimal est entre 150 et 250 caractères, le reste risque d’être tronqué sur l’affichage du résultat sur les moteurs de recherche.',
length_var_name: desc_text_ln,
'marks': 2
}
final_score = final_score + result['marks']
final_report.append(result)
print('try worked3')
except:
result1 = {
'name': name,
'message':
'Votre site ne dispose pas de méta-description, La balise meta description manque sur votre page. Vous devez inclure cette balise afin de fournir une brève description de votre page pouvant être utilisée par les moteurs de recherche. Des méta-descriptions bien écrites et attrayantes peuvent également aider les taux de clics sur votre site dans les résultats de moteur de recherche',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
final_report.append(result1)
print('except worked')
# This is for row 3 (meta @keywords)
name = 'meta_keywords'
length_var_name = 'meta_key_len'
try:
meta_tag = soup.find("meta", {"name": "keywords"})
desc_text_ln = len(meta_tag['content'])
title_ln = int(desc_text_ln)
if title_ln:
result = {
'name': name,
'message':
'Bravo vous avez spécifié des meta keywords . Vos mots-clés principaux doivent apparaître dans vos méta-tags pour vous aider à identifier le sujet de votre page Web dans les moteurs de recherche.',
length_var_name: desc_text_ln,
'marks': 1
}
final_score = final_score + result['marks']
final_report.append(result)
print('try worked1')
except:
result1 = {
'name': name,
'message':
'Vos mots-clés principaux doivent apparaître dans vos méta-tags pour vous aider à identifier le sujet de votre page Web dans les moteurs de recherche.',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
final_report.append(result1)
print('except worked')
# This is for row 4 (meta @robots)
name = 'meta_robots'
length_var_name = 'meta_robots_len'
try:
meta_tag = soup.find("meta", {"name": "robots"})
desc_text_ln = len(meta_tag['content'])
title_ln = int(desc_text_ln)
if title_ln:
result = {
'name': name,
'message': "Votre site dispose d'un fichier robots.txt",
length_var_name: desc_text_ln,
'marks': 4
}
final_score = final_score + result['marks']
final_report.append(result)
print('try worked1')
except:
result1 = {
'name': name,
'message': '''
Votre site n’a pas de robot.txt
Le robots.txt est un fichier texte utilisant un format précis qui permet à un Webmaster de contrôler quelles zones de son site un robot d'indexation est autorisé à analyser. Ce fichier texte sera disponible à une URL bien précise pour un site donné, par exemple http://www.monsite.com/robots.txt
Pour bien comprendre à quoi sert un robots.txt, il faut comprendre la manière dont fonctionnent les robots d'indexation des moteurs de recherche (appelés aussi Web spiders, Web crawlers ou Bots) tels que Google, Yahoo ou Bing. Voici leurs actions lorsqu'ils analysent un site tel que www.monsite.com : ils commencent par télécharger et analyser le fichier http://www.monsite.com/robots.txt.
''',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
final_report.append(result1)
print('except worked')
# This is for row 5 (html lang)
name = 'html_lang'
length_var_name = 'html_lang'
try:
meta_tag = soup.find("html", {"lang": True})
lang_text = meta_tag['lang']
result = {
'name': name,
'message':
"Félicitations. Vous avez spécifié une langue à votre page.",
length_var_name: lang_text,
'marks': 3
}
final_score = final_score + result['marks']
final_report.append(result)
print('try worked1')
except:
result1 = {
'name': name,
'message': '''
Vous devriez spécifier une langue pour votre site, les moteurs de recherches ne comprennent pas quand un site dispose de plusieurs langues par exemple ayant des mots techniques en anglais et un contenu texte en français. Il faut donc bien spécifier la langue.
''',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
final_report.append(result1)
print('except worked')
# This is for row 6 (sitemap)
url = url.strip()
sitemap_url = url + '/sitemap.xml'
code = requests.get(sitemap_url).status_code
name = 'sitemap'
if code == 200:
result = {
'name': name,
'message':
"Félicitations, votre site dispose d’un fichier sitemap",
'marks': 2
}
final_score = final_score + result['marks']
final_report.append(result)
else:
result = {
'name': name,
'message':
"Votre site Web ne dispose pas d'un fichier sitemap. Les sitemaps peuvent aider les robots à indexer votre contenu de manière plus complète et plus rapide. ",
'marks': 0
}
final_score = final_score + result['marks']
final_report.append(result)
# This is for row 7 (google Analytics)
searched_word = 'google-analytics'
name = 'google_analytics'
if searched_word in str(soup):
print("Google analytics found")
result = {
'name': name,
'message':
"Félicitations, votre site dispose de l'outil Google Analytics",
'marks': 2
}
final_score = final_score + result['marks']
final_report.append(result)
else:
result = {
'name': name,
'message':
"Votre site ne dispose pas de l'outil Google Analytics.",
'marks': 0
}
final_score = final_score + result['marks']
final_report.append(result)
# This is for row 8 (page_cache)
name = 'page_cache'
length_var_name = 'page_cache_desc'
try:
meta_tag = soup.find("meta", {"http-equiv": "Cache-control"})
lang_text = meta_tag['content']
result = {
'name': name,
'message':
"Vous avez activé le cache sur votre page, c'est très bien.",
length_var_name: lang_text,
'marks': 3
}
final_score = final_score + result['marks']
final_report.append(result)
print('try worked1')
except:
result1 = {
'name': name,
'message':
"Vous n'avez pas activé la mise en cache sur vos pages. La mise en cache permet un chargement plus rapide des pages.",
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
final_report.append(result1)
print('except worked')
# API_KEY = AIzaSyD_RLUOcTN1JAq8PL8zJ79X6-kmHIDy_uM
# This is for row 9 (Google safe browsing api)
from gglsbl import SafeBrowsingList
api_key = 'AIzaSyCVylpWnsOwzUoeTGg7akZRod-4YbhXoPU'
sbl = SafeBrowsingList(api_key)
bl = sbl.lookup_url(url)
name = 'google_safe_browsing'
if bl is None:
print("Website is safe")
result = {
'name': name,
'message': "Votre site est considéré comme sécurisé.",
'marks': 2
}
final_score = final_score + result['marks']
final_report.append(result)
else:
result = {
'name': name,
'message':
"Votre site n'est pas considéré comme sécurisé. Google et les autres moteurs de recherche prennent en compte le niveau de sécurité de votre site pour garantir la sécurité des visiteurs.",
'marks': 0,
'threats': bl
}
final_score = final_score + result['marks']
final_report.append(result)
# This is for row 10 (responsive website test)
name = 'responsive_test'
length_var_name = 'responsive_test_desc'
try:
meta_tag = soup.find("meta", {"name": "viewport"})
lang_text = meta_tag['content']
result = {
'name': name,
'message': "Félicitations. Votre site est responsive.",
length_var_name: lang_text,
'marks': 4
}
final_score = final_score + result['marks']
final_report.append(result)
print('try worked1')
except:
result1 = {
'name': name,
'message': '''
Nous n'avons pas détécté que votre site internet était responsive, soit adapté au mobile. Google prend énormément en compte ce critère pour un bon référencement.
''',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
final_report.append(result1)
print('except worked')
# Html page size
# # mobile_friendliness_test
# data = {
# "url": url,
# "requestScreenshot": True,
# }
# r1 = requests.post('https://searchconsole.googleapis.com/v1/urlTestingTools/mobileFriendlyTest:run?key=AIzaSyDExRwe7TNEgHa_JLogOVjccqWNVoaH-EQ',data)
# r1.text
# import json
# a = json.loads(r1.text)
# imgstring = a['screenshot']['data']
# # import base64
# # imgdata = base64.b64decode(imgstring)
# # filename = 'some_image.jpg' # I assume you have a way of picking unique filenames
# # with open(filename, 'wb') as f:
# # f.write(imgdata)
# name = 'mobile_friendliness_test'
# if a['mobileFriendliness'] is 'MOBILE_FRIENDLY':
# print("Website is mobile friendly")
# result = {
# 'name':name,
# 'message':"Félicitations. Votre site est Mobile friendly.",
# 'result': a['mobileFriendliness'],
# 'img_string':imgstring,
# 'marks':4
# }
# final_score = final_score + result['marks']
# final_report.append(result)
# else:
# result = {
# 'name':name,
# 'message':"Votre site n'est pas optimisé pour le mobile. Les moteurs de recherches donnent une très grande importance à la compatibilité mobile.",
# 'marks':0,
# 'result': a['mobileFriendliness'],
# 'img_string':imgstring
# }
# final_score = final_score + result['marks']
# final_report.append(result)
# # # "mobileFriendlyIssues": [
# # # {
# # # "rule": "TAP_TARGETS_TOO_CLOSE"
# # # },
# # # {
# # # "rule": "USE_LEGIBLE_FONT_SIZES"
# # # },
# # # {
# # # "rule": "CONFIGURE_VIEWPORT"
# # # }
# # # ],
import json
# google page speed
r2 = requests.get(
'https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url={}?key=AIzaSyAXf3ILJpeIs1nfDvvmLk0MsQDsuIsG5gM'
.format(url))
b = json.loads(r2.text)
# final_report.append({
# "google_page_speed_data":b
# })
# This is for row 13 (img alt attribute)
name = 'img_alt'
img_tags = soup.findAll("img")
no_alt = []
empty_alt = []
alt_ok = []
empty_check = []
name = "img_alt"
for img_tag in img_tags:
if not img_tag['alt']:
empty_alt.append(img_tag['src'])
elif img_tag['alt'] is None:
no_alt.append(img_tag['src'])
else:
alt_ok.append(img_tag['src'])
total_alt_num = len(empty_alt) + len(alt_ok)
img_alt_result = {
'name': name,
'message': '',
'marks': '',
'no_alt': no_alt,
'empty_altm': empty_alt
}
if len(img_tags) == len(alt_ok):
img_alt_result[
'message'] = 'Félicitations. Toutes vos images disposent de balises alt attributs'
img_alt_result['marks'] = 3
print("every image tag contains alt and all have values")
elif empty_alt and len(img_tags) == total_alt_num:
img_alt_result[
'message'] = 'Certaines de vos images manquent de balises alt attributs. Voir la liste complète'
img_alt_result['marks'] = 1
print("Every img have alt tag but some have empty alt")
elif len(img_tags) == len(no_alt):
img_alt_result[
'message'] = "Aucune de vos images n'a de balises alt attributs, elles sont essentielles pour permettre aux moteurs de recherche de comprendre ce que représente votre image."
img_alt_result['marks'] = 0
print("No images have alt tag")
if no_alt:
print("Some images have no alt tag")
final_score = final_score + img_alt_result['marks']
final_report.append(img_alt_result)
# This is for row 14 (favicon test)
name = 'favicon_test'
length_var_name = 'favicon_link'
favicon_list = []
link_tags = soup.findAll("link")
for link in link_tags:
if "favicon" in link['href']:
favicon_list.append(link['href'])
if favicon_list:
result = {
'name': name,
'message': "Félicitations. Votre site dispose d'une favicon.",
length_var_name: favicon_list,
'marks': 1
}
final_score = final_score + result['marks']
final_report.append(result)
print('if worked1')
else:
result1 = {
'name': name,
'message':
"Votre site ne dispose pas de favicon. La favicon est la petite icone qui apparait en haut du navigateur à côté du titre de votre site. Au delà de l'aspect SEO, elle permet de donner une identité visuelle à votre site.",
'marks': 0
}
final_score = final_score + result1['marks']
final_report.append(result1)
print('else worked')
# This is for strong tag test
name = 'strong_tag'
length_var_name = 'strong_text'
try:
strong_tags = soup.findAll("strong")
if strong_tags:
result = {
'name': name,
'message':
'Félicitations. Vous avez spécifié des balises strong dans votre texte',
length_var_name: strong_tags,
'marks': 2
}
else:
result = {
'name': name,
'message':
" Vous n'avez spécifié aucune balise strong dans votre texte. Les balises strong permettent aux moteurs de recherche de savoir quel contenu est intéressant et pertinent dans votre texte.",
'marks': 0
}
final_score = final_score + result['marks']
final_report.append(result)
print('try worked1')
except:
result1 = {
'name': name,
'message':
" Vous n'avez spécifié aucune balise strong dans votre texte. Les balises strong permettent aux moteurs de recherche de savoir quel contenu est intéressant et pertinent dans votre texte.",
'marks': 0
}
final_score = final_score + result1['marks']
final_report.append(result1)
print('except worked')
# This is for Microdata test (itemscope , itemtype)
name = 'micro_data_test'
try:
soup.find(True, {'itemscope': True}) or soup.find(
True, {'itemtype': True})
result = {
'name': name,
'message':
"Félicitations. Votre site utilise des Microdonnées Schema.org",
'marks': 3
}
final_score = final_score + result['marks']
final_report.append(result)
print('try worked1')
except:
result1 = {
'name': name,
'message': '''
Vos visiteurs aiment les beadcrumbs, mais Google aussi. Les beadcrumbs donnent à Google un autre moyen de comprendre la structure de votre site Web. Toutefois, comme indiqué précédemment, Google peut également utiliser vos beadcrumbs dans les résultats de recherche, ce qui rend votre résultat beaucoup plus attrayant pour les utilisateurs.
''',
'marks': 0
}
final_score = final_score + result1['marks']
final_report.append(result1)
print('except worked')
# This is for AMP Version
name = 'amp_html_test'
try:
tag = soup.find('link', {'rel': "amphtml"})
result = {
'name': name,
'message': " Félicitations. Votre site dispose d'une version AMP",
'amp_html_link': tag['href'],
'marks': 3
}
final_score = final_score + result['marks']
final_report.append(result)
print('try worked1')
except:
result1 = {
'name': name,
'message':
'''L’objectif est que les pages AMP s’affichent presque de façon instantannée, c’est-à-dire généralement 90% plus rapidement que d’habitude.
Grâce à cette grande vitesse, l’expérience utilisateur sur mobile se trouve largement améliorée, ce qui d’après des études fait chuter le taux de rebo
''',
'marks': 0
}
final_score = final_score + result1['marks']
final_report.append(result1)
print('except worked')
# This is for Breadcrumps
searched_word = 'breadcrumb'
name = 'breadcrumb'
if searched_word in str(soup).lower():
print("Breadcrum found")
result = {
'name': name,
'message':
"Félicitations, votre site dispose de l'outil Google Analytics",
'marks': 2
}
final_score = final_score + result['marks']
final_report.append(result)
else:
result = {
'name': name,
'message':
"Vos url sont composées de plus de 5 dossiers, veuillez en diminuer le nombre",
'marks': 0
}
final_score = final_score + result['marks']
final_report.append(result)
return final_report
# AIzaSyDWcNFNEsDWagvfgjZGHw0Y9LNvtgz3LhE Throwaway key (doesn't matter)
from gglsbl import SafeBrowsingList
sbl = SafeBrowsingList('AIzaSyDWcNFNEsDWagvfgjZGHw0Y9LNvtgz3LhE')
threat_list = sbl.lookup_url('http://github.com/')
if threat_list == None:
print('None.')
else:
print('Threats: ' + str(threat_list))
dnsbl[domain.group(0)] = 1
print('Checking {} domains against blacklists...'.format(domaincount))
for domain in domains:
if domain is None:
break
iteration += 1
if iteration % 101 == 0:
print('\rProgress: {:05.3f}%'.format(
(iteration / int(domaincount)) * 100),
end='')
domain_name = domain['name'].replace('*.', '')
blacklists = 0
# print('Safebrowsing check started for {} ({})'.format(domain_name, str(blacklists)))
try:
th = sbl.lookup_url('https://' + domain_name + '/')
if th is not None:
blacklists += 1
except:
print('Error retrieving safebrowsing data for {}'.format(domain_name))
# th = sbl.lookup_url('http://' + domain_name + '/')
# if th is not None:
# blacklists += 1
# # print('DNSBL check started for {} ({})'.format(domain_name, str(blacklists)))
if domain_name in dnsbl:
blacklists += dnsbl[domain_name]
if blacklists > 0:
print('\nDomain {} found in {} blacklists - updating database.'.format(
domain_name, str(blacklists)))
db.update_blacklists(domain=domain['name'], count=blacklists)
print('Blacklist data update complete!')
'marks': 0
}
final_score = final_score + result1['marks']
final_report.append(result1)
print('except worked')
# In[63]:
# API_KEY = AIzaSyD_RLUOcTN1JAq8PL8zJ79X6-kmHIDy_uM
# This is for row 9 (Google safe browsing api)
from gglsbl import SafeBrowsingList
api_key = 'AIzaSyCVylpWnsOwzUoeTGg7akZRod-4YbhXoPU'
sbl = SafeBrowsingList(api_key)
bl = sbl.lookup_url(url)
name = 'google_safe_browsing'
if bl is None:
print("Website is safe")
result = {
'name': name,
'message': "Votre site est considéré comme sécurisé.",
'marks': 2
}
final_score = final_score + result['marks']
final_report.append(result)
else:
result = {
'name': name,
def main():
# 引数の解釈の準備
p = argparse.ArgumentParser()
p.add_argument("domain_name")
p.add_argument('-g',
'--http',
action="store_true",
help="Get http response by each candidate domains")
p.add_argument(
'--safe_site',
default="",
help=
"Get google safe sites tool information. must be followed by api key ")
p.add_argument(
'--virustotal',
default="",
help=
"Get google safe sites tool information. must be followed by api key. VERY SLOW "
)
args = p.parse_args()
# URL候補を取得
generator_dict = {}
# TODO: 練習用にリストの長さを制限しているが、本番のときは制限をなくす
# TODO: 同じような内容が反復されているので上手くまとめる(呼ぶ関数が違うので単純にforにはしにくいけど)
print_progress("generating qr ...")
generator_dict["qr"] = qr.near_urls(args.domain_name)[:1]
print_progress("generated: " + str(len(generator_dict["qr"])))
print_progress("generating suffix ...")
generator_dict["suffix"] = suffix.generate_domain(args.domain_name)[:1]
print_progress("generated: " + str(len(generator_dict["suffix"])))
print_progress("generating bit ...")
generator_dict["bit"] = bit.near_urls(args.domain_name)[:1]
print_progress("generated: " + str(len(generator_dict["bit"])))
print_progress("generating typo ...")
generator_dict["typo"] = typo.near_urls(args.domain_name)[:1]
print_progress("generated: " + str(len(generator_dict["typo"])))
#domains_dict["h**o"] = h**o.near_urls(domain)
#domains_dict["combo"] = combo.near_urls(domain)
print_progress("fetching domain info ...")
# 辞書形式でドメインの情報らを持つ
domains_dict = {}
for generate_type_name, domain_list in generator_dict.items():
for domain_name in domain_list:
if domain_name not in domains_dict:
domains_dict[domain_name] = {}
# 冗長だがあとでjsonに変換するときに必要
domains_dict[domain_name]["domain_name"] = domain_name
if "generate_type" not in domains_dict[domain_name]:
domains_dict[domain_name]["generate_type"] = []
domains_dict[domain_name]["generate_type"].append(
generate_type_name)
# ドメインに関する情報を調べ、記録していく
for domain_name, domain_info_dict in tqdm(domains_dict.items()):
# httpレスポンス情報を付加する
if args.http:
# TODO: httpステータスコードの取得をもっとマシなものにする
# https://stackoverflow.com/questions/1726402/in-python-how-do-i-use-urllib-to-see-if-a-website-is-404-or-200
http_status_code = 0
try:
urllib.request.urlopen("http://" + domain_name, timeout=0.5)
except urllib.error.HTTPError as e:
http_status_code = e.code
# connection refusedなどになった場合。後でもっとうまく変えたほうがよいかも
except urllib.error.URLError as e:
http_status_code = -1
except socket.timeout:
http_status_code = -1
except ConnectionResetError:
http_status_code = -1
else:
# エラーにならないのは本当に200だけか...?301とかもあるかもしれないがとりあえず200
http_status_code = 200
domain_info_dict["http_status_code"] = http_status_code
# Google Safe Brawsingの情報を取得
if len(args.safe_site) > 0:
api_key_gsb = args.safe_site
sbl = SafeBrowsingList(api_key_gsb)
threat_list = sbl.lookup_url(domain_name)
if threat_list == None:
domain_info_dict["site_threat"] = []
else:
domain_info_dict["site_threat"] = threat_list
# VirusTotalの情報を取得
if len(args.virustotal) > 0:
api_key_vt = args.virustotal
# TODO:関数とかに後でする
interval_seconds_virustotal = 60 / 4
retry_max_time = 2
retry_sleep_seconds_virustotal = 1
for _ in range(retry_max_time):
try:
info_virustotal = fetch_pdns_domain_info(
domain_name, api_key_vt)
except:
# virustotalがrate limitなどなどで取得に失敗した場合はすこし待つ
time.sleep(retry_sleep_seconds_virustotal)
else:
domain_info_dict["virus_total"] = info_virustotal[
"Webutation domain info"]
# virustotalのrate limitにかからないように60/4 = 15秒ほど寝る
# 制限は1分間に4クエリなのだから、1クエリにつき15秒まつのではなく、4クエリ投げたら1分待つ方が正当だが面倒なのでこうした
time.sleep(interval_seconds_virustotal)
break
# 追加例：
# geoip情報を付加する
# if args.geoip:
# domain_info_dict["geoip"] = country
print_list = []
for domain_info_dict in domains_dict.values():
print_list.append(domain_info_dict)
print(json.dumps(print_list, indent=4, separators=(',', ': ')))
def scrapper(url):
if "www" in url:
url = url.replace("www.", "")
print(url)
else:
pass
headers = {
'User-Agent':
'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.76 Safari/537.36',
"Upgrade-Insecure-Requests": "1",
"DNT": "1",
"Accept":
"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.5",
"Accept-Encoding": "gzip, deflate"
}
final_report = []
final_score = 0
from result_dict import result_dict
domain = tldextract.extract(url).domain
suffix = tldextract.extract(url).suffix
subdomain = tldextract.extract(url).subdomain
pattern = '<a [^>]*href=[\'|"](.*?)[\'"].*?>'
# row 15 HTTPS test
result = {'name': 'https_test', 'message': '', 'marks': ''}
if "https" in url or "http" in url:
print("if worked")
a = url.split(":")
a[0] = "https:"
web = "".join(a)
print("This is web ", web)
try:
print("try of if worked")
r = requests.get(web, headers=headers)
# req = urllib.request.Request(url, headers=headers)
# r = urllib.request.urlopen(req)
url = web
result[
'message'] = 'Félicitations. Votre site les données transitants par votre site sont sécurisées avec un certificat SSL'
result['marks'] = 4
except:
a = url.split(":")
a[0] = "http:"
url3 = "".join(a)
print("try of except worked")
r = requests.get(url3, headers=headers, verify=False)
url = url3
# req = urllib.request.Request(url, headers=headers)
# r = urllib.request.urlopen(req)
result['message'] = '''
Votre site ne dispose pas de certificat SSL. Les données qui y transitent peuvent donc être récupérés par des parties malveillantes. Google donne une grande importance à la sécurité des visiteurs.
'''
result['marks'] = 0
print("HTTPS didn't worked")
else:
print("else worked")
try:
url2 = 'https://' + url
r = requests.get(url2, headers=headers)
url = url2
# req = urllib.request.Request(url, headers=headers)
# r = urllib.request.urlopen(req)
result[
'message'] = 'Félicitations. Votre site les données transitants par votre site sont sécurisées avec un certificat SSL'
result['marks'] = 4
except:
url1 = 'http://' + url
print("from else except ", url1)
r = requests.get(url1, headers=headers, verify=False)
url = url1
# req = urllib.request.Request(url, headers=headers)
# r = urllib.request.urlopen(req)
result['message'] = '''
Votre site ne dispose pas de certificat SSL. Les données qui y transitent peuvent donc être récupérés par des parties malveillantes. Google donne une grande importance à la sécurité des visiteurs.
'''
result['marks'] = 0
print(result)
result_dict['https_test'] = result
final_score = final_score + result['marks']
soup = BeautifulSoup(r.text, "lxml")
# This is for row 1 (title)
try:
title_content = soup.find('title').text
title_ln = len(title_content)
if title_ln < 70:
result = {
'name': 'title',
'message':
'Félicitations votre site dispose d’un titre avec un nombre de caractères optimale soit moins de 70 caractères',
'title_length': title_ln,
'title_content': title_content,
'marks': 5
}
final_score = final_score + 5
result_dict['title'] = result
elif title_ln > 70:
result = {
'name': 'title',
'message':
'Votre titre est trop long, le nombre de caractères optimal est de 70 caractères, essayez de le raccourcir',
'title_length': title_ln,
'title_content': title_content,
'marks': 2
}
final_score = final_score + 2
result_dict['title'] = result
except:
result = {
'name': 'title',
'message':
'Votre site ne dispose pas de balise meta title. La balise <title> correspond au titre de votre page web. Il s’agit d’un champ essentiel à ne pas négliger dans le cadre d’une bonne stratégie d’optimisation du référencement naturel puisqu’elle est l’un des critères les plus importants pour les moteurs de recherche (Google, Bing...)',
'title_length': 0,
'marks': 0
}
final_score = final_score + 0
result_dict['title'] = result
# This is for row 2 (meta @description)
name = 'meta_description'
length_var_name = 'meta_desc_len'
try:
meta_tag = soup.find("meta", {"name": "description"})
desc_content = meta_tag['content']
desc_text_ln = len(desc_content)
#desc_text_ln = int(desc_text_ln)
if desc_text_ln < 150:
result = {
'name': name,
'message':
'Votre méta-description est trop courte, le nombre de caractère optimale doit être entre 150 et 250 caractères.',
length_var_name: desc_text_ln,
'desc_content': desc_content,
'marks': 1
}
final_score = final_score + result['marks']
result_dict['meta_description'] = result
print('try worked1')
elif desc_text_ln > 150 and desc_text_ln < 250:
result = {
'name': name,
'message':
'Félicitations votre site dispose d’une méta-description avec un nombre de caractère optimal entre 150 et 155 caractères',
length_var_name: desc_text_ln,
'desc_content': desc_content,
'marks': 3
}
final_score = final_score + result['marks']
result_dict['meta_description'] = result
print('try worked2')
elif desc_text_ln > 250:
result = {
'name': name,
'message':
' Votre méta-description est trop longue, essayez de la raccourcir, le nombre optimal est entre 150 et 250 caractères, le reste risque d’être tronqué sur l’affichage du résultat sur les moteurs de recherche.',
length_var_name: desc_text_ln,
'desc_content': desc_content,
'marks': 2
}
final_score = final_score + result['marks']
result_dict['meta_description'] = result
print('try worked3')
except:
result1 = {
'name': name,
'message':
'Votre site ne dispose pas de méta-description, La balise meta description manque sur votre page. Vous devez inclure cette balise afin de fournir une brève description de votre page pouvant être utilisée par les moteurs de recherche. Des méta-descriptions bien écrites et attrayantes peuvent également aider les taux de clics sur votre site dans les résultats de moteur de recherche.',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['meta_description'] = result1
print('except worked')
# This is for row 3 (meta @keywords)
name = 'meta_keywords'
length_var_name = 'meta_key_len'
try:
meta_tag = soup.find("meta", {"name": "keywords"})
meta_key_content_ln = len(meta_tag['content'])
#title_ln = int(meta_key_content_ln)
if meta_key_content_ln:
result = {
'name': name,
'message':
'Bravo vous avez spécifié des meta keywords . Vos mots-clés principaux doivent apparaître dans vos méta-tags pour vous aider à identifier le sujet de votre page Web dans les moteurs de recherche.',
length_var_name: meta_key_content_ln,
'marks': 1
}
final_score = final_score + result['marks']
result_dict['meta_keywords'] = result
print('try worked1')
except:
result1 = {
'name': name,
'message':
'Vos mots-clés principaux doivent apparaître dans vos méta-tags pour vous aider à identifier le sujet de votre page Web dans les moteurs de recherche.',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['meta_keywords'] = result
print('except worked')
# This is for row 4 (meta @robots)
name = 'meta_robots'
length_var_name = 'meta_robots_len'
try:
meta_tag = soup.find("meta", {"name": "robots"})
meta_robots_content = len(meta_tag['content'])
# title_ln = int(desc_text_ln)
if meta_robots_content:
result = {
'name': name,
'message': "Votre site dispose d'un fichier robots.txt",
length_var_name: meta_robots_content,
'marks': 4
}
final_score = final_score + result['marks']
result_dict['meta_robots'] = result
print('try worked1')
except:
result1 = {
'name': name,
'message': '''
Votre site n’a pas de robot.txt
Le robots.txt est un fichier texte utilisant un format précis qui permet à un Webmaster de contrôler quelles zones de son site un robot d'indexation est autorisé à analyser. Ce fichier texte sera disponible à une URL bien précise pour un site donné, par exemple http://www.monsite.com/robots.txt
Pour bien comprendre à quoi sert un robots.txt, il faut comprendre la manière dont fonctionnent les robots d'indexation des moteurs de recherche (appelés aussi Web spiders, Web crawlers ou Bots) tels que Google, Yahoo ou Bing. Voici leurs actions lorsqu'ils analysent un site tel que www.monsite.com : ils commencent par télécharger et analyser le fichier http://www.monsite.com/robots.txt.
''',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['meta_robots'] = result1
print('except worked')
# This is for row 5 (html lang)
name = 'html_lang'
length_var_name = 'html_lang'
try:
meta_tag = soup.find("html", {"lang": True})
lang_text = meta_tag['lang']
result = {
'name': name,
'message':
"Félicitations. Vous avez spécifié une langue à votre page.",
length_var_name: lang_text,
'marks': 3
}
final_score = final_score + result['marks']
result_dict['html_lang'] = result
print('try worked1')
except:
result1 = {
'name': name,
'message': '''
Vous devriez spécifier une langue pour votre site, les moteurs de recherches ne comprennent pas quand un site dispose de plusieurs langues par exemple ayant des mots techniques en anglais et un contenu texte en français. Il faut donc bien spécifier la langue.
''',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['html_lang'] = result1
print('except worked')
# This is for row 6 (sitemap)
url = url.strip()
sitemap_url = url + '/sitemap.xml'
print("Sitemap url ", sitemap_url)
try:
code = requests.get(sitemap_url, headers=headers).status_code
name = 'sitemap'
if code == 200:
result = {
'name': name,
'message':
"Félicitations, votre site dispose d’un fichier sitemap",
'marks': 2
}
final_score = final_score + result['marks']
result_dict['sitemap'] = result
else:
result = {
'name': name,
'message':
"Votre site Web ne dispose pas d'un fichier sitemap. Les sitemaps peuvent aider les robots à indexer votre contenu de manière plus complète et plus rapide. ",
'marks': 0
}
final_score = final_score + result['marks']
result_dict['sitemap'] = result
except:
result = {
'name': name,
'message':
"Votre site Web ne dispose pas d'un fichier sitemap. Les sitemaps peuvent aider les robots à indexer votre contenu de manière plus complète et plus rapide. ",
'marks': 0
}
final_score = final_score + result['marks']
result_dict['sitemap'] = result
# This is for row 7 (google Analytics)
searched_word = 'google-analytics'
name = 'google_analytics'
if searched_word in str(soup):
print("Google analytics found")
result = {
'name': name,
'message':
"Félicitations, votre site dispose de l'outil Google Analytics",
'marks': 2
}
final_score = final_score + result['marks']
result_dict['google_analytics'] = result
else:
result = {
'name': name,
'message':
"Votre site ne dispose pas de l'outil Google Analytics.",
'marks': 0
}
final_score = final_score + result['marks']
result_dict['google_analytics'] = result
# This is for row 8 (page_cache)
name = 'page_cache'
length_var_name = 'page_cache_desc'
try:
meta_tag = soup.find("meta", {"http-equiv": "Cache-control"})
lang_text = meta_tag['content']
result = {
'name': name,
'message':
"Vous avez activé le cache sur votre page, c'est très bien.",
length_var_name: lang_text,
'marks': 3
}
final_score = final_score + result['marks']
result_dict['page_cache'] = result
print('try worked1')
except:
result1 = {
'name': name,
'message':
"Vous n'avez pas activé la mise en cache sur vos pages. La mise en cache permet un chargement plus rapide des pages.",
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['page_cache'] = result1
print('except worked')
# API_KEY = AIzaSyD_RLUOcTN1JAq8PL8zJ79X6-kmHIDy_uM
# This is for row 9 (Google safe browsing api)
api_key = 'AIzaSyCVylpWnsOwzUoeTGg7akZRod-4YbhXoPU'
sbl = SafeBrowsingList(api_key)
bl = sbl.lookup_url(url)
name = 'google_safe_browsing'
print("google_safe_browsing ", url)
if bl is None:
print("Website is safe")
result = {
'name': name,
'message': "Votre site est considéré comme sécurisé.",
'marks': 2
}
final_score = final_score + result['marks']
result_dict['google_safe_browsing'] = result
else:
result = {
'name': name,
'message':
"Votre site n'est pas considéré comme sécurisé. Google et les autres moteurs de recherche prennent en compte le niveau de sécurité de votre site pour garantir la sécurité des visiteurs.",
'marks': 0,
'threats': bl
}
final_score = final_score + result['marks']
result_dict['google_safe_browsing'] = result
# This is for row 10 (responsive website test)
name = 'responsive_test'
length_var_name = 'responsive_test_desc'
try:
meta_tag = soup.find("meta", {"name": "viewport"})
lang_text = meta_tag['content']
result = {
'name': name,
'message': "Félicitations. Votre site est responsive.",
length_var_name: lang_text,
'marks': 4
}
final_score = final_score + result['marks']
result_dict['responsive_test'] = result
print('try worked1')
except:
result1 = {
'name': name,
'message': '''
Nous n'avons pas détécté que votre site internet était responsive, soit adapté au mobile. Google prend énormément en compte ce critère pour un bon référencement.
''',
length_var_name: 0,
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['responsive_test'] = result1
print('except worked')
# Html page size
# mobile_friendliness_test
print("mobile friendly ", url)
data = {
"url": url,
"requestScreenshot": True,
}
try:
r1 = requests.post(
'https://searchconsole.googleapis.com/v1/urlTestingTools/mobileFriendlyTest:run?key=AIzaSyDExRwe7TNEgHa_JLogOVjccqWNVoaH-EQ',
data)
r1.text
# a = json.loads(r1.text).decode('utf-8')
a = json.loads(r1.text)
imgstring = a['screenshot']['data']
if imgstring:
print("image of mobile returned")
else:
print("image of mobile NOT returned")
# import base64
# imgdata = base64.b64decode(imgstring)
# filename = 'some_image.jpg' # I assume you have a way of picking unique filenames
# with open(filename, 'wb') as f:
# f.write(imgdata)
name = 'mobile_friendliness_test'
if a['mobileFriendliness'] == 'MOBILE_FRIENDLY':
print("Website is mobile friendly")
result = {
'name':
name,
'message':
"Félicitations. Votre site est Mobile friendly.",
'result':
a['mobileFriendliness'],
'img_string':
'data:image/png;base64,' + urllib.parse.quote(imgstring),
'marks':
4
}
final_score = final_score + result['marks']
result_dict['mobile_friendliness_test'] = result
else:
result = {
'name':
name,
'message':
"Votre site n'est pas optimisé pour le mobile. Les moteurs de recherches donnent une très grande importance à la compatibilité mobile.",
'marks':
0,
'result':
a['mobileFriendliness'],
'img_string':
'data:image/png;base64,' + urllib.parse.quote(imgstring)
}
final_score = final_score + result['marks']
result_dict['mobile_friendliness_test'] = result
except:
result = {
'name': name,
'message':
"Votre site n'est pas optimisé pour le mobile. Les moteurs de recherches donnent une très grande importance à la compatibilité mobile.",
'marks': 0,
'result': "Not Mobile Friendly"
}
final_score = final_score + result['marks']
result_dict['mobile_friendliness_test'] = result
# # "mobileFriendlyIssues": [
# # {
# # "rule": "TAP_TARGETS_TOO_CLOSE"
# # },
# # {
# # "rule": "USE_LEGIBLE_FONT_SIZES"
# # },
# # {
# # "rule": "CONFIGURE_VIEWPORT"
# # }
# # ],
# google page speed
try:
print("Google page speed ", url)
r2 = requests.get(
'https://www.googleapis.com/pagespeedonline/v5/runPagespeed?url={}?key=AIzaSyAXf3ILJpeIs1nfDvvmLk0MsQDsuIsG5gM'
.format(url))
#b = json.loads(r2.text).decode('utf-8')
b = json.loads(r2.text)
name = "page_speed"
score = b['lighthouseResult']['audits']['speed-index']['displayValue']
print("this is speed index", score)
# final_report.append({
# "google_page_speed_data":b
# })
result = {
"name": "google_page_speed",
"speed_index": score,
"message": "",
"marks": ""
}
if "\xa0s" in score:
score1 = float(score.replace("\xa0s", ""))
else:
score1 = float(score)
if score1 < 5:
result[
'message'] = "Félicitations. La vitesse moyenne de chargement de votre site est de X secondes, soit en dessous de la vitesse moyenne de 5secondes."
result['marks'] = 4
else:
result[
'message'] = "La vitesse moyenne de chargement de votre site internet est de X secondes, c'est supérieur à la vitesse moyenne optimale qui est de 5 secondes."
result['marks'] = 2
except:
result = {
"name": "google_page_speed",
"speed_index": 0,
"message":
"Désolé, Google n'a renvoyé aucune réponse indiquant une vitesse de page relative à votre site Web.",
"marks": 0
}
result_dict['page_speed'] = result
# This is for row 13 (img alt attribute)
name = 'img_alt'
img_tags = soup.findAll("img")
no_alt = []
empty_alt = []
alt_ok = []
empty_check = []
name = "img_alt"
for img_tag in img_tags:
try:
if not img_tag['alt'].strip():
empty_alt.append(img_tag['src'])
elif img_tag['alt'].strip():
alt_ok.append(img_tag['src'])
except:
no_alt.append(img_tag)
total_alt_num = len(empty_alt) + len(alt_ok)
img_alt_result = {
'name': name,
'message': '',
'marks': '',
'no_alt': no_alt,
'empty_altm': empty_alt
}
if len(img_tags) == len(alt_ok):
img_alt_result[
'message'] = 'Félicitations. Toutes vos images disposent de balises alt attributs'
img_alt_result['marks'] = 3
print("every image tag contains alt and all have values")
elif empty_alt and len(img_tags) == total_alt_num:
img_alt_result[
'message'] = 'Certaines de vos images manquent de balises alt attributs. Voir la liste complète'
img_alt_result['marks'] = 1
print("Every img have alt tag but some have empty alt")
elif len(img_tags) == len(no_alt):
img_alt_result[
'message'] = "Aucune de vos images n'a de balises alt attributs, elles sont essentielles pour permettre aux moteurs de recherche de comprendre ce que représente votre image."
img_alt_result['marks'] = 0
print("No images have alt tag")
if no_alt:
img_alt_result[
'message'] = "Aucune de vos images n'a de balises alt attributs, elles sont essentielles pour permettre aux moteurs de recherche de comprendre ce que représente votre image."
img_alt_result['marks'] = 0
print("Some images have no alt tag")
final_score = final_score + img_alt_result['marks']
result_dict['img_alt'] = img_alt_result
# This is for row 14 (favicon test)
name = 'favicon_test'
length_var_name = 'favicon_link'
favicon_list = []
link_tags = soup.findAll("link")
for link in link_tags:
if "favicon" in link['href']:
favicon_list.append(link['href'])
if favicon_list:
result = {
'name': name,
'message': "Félicitations. Votre site dispose d'une favicon.",
length_var_name: favicon_list,
'marks': 1
}
final_score = final_score + result['marks']
result_dict['favicon_test'] = result
print('if worked1')
else:
result1 = {
'name': name,
'message':
"Votre site ne dispose pas de favicon. La favicon est la petite icone qui apparait en haut du navigateur à côté du titre de votre site. Au delà de l'aspect SEO, elle permet de donner une identité visuelle à votre site.",
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['favicon_test'] = result1
print('else worked')
# This is for strong tag test
name = 'strong_tag'
length_var_name = 'strong_text'
try:
strong_tags = soup.findAll("strong")
if strong_tags:
result = {
'name': name,
'message':
'Félicitations. Vous avez spécifié des balises strong dans votre texte',
length_var_name: strong_tags,
'marks': 2
}
else:
result = {
'name': name,
'message':
" Vous n'avez spécifié aucune balise strong dans votre texte. Les balises strong permettent aux moteurs de recherche de savoir quel contenu est intéressant et pertinent dans votre texte.",
'marks': 0
}
final_score = final_score + result['marks']
result_dict['strong_tag'] = result
print('try worked1')
except:
result1 = {
'name': name,
'message':
" Vous n'avez spécifié aucune balise strong dans votre texte. Les balises strong permettent aux moteurs de recherche de savoir quel contenu est intéressant et pertinent dans votre texte.",
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['strong_tag'] = result1
print('except worked')
# This is for Microdata test (itemscope , itemtype)
name = 'micro_data_test'
try:
soup.find(True, {'itemscope': True}) or soup.find(
True, {'itemtype': True})
result = {
'name': name,
'message':
"Félicitations. Votre site utilise des Microdonnées Schema.org",
'marks': 3
}
final_score = final_score + result['marks']
result_dict['micro_data_test'] = result
print('try worked1')
except:
result1 = {
'name': name,
'message': '''
Vos visiteurs aiment les beadcrumbs, mais Google aussi. Les beadcrumbs donnent à Google un autre moyen de comprendre la structure de votre site Web. Toutefois, comme indiqué précédemment, Google peut également utiliser vos beadcrumbs dans les résultats de recherche, ce qui rend votre résultat beaucoup plus attrayant pour les utilisateurs.
''',
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['micro_data_test'] = result1
print('except worked')
# This is for AMP Version
name = 'amp_html_test'
try:
tag = soup.find('link', {'rel': "amphtml"})
result = {
'name': name,
'message': " Félicitations. Votre site dispose d'une version AMP",
'amp_html_link': tag['href'],
'marks': 3
}
final_score = final_score + result['marks']
result_dict['amp_html_test'] = result
print('try worked1')
except:
result1 = {
'name': name,
'message':
'''L’objectif est que les pages AMP s’affichent presque de façon instantannée, c’est-à-dire généralement 90% plus rapidement que d’habitude.
Grâce à cette grande vitesse, l’expérience utilisateur sur mobile se trouve largement améliorée, ce qui d’après des études fait chuter le taux de rebo
''',
'marks': 0
}
final_score = final_score + result1['marks']
result_dict['amp_html_test'] = result1
print('except worked')
# This is for Breadcrumps
searched_word = 'breadcrumb'
name = 'breadcrumb'
if searched_word in str(soup).lower():
print("Breadcrum found")
result = {
'name': name,
'message':
"Félicitations, nous avons détécté l'utilisation de beadcrumbs sur votre site.",
'marks': 2
}
final_score = final_score + result['marks']
result_dict['breadcrumb'] = result
else:
result = {
'name': name,
'message':
"Nous n'avons pas détécté de Beadcrumb sur votre site. Les Beadcrumbs sont une partie importante de presque tous les bons sites Web. Ces petites aides à la navigation ne permettent pas seulement aux internautes de savoir où elles se trouvent sur votre site, elles aident également Google à déterminer la structure de votre site.",
'marks': 0
}
final_score = final_score + result['marks']
result_dict['breadcrumb'] = result
# Open graph Test
name = 'open_graph_test'
open_graph_tags = []
og_tags = soup.findAll('meta', {"property": True})
for og in og_tags:
if "og" in str(og):
open_graph_tags.append(og['property'])
result = {
'name': name,
'message': "",
'marks': "",
'og_tags': open_graph_tags
}
if open_graph_tags:
result[
'message'] = 'Félicitations nous avons détécté des balises Open Graph.'
result['marks'] = 1
print("If worked")
else:
result['message'] = '''
Les balises méta Open Graph sont conçues pour communiquer des informations sur votre site Web aux réseaux sociaux lorsque des liens vers votre site Web sont partagés. Ces balises vous permettent de créer des titres, des descriptions et des images personnalisés à utiliser lorsque vos pages sont partagées sur Facebook, LinkedIn et Google+.
Ainsi, tout comme lorsque Google ou un autre moteur de recherche visite votre site et recherche les données (ou balises) appropriées afin d'afficher correctement votre site Web dans les résultats de recherche, les réseaux sociaux agissent de la même manière. La seule différence est que les réseaux sociaux recherchent ces tags spécifiques Open Graph (ou tags Twitter).
'''
result['marks'] = 0
print("else worked")
result_dict['open_graph_test'] = result
final_score = final_score + result['marks']
# Twitter Test
name = 'twitter_test'
twitter_tags = []
og_tags = soup.findAll('meta', {"property": True})
for twitter in twitter_tags:
if "twitter" in str(og_tags):
twitter_tags.append(og['property'])
result = {
'name': name,
'message': "",
'marks': "",
'og_tags': twitter_tags
}
if twitter_tags:
result['message'] = ' Parfait. Vous avez spécifié des Twitter Cards'
result['marks'] = 2
print("If worked")
else:
result[
'message'] = "Twitter via les twitter Cards vous permet d'identifier l'auteur de la publication / de la page ainsi que l'éditeur, qui est généralement le nom du site Web. Ces deux valeurs ne sont pas obligatoires, mais permettent d’ajouter des données supplémentaires à ceux qui souhaiteraient l’ajouter."
result['marks'] = 0
print("else worked")
result_dict['twitter_test'] = result
final_score = final_score + result['marks']
# This is for Social Media test
fb = 'facebook.com'
linkedin = 'linkedin.com'
twitter = 'twitter.com'
name = 'social_media_test'
social_sites_found = []
if fb in str(soup):
social_sites_found.append('facebook')
print("facebook.com found")
elif linkedin in str(soup):
social_sites_found.append('linkedin')
print("linkedin.com found")
elif twitter in str(soup):
social_sites_found.append('twitter')
print("twitter.com found")
result = {
'name': name,
'message': "",
'marks': '',
'social_sites_found': social_sites_found
}
if social_sites_found:
result[
'message'] = 'Nous avons détécté une liaison vers les réseaux sociaux sur votre site.'
result['marks'] = 2
else:
result[
'message'] = " Nous n'avons pas détécté de lien vers vos réseaux sociaux sur votre site. Même si ça n'impacte pas grandement votre SEO, avoir des liens vers les réseaux sociaux de sa marque est plus agréable et utile pour les utilisateurs."
result['marks'] = 0
final_score = final_score + result['marks']
result_dict['social_media_test'] = result
# for H1/h2/h3
h1_tag = soup.findAll('h5')
h_tags = []
for i in range(1, 6):
h_tag = soup.find_all('h' + str(i))
result = {"tag": 'h' + str(i), "total_num": len(h_tag)}
h_tags.append(result)
result = {
"name": "heading_tags_test",
"message": "",
"marks": "",
"total_num _tags": h_tags
}
if h_tags[0] and h_tags[1] and h_tags[2]:
result['message'] = "Félicitations vos en en-têtes sont structurées"
result['marks'] = 3
elif h_tags[0] or h_tags[1] or h_tags[2] or h_tags[3] or h_tags[4]:
result[
'message'] = "FVos en-têtes ne sont pas structurés, il faut d'abord spécifier des en-têtes H1 puis H2 puis H3 etc.."
result['marks'] = 1
else:
result[
'message'] = "Vous n'avez pas spécifié d'en têtes, c'est un élément essentiel du SEO, ça permet aux moteurs de recherche de savoir de quoi le chapitre ou la section va discuter."
result['marks'] = 0
final_score = final_score + result['marks']
result_dict['heading_tags_test'] = result
# This is for page characters
name = 'page_characters'
try:
tags1 = soup.findAll('p')
tags2 = soup.findAll('h1')
tags3 = soup.findAll('h2')
tags4 = soup.findAll('h3')
tags5 = soup.findAll('h4')
tags6 = soup.findAll('h5')
tags = tags1 + tags2 + tags3 + tags4 + tags5 + tags6
text = ""
for tag in tags:
text = text + tag.text
num_words = len(text.split(' '))
result = {
'name': name,
'message': "",
'marks': "",
'num_words': num_words
}
if num_words > 300:
result[
'message'] = "Félicitations, la quantité de texte est supérieur à 300 mots."
result['marks'] = 5
else:
result[
'message'] = "La quantité de texte est insuffisante, il faut que vos pages contiennent plus de 300 mots pour que le contenu soit intéressant pour les moteurs de recherche."
result['marks'] = 0
print('try worked1')
except:
result = {
'name': name,
'message': '''
La quantité de texte est insuffisante, il faut que vos pages contiennent plus de 300 mots pour que le contenu soit intéressant pour les moteurs de recherche.
''',
'marks': 0
}
print('except worked')
final_score = final_score + result['marks']
result_dict['page_characters'] = result
# page = requests.get(url,headers=headers).text
# collecting all urls in website
domain = tldextract.extract(url).domain
suffix = tldextract.extract(url).suffix
subdomain = tldextract.extract(url).subdomain
pattern = '<a [^>]*href=[\'|"](.*?)[\'"].*?>'
link_levels = []
found_links = re.findall(pattern, r.text)
links = []
external_links = []
web = domain + '.' + suffix
for link in found_links:
if url not in link and "." not in link and "#" not in link:
links.append(url + link)
elif url not in link and "#" not in link and web not in link:
external_links.append(link)
links = list(dict.fromkeys(links))
# keywords in URL test && levels in url
keywords_in_url = []
directories_in_url = []
for url in links:
if 'https' in url:
if subdomain:
url1 = "https://" + subdomain + '.' + domain + '.' + suffix
else:
url1 = "https://" + domain + '.' + suffix
elif 'http' in url:
if subdomain:
url1 = "http://" + subdomain + '.' + domain + '.' + suffix
else:
url1 = "http://" + domain + '.' + suffix
a = url
t = set(url1.split('/'))
p = set(a.split('/'))
e = p - t
keywords = list(e)
if keywords:
for item in keywords:
keywords_in_url.append(item)
directories_in_url.append(len(keywords))
keywords_in_url = list(dict.fromkeys(keywords_in_url))
else:
pass
result = {
"name": "keywords_in_url",
"keywords": keywords_in_url,
"message": "",
"marks": ''
}
if keywords_in_url:
result[
'message'] = "Vos urls disposent de keywords, Veuillez vérifier qu'elles correspondent bien à ce que vous voulez mettre en avant sur votre site."
result['marks'] = 1
else:
result['message'] = "Vos urls ne semblent pas avoir de keywords."
result['marks'] = 0
result_dict['keywords_in_url'] = result
final_score = final_score + result['marks']
if directories_in_url:
directories = max(directories_in_url)
else:
directories = 0
result = {
"name": "directories_in_url",
"directories": directories,
"message": "",
"marks": ''
}
if directories < 5:
result[
'message'] = "Félicitations, votre URL est composée de moins de 5 dossiers",
result['marks'] = 2
else:
result[
'message'] = "Vos url sont composées de plus de 5 dossiers, veuillez en diminuer le nombre",
result['marks'] = 0
result_dict['directories_in_url'] = result
final_score = final_score + result['marks']
# # broken_link test
# broken_links = []
# all_links = links + external_links
# for link in all_links:
# try:
# print("Checking link health of ",link)
# r1 = requests.get(url,headers = headers)
# except:
# broken_links.append(link)
# result = {
# "name":"broken_links_test",
# "message":"",
# "marks":'',
# "broken_links":broken_links
# }
# if broken_links:
# result['message'] = "Nous avons détécté un ou plusieurs liens qui ne fonctionnent plus sur votre site internet. Voir la liste complète"
# result['marks'] = 0
# else:
# result['message'] = "Félicitations, vous n'avez pas de brokenlinks."
# result['marks'] = 3
# final_score = final_score + result['marks']
# result_dict['broken_links_test'] = result
# external links test
result = {
"name": "external_links_test",
"message": "",
"marks": '',
"external_links": external_links
}
if external_links:
result[
'message'] = "Félicitations, vous avez plusieurs external links. Voir la liste complète"
result['marks'] = 9
else:
result[
'message'] = "Nous n'avons pas détécté de external links pour votre site internet. Les liens retour (external internal links) de qualité, sont primordiaux pour une bon référencement."
result['marks'] = 0
final_score = final_score + result['marks']
result_dict['external_links_test'] = result
#word cloud
if text:
cloud = WordCloud(background_color="white").generate(text)
plt.imshow(cloud)
plt.axis('off')
image = io.BytesIO()
plt.savefig(image, format='png')
image.seek(0) # rewind the data
string = base64.b64encode(image.read())
image_64 = 'data:image/png;base64,' + urllib.parse.quote(string)
result = {
"name": "word_cloud",
"img": image_64,
"message": "Nuage des mots les plus présents sur votre page"
}
result_dict['word_cloud'] = result
else:
result = {
"name": "word_cloud",
"img": "",
"message": "Aucun contenu texte n'a été détécté"
}
# Internal links test
result = {
"name": "internal_links_test",
"message": "",
"marks": '',
"internal_links": links
}
if links:
result[
'message'] = "Félicitations. Nous avons détécté l'utilisation de liens internes sur votre page."
result['marks'] = 4
else:
result[
'message'] = "Nous n'avons pas détécté de liens internes sur votre page. En plus de faire la liaison entre vos différentes pages, les liens internes permettent de mieux guider les robots Google et mettent en évidence le lien entre vos différentes pages."
result['marks'] = 0
final_score = final_score + result['marks']
result_dict['internal_links_test'] = result
# For SEO Friendly URL
from string import punctuation
special_charac = list(set(punctuation))
special_charac.pop(20)
name = "seo_friendly_url"
found_special_characters = []
for item in special_charac:
if item in subdomain + domain:
if item == "-":
pass
else:
found_special_characters.append(item)
result = {
"name": name,
"message": '',
"marks": '',
"found_special_characters": found_special_characters
}
if found_special_characters:
result[
'message'] = "Certaines de vos URL ne sont pas SEO Friendly. Voir la liste complète"
result['marks'] = 0
else:
result['message'] = "Félicitations. Touts vos urls sont SEO Friendly"
result['marks'] = 3
final_score = final_score + result['marks']
result_dict['seo_friendly_url'] = result
# Page Size test
name = "page_size_test"
result = {"name": name, "message": '', "marks": ''}
hdr = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64)'}
req = urllib.request.Request(url, headers=hdr)
response = urllib.request.urlopen(req)
size = (len(response.read())) / 1024
if size < 33:
result[
'message'] = "Toutes nos félicitations! La taille du code HTML de votre page Web est de {} Kb et se situe en dessous de la taille HTML moyenne de la page Web de 33 Kb. Un chargement plus rapide des sites Web se traduit par une meilleure expérience utilisateur, des taux de conversion plus élevés et, de manière générale, un meilleur classement des moteurs de recherche.".format(
size)
result['marks'] = 3
else:
result[
'message'] = " La taille du code HTML de votre page Web est de {} Kb et se situe au dessusde la taille HTML moyenne de la page Web de 33 Kb. Un chargement plus rapide des sites Web se traduit par une meilleure expérience utilisateur, des taux de conversion plus élevés et, de manière générale, un meilleur classement des moteurs de recherche.".format(
size)
result['marks'] = 0
final_score = final_score + result['marks']
result_dict['page_size_test'] = result
# For speakable tags
name = "speakable_tags"
result = {"name": name, "message": '', "marks": ''}
main_text = str(soup)
if "speakable" in main_text and "@type" in main_text:
result[
'message'] = "Félicitations. Nous avons détécté des balises speachable."
result['marks'] = 2
else:
result[
'message'] = "Nous n'avons détécté aucune balise speachable sur votre site internet. Ces balises permettent d'indiquiter aux assistants vocaux qu'un contenu est adapté à la lecture pour répondre aux requêtes des utilisateurs, ce critère est nouveau et de plus en plus pris en compte par les moteurs de recherche."
result['marks'] = 0
final_score = final_score + result['marks']
result_dict['speakable_tags'] = result
test_count = {"test_passed": "", "test_failed": "", "without_marks": ""}
passed = 0
failed = 0
without_marks = 0
no_marks_field = []
for k, v in result_dict.items():
try:
if v['marks'] == 0:
failed = failed + 1
elif v['marks'] > 0:
passed = passed + 1
else:
pass
except:
try:
without_marks = without_marks + 1
no_marks_field.append(v['name'])
except:
pass
print("This is without marks tests", no_marks_field)
test_count['test_passed'] = passed
test_count['test_failed'] = failed
test_count['without_marks'] = without_marks
result_dict['test_count'] = test_count
return (final_score, result_dict)
def testLongURL(long_url):
sbl = SafeBrowsingList(GOOGLE_SAFEBROWSE_API_KEY, db_path="/opt/crawler/gsb_v3.db")
return sbl.lookup_url(long_url)
