hacking Güvenlik Zafiyeti Tespit ve Raporlama Aracı(Basit Düzeyde)

a.py
Python:
import requests
from bs4 import BeautifulSoup
import re
from urllib.parse import urlparse, urljoin, parse_qs
import time
import json
import logging
import socket
import ssl
import pdfkit
from jinja2 import Environment, FileSystemLoader

class URLVulnerabilityScanner:
def __init__(self, url, timeout=10):
self.url = self.format_url(url)
self.timeout = timeout
self.vulnerabilities = []
self.setup_logging()
self.session = requests.Session()
self.session.headers.update({
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
 })

def format_url(self, url):
"""Kullanıcıdan gelen domaini doğru formatta URL'ye çevirir."""
if not url.startswith(('http://', 'https://')):
url = 'http://' + url
 return url

def setup_logging(self):
logging.basicConfig(filename='tarayici.log', level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s')
self.logger = logging.getLogger()

def menu(self):
while True:
print("\nGüvenlik Tarama Seçenekleri:")
print("1. HTTP Başlıkları Analizi")
print("2. SSL/TLS Kontrolü")
print("3. Açık Yönlendirme Kontrolü")
print("4. Admin Sayfası Kontrolü")
print("5. XSS Kontrolü")
print("6. SQL Injection Kontrolü")
print("7. Bilgi İfşası Kontrolü")
print("8. CSRF Kontrolü")
print("9. Clickjacking Kontrolü")
print("10. Güvensiz Çerez Kontrolü")
print("11. Tüm Testleri Çalıştır")
print("12. Çıkış")

choice = input("Lütfen bir seçenek girin: ")

if choice == '1':
self.scan_http_headers()
elif choice == '2':
self.scan_ssl()
elif choice == '3':
self.scan_open_redirect()
elif choice == '4':
self.scan_admin_pages()
elif choice == '5':
self.scan_xss()
elif choice == '6':
self.scan_sql_injection()
elif choice == '7':
self.scan_information_disclosure()
elif choice == '8':
self.scan_csrf()
elif choice == '9':
self.scan_clickjacking()
elif choice == '10':
self.scan_insecure_cookies()
elif choice == '11':
self.scan_all()
elif choice == '12':
print("Çıkış yapılıyor...")
break
 else:
print("Geçersiz seçenek! Lütfen tekrar deneyin.")

self.generate_report()

def scan_http_headers(self):
print("\n[+] HTTP Başlıkları Analizi")
response = self.session.get(self.url, timeout=self.timeout)
self.analyze_headers(self.url, response)

def scan_ssl(self):
print("\n[+] SSL/TLS Kontrolü")
self.check_ssl(self.url)

def scan_open_redirect(self):
print("\n[+] Açık Yönlendirme Kontrolü")
response = self.session.get(self.url, timeout=self.timeout)
self.check_open_redirect(self.url, response)

def scan_admin_pages(self):
print("\n[+] Admin Sayfası Kontrolü")
self.check_admin_page(self.url)

def scan_xss(self):
print("\n[+] XSS Kontrolü")
response = self.session.get(self.url, timeout=self.timeout)
self.check_xss(self.url, response)

def scan_sql_injection(self):
print("\n[+] SQL Injection Kontrolü")
self.check_sql_injection(self.url)

def scan_information_disclosure(self):
print("\n[+] Bilgi İfşası Kontrolü")
response = self.session.get(self.url, timeout=self.timeout)
self.check_information_disclosure(self.url, response)

def scan_csrf(self):
print("\n[+] CSRF Kontrolü")
response = self.session.get(self.url, timeout=self.timeout)
self.check_csrf(self.url, response)

def scan_clickjacking(self):
print("\n[+] Clickjacking Kontrolü")
response = self.session.get(self.url, timeout=self.timeout)
self.check_clickjacking(self.url, response)

def scan_insecure_cookies(self):
print("\n[+] Güvensiz Çerez Kontrolü")
response = self.session.get(self.url, timeout=self.timeout)
self.check_insecure_cookies(self.url, response)

def scan_all(self):
print("\n[+] Tüm Testler Çalıştırılıyor")
response = self.session.get(self.url, timeout=self.timeout)
self.analyze_headers(self.url, response)
self.check_ssl(self.url)
self.check_open_redirect(self.url, response)
self.check_admin_page(self.url)
self.check_xss(self.url, response)
self.check_sql_injection(self.url)
self.check_information_disclosure(self.url, response)
self.check_csrf(self.url, response)
self.check_clickjacking(self.url, response)
self.check_insecure_cookies(self.url, response)

def analyze_headers(self, url, response):
self.logger.info("HTTP Başlıkları analiz ediliyor...")
headers = response.headers
security_headers = {
'Strict-Transport-Security': 'HSTS eksik',
'Content-Security-Policy': 'CSP eksik',
'X-Frame-Options': 'X-Frame-Options eksik',
'X-XSS-Protection': 'X-XSS-Protection eksik',
'X-Content-Type-Options': 'X-Content-Type-Options eksik'
}
for header, message in security_headers.items():
if header not in headers:
vuln = f"Güvenlik Başlığı Eksik: {url} ({message})"
self.logger.warning(vuln)
self.vulnerabilities.append(vuln)

def check_ssl(self, url):
self.logger.info("SSL/TLS kontrolü yapılıyor...")
parsed_url = urlparse(url)
if parsed_url.scheme == 'https':
 try:
context = ssl.create_default_context()
with socket.create_connection((parsed_url.hostname, 443)) as sock:
with context.wrap_socket(sock, server_hostname=parsed_url.hostname) as secure_sock:
ssl_version = secure_sock.version()
if ssl_version in ['TLSv1', 'TLSv1.1']:
vuln = f"Eski SSL/TLS Versiyonu: {url} (Versiyon: {ssl_version})"
self.logger.warning(vuln)
self.vulnerabilities.append(vuln)
except ssl.SSLError as e:
vuln = f"SSL Hatası: {url} (Hata: {str(e)})"
self.logger.error(vuln)
self.vulnerabilities.append(vuln)
except Exception as e:
self.logger.error(f"SSL kontrolü sırasında hata: {e}")
print(f"Bir SSL hatası oluştu: {e}")

def check_open_redirect(self, url, response):
self.logger.info("Açık Yönlendirme kontrolü yapılıyor...")
redirect_params = ['url', 'redirect', 'next', 'redir', 'destination', 'return_to']
parsed_url = urlparse(url)
base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
query_params = parse_qs(parsed_url.query)
  
for param in redirect_params:
if param in query_params:
test_url = f"{url}&{param}={base_url}"
 try:
test_response = self.session.get(test_url, allow_redirects=False, timeout=self.timeout)
if test_response.status_code in [301, 302, 303, 307, 308]:
location = test_response.headers.get('Location', '')
if base_url in location:
vuln = f"Açık Yönlendirme: {url} (Parametre: {param})"
self.logger.warning(f"Güvenlik Açığı Bulundu: {vuln}")
self.vulnerabilities.append(vuln)
return
except requests.RequestException as e:
self.logger.error(f"Yönlendirme kontrolü sırasında hata: {e}")
self.logger.info("Açık Yönlendirme bulunamadı.")

def check_admin_page(self, base_url):
self.logger.info("Admin sayfası kontrolü yapılıyor...")
admin_patterns = ['/admin', '/administrator', '/login', '/user', '/wp-admin', '/cpanel', '/dashboard']
for pattern in admin_patterns:
admin_url = urljoin(base_url, pattern)
 try:
admin_response = self.session.get(admin_url, timeout=self.timeout)
if admin_response.status_code == 200:
soup = BeautifulSoup(admin_response.text, 'html.parser')
if soup.find('input', {'type': 'password'}):
vuln = f"Potansiyel Admin Sayfası: {admin_url}"
self.logger.warning(f"Güvenlik Açığı Bulundu: {vuln}")
self.vulnerabilities.append(vuln)
return
except requests.RequestException as e:
self.logger.error(f"Admin sayfası kontrolü sırasında hata: {e}")
self.logger.info("Admin sayfası bulunamadı.")

def check_xss(self, url, response):
self.logger.info("XSS (Cross-Site Scripting) kontrolü yapılıyor...")
xss_payloads = [
 "<script>alert('XSS')</script>",
 "'-alert(1)-'",
 "<img src=x onerror=alert('XSS')>",
 "<svg/onload=alert('XSS')>",
"javascript:alert('XSS')"
]
parsed_url = urlparse(url)
query_params = parse_qs(parsed_url.query)
      
for param, values in query_params.items():
for payload in xss_payloads:
test_url = f"{url}&{param}={payload}"
 try:
test_response = self.session.get(test_url, timeout=self.timeout)
if payload in test_response.text:
vuln = f"Potansiyel XSS Açığı: {url} (Parametre: {param}, Payload: {payload})"
self.logger.warning(f"Güvenlik Açığı Bulundu: {vuln}")
self.vulnerabilities.append(vuln)
return
except requests.RequestException as e:
self.logger.error(f"XSS kontrolü sırasında hata: {e}")
self.logger.info("XSS açığı bulunamadı.")

def check_sql_injection(self, url):
self.logger.info("SQL Injection kontrolü yapılıyor...")
sql_payloads = ["'", "\"", "1' OR '1'='1", "1\" OR \"1\"=\"1", "' UNION SELECT NULL--", "admin' --"]
parsed_url = urlparse(url)
query_params = parse_qs(parsed_url.query)
      
for param, values in query_params.items():
for payload in sql_payloads:
test_url = f"{url}&{param}={payload}"
 try:
test_response = self.session.get(test_url, timeout=self.timeout)
error_patterns = [
"SQL syntax.*?MySQL", "Warning.*?\\Wmysqli?_", "MySQLSyntaxErrorException",
"Valid MySQL result", "check the manual that (corresponds to|fits) your MySQL server version",
"Unknown column '[^ ]+' in 'field list'", "MySqlClient\\.",
"com\\.mysql\\.jdbc", "Zend_Db_(Adapter|Statement)_Mysqli_Exception"
]
for pattern in error_patterns:
if re.search(pattern, test_response.text, re.IGNORECASE):
vuln = f"Potansiyel SQL Injection Açığı: {url} (Parametre: {param}, Payload: {payload})"
self.logger.warning(f"Güvenlik Açığı Bulundu: {vuln}")
self.vulnerabilities.append(vuln)
return
except requests.RequestException as e:
self.logger.error(f"SQL Injection kontrolü sırasında hata: {e}")
self.logger.info("SQL Injection açığı bulunamadı.")

def check_information_disclosure(self, url, response):
self.logger.info("Bilgi İfşası kontrolü yapılıyor...")
patterns = [
 r"(?i)phpinfo\(\)",
 r"(?i)stack trace:",
 r"(?i)exception in thread",
 r"(?i)error log:",
 r"(?i)server path:",
 r"(?i)(sql|mysql|postgresql|oracle) error",
 r"(?i)syntax error",
 r"(?i)debug ?mode",
 r"(?i)username=|password=",
r"(?i)/(etc|usr|var|tmp|home)/"
]
for pattern in patterns:
if re.search(pattern, response.text):
vuln = f"Potansiyel Bilgi İfşası: {url} (Pattern: {pattern})"
self.logger.warning(f"Güvenlik Açığı Bulundu: {vuln}")
self.vulnerabilities.append(vuln)
return
self.logger.info("Bilgi İfşası bulunamadı.")

def check_csrf(self, url, response):
self.logger.info("CSRF (Cross-Site Request Forgery) kontrolü yapılıyor...")
soup = BeautifulSoup(response.text, 'html.parser')
forms = soup.find_all('form')
      
for form in forms:
if form.get('method', '').lower() == 'post':
csrf_token = form.find('input', {'name': re.compile(r'csrf|token', re.I)})
if not csrf_token:
vuln = f"Potansiyel CSRF Açığı: {url} (Form action: {form.get('action', 'N/A')})"
self.logger.warning(f"Güvenlik Açığı Bulundu: {vuln}")
self.vulnerabilities.append(vuln)
return
self.logger.info("CSRF açığı bulunamadı.")

def check_clickjacking(self, url, response):
self.logger.info("Clickjacking kontrolü yapılıyor...")
x_frame_options = response.headers.get('X-Frame-Options', '').lower()
csp = response.headers.get('Content-Security-Policy', '')
      
if 'frame-ancestors' not in csp and x_frame_options not in ['deny', 'sameorigin']:
vuln = f"Potansiyel Clickjacking Açığı: {url} (X-Frame-Options: {x_frame_options}, CSP: {csp})"
self.logger.warning(f"Güvenlik Açığı Bulundu: {vuln}")
self.vulnerabilities.append(vuln)
 else:
self.logger.info("Clickjacking koruması mevcut.")

def check_insecure_cookies(self, url, response):
self.logger.info("Güvensiz çerezler kontrolü yapılıyor...")
for cookie in response.cookies:
if not cookie.secure:
vuln = f"Güvensiz Çerez: {url} (Çerez Adı: {cookie.name}, Secure Flag Yok)"
self.logger.warning(f"Güvenlik Açığı Bulundu: {vuln}")
self.vulnerabilities.append(vuln)
if not cookie.has_nonstandard_attr('HttpOnly'):
vuln = f"Güvensiz Çerez: {url} (Çerez Adı: {cookie.name}, HttpOnly Flag Yok)"
self.logger.warning(f"Güvenlik Açığı Bulundu: {vuln}")
self.vulnerabilities.append(vuln)
self.logger.info("Çerez kontrolü tamamlandı.")

def generate_report(self):
self.logger.info("Rapor oluşturuluyor...")
report = {
"scan_summary": {
"total_vulnerabilities": len(self.vulnerabilities),
"scan_date": time.strftime("%Y-%m-%d %H:%M:%S"),
 },
"vulnerabilities": self.vulnerabilities,
"scanned_url": self.url
}
      
with open('güvenlik_tarama_raporu.json', 'w') as f:
json.dump(report, f, indent=4)
self.logger.info("Rapor 'güvenlik_tarama_raporu.json' dosyasına kaydedildi.")

self.generate_html_pdf_report(report)
      

def generate_html_pdf_report(self, report):
self.logger.info("HTML ve PDF raporu oluşturuluyor...")
      
env = Environment(loader=FileSystemLoader('.'))
template = env.get_template('rapor_template.html')

html_out = template.render(report=report)
html_file = 'güvenlik_tarama_raporu.html'
with open(html_file, 'w') as f:
f.write(html_out)
self.logger.info(f"HTML raporu '{html_file}' olarak kaydedildi.")

pdf_file = 'güvenlik_tarama_raporu.pdf'
 try:
pdfkit.from_file(html_file, pdf_file)
self.logger.info(f"PDF raporu '{pdf_file}' olarak kaydedildi.")
except Exception as e:
self.logger.error(f"PDF oluşturulurken hata: {e}")
print(f"PDF oluşturulurken bir hata oluştu: {e}")

if __name__ == "__main__":
url_to_scan = input("Tarama yapılacak domain'i girin (örnek: example.com): ")
scanner = URLVulnerabilityScanner(url=url_to_scan, timeout=15)
scanner.menu()

print("\nTarama tamamlandı. Detaylı rapor 'güvenlik_tarama_raporu.json', 'güvenlik_tarama_raporu.html', ve 'güvenlik_tarama_raporu.pdf' dosyalarında bulunabilir.")

rapor_template.html

HTML:
<!DOCTYPE html>
<html lang="tr">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Güvenlik Tarama Raporu</title>
<link href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
<h1 class="mt-5">Güvenlik Tarama Raporu</h1>
<div class="card mt-4">
<div class="card-body">
<h2>Tarama Özeti</h2>
<p><strong>Tarama Yapılan URL:</strong> {{ report['scanned_url'] }}</p>
<p><strong>Toplam Bulunan Güvenlik Açığı:</strong> {{ report['scan_summary']['total_vulnerabilities'] }}</p>
<p><strong>Tarama Tarihi:</strong> {{ report['scan_summary']['scan_date'] }}</p>
</div>
 </div>

<div class="card mt-4">
<div class="card-body">
<h2>Bulunan Güvenlik Açıkları</h2>
                {% if report['vulnerabilities'] %}
<ul class="list-group">
                        {% for vuln in report['vulnerabilities'] %}
<li class="list-group-item">{{ vuln }}</li>
                        {% endfor %}
</ul>
                {% else %}
<p>Hiçbir güvenlik açığı bulunamadı.</p>
                {% endif %}
</div>
</div>
</div>
<script src="https://code.jquery.com/jquery-3.5.1.slim.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/@popperjs/core@2.9.2/dist/umd/popper.min.js"></script>
<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js"></script>
</body>
</html>