CCTV Camera





E4lord

İstifadəçi
İsmarıclar
31
Reaksiya xalı
6
Qoşuldu
6 İyn 2025
  1 aylıq istifadəçi
Məkan
Azerbaycan
ultra suretli versionu
isletmezden evvel powershell-e girib bu kodu calsitirin:pip install pyqt5 requests
birde bu programi desktopunuza (masaustunuze) atib calistirin cunki output.txt gormek daha asnd olar

version2:
import sys, threading, socket, requests, os, random, time
from ipaddress import ip_network
from concurrent.futures import ThreadPoolExecutor, as_completed
from PyQt5.QtWidgets import (QApplication, QWidget, QPushButton, QLabel, QVBoxLayout,
QComboBox, QTextEdit, QHBoxLayout, QProgressBar)
from PyQt5.QtCore import Qt, QTimer, pyqtSignal, QObject
from PyQt5.QtGui import QFont, QTextCursor

# ---- AYARLAR ----
PORT_LIST = [21, 22, 23, 25, 53, 80, 110, 139, 143, 443, 445, 465, 993, 995,
1080, 1433, 1521, 1723, 3306, 3389, 5900, 8000, 8080, 8081, 8443, 8554]
THREAD_COUNT = 1200 # Ultra hızlı için artırıldı
TIMEOUT = 0.8 # Timeout çok kısa, hız için
MAX_RETRIES = 1 # Hız için tekrar sayısı düşürüldü
running = False

SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
OUTPUT_FILE = os.path.join(SCRIPT_DIR, "sonuclar.txt")

country_codes = {
"AZ": "Azerbaycan", "TR": "Türkiye", "IR": "İran", "GE": "Gürcistan",
"AM": "Ermenistan", "PK": "Pakistan", "IN": "Hindistan", "PS": "Filistin",
"GB": "İngiltere", "US": "Amerika", "FR": "Fransa"
}

hardcoded_blocks = {
"TR": ["78.160.0.0/11", "81.212.0.0/14", "85.96.0.0/12"],
"IR": ["2.176.0.0/12", "5.160.0.0/13", "91.98.0.0/15"]
}

found_count = 0
processed_count = 0
error_count = 0
total_ips = 0

class ScannerSignals(QObject):
log_signal = pyqtSignal(str)
status_signal = pyqtSignal(str)
update_stats_signal = pyqtSignal(int, int, int)
scan_complete = pyqtSignal()
update_progress = pyqtSignal(int)

class MatrixEffectWidget(QTextEdit):
def __init__(self):
super().__init__()
self.setReadOnly(True)
self.setStyleSheet("background-color: black; color: lime; font-family: Consolas;")
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.chars = "01E4"
self.columns = 80
self.rows = 30
self.matrix = [[random.choice(self.chars) for _ in range(self.columns)] for _ in range(self.rows)]
self.timer = QTimer()
self.timer.timeout.connect(self.update_matrix)
self.timer.start(50) # Daha hızlı animasyon

def update_matrix(self):
new_line = [random.choice(self.chars) for _ in range(self.columns)]
self.matrix.pop(0)
self.matrix.append(new_line)
self.setPlainText('\n'.join(''.join(row) for row in self.matrix))

def append_log(self, message):
cursor = self.textCursor()
cursor.movePosition(QTextCursor.End)
cursor.insertText(f"\n{message}")
self.setTextCursor(cursor)
self.ensureCursorVisible()

class MatrixScannerGUI(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("Matrix IP Scanner - E4lord Ultra Hızlı")
self.setGeometry(100, 100, 800, 600)
self.setStyleSheet("background-color: black; color: lime;")

self.signals = ScannerSignals()
self.signals.log_signal.connect(self.log_message)
self.signals.status_signal.connect(self.update_status)
self.signals.update_stats_signal.connect(self.update_stats)
self.signals.scan_complete.connect(self.scan_finished)
self.signals.update_progress.connect(self.update_progress_bar)

layout = QVBoxLayout()

self.matrix_display = MatrixEffectWidget()
layout.addWidget(self.matrix_display)

country_layout = QHBoxLayout()
country_label = QLabel("Ülke Seçimi:")
country_label.setStyleSheet("font: bold 14px;")
country_layout.addWidget(country_label)

self.combo = QComboBox()
self.combo.addItems(country_codes.keys())
self.combo.setStyleSheet("background-color: #101010; color: lime; font: bold 14px;")
self.combo.setFixedWidth(150)
country_layout.addWidget(self.combo)
layout.addLayout(country_layout)

self.progress_bar = QProgressBar()
self.progress_bar.setStyleSheet("""
QProgressBar {
border: 2px solid lime;
border-radius: 5px;
text-align: center;
color: white;
}
QProgressBar::chunk {
background-color: green;
}
""")
self.progress_bar.setFixedHeight(25)
layout.addWidget(self.progress_bar)

self.stats_label = QLabel("İşlenen: 0 | Bulunan: 0 | Hata: 0")
self.stats_label.setStyleSheet("font: bold 14px;")
layout.addWidget(self.stats_label)

btn_layout = QHBoxLayout()
self.start_btn = QPushButton("BAŞLAT")
self.stop_btn = QPushButton("DURDUR")
self.start_btn.clicked.connect(self.start_scan)
self.stop_btn.clicked.connect(self.stop_scan)

for btn in [self.start_btn, self.stop_btn]:
btn.setStyleSheet("""
QPushButton {
background-color: #006400;
color: white;
font-weight: bold;
border-radius: 5px;
padding: 10px;
font-size: 16px;
}
QPushButton:hover {
background-color: #008000;
}
QPushButton:disabled {
background-color: #003300;
color: #888;
}
""")
btn.setFixedHeight(50)

btn_layout.addWidget(self.start_btn)
btn_layout.addWidget(self.stop_btn)
layout.addLayout(btn_layout)

self.status_label = QLabel("[Hazır]")
self.status_label.setStyleSheet("color: lime; font: bold 14px;")
layout.addWidget(self.status_label)

self.setLayout(layout)
self.stop_btn.setEnabled(False)
self.log_message("Sistem hazır. Ülke seçip BAŞLAT'a basın.")

def log_message(self, msg):
self.matrix_display.append_log(msg)

def update_status(self, msg):
self.status_label.setText(msg)

def update_stats(self, processed, found, errors):
self.stats_label.setText(f"İşlenen: {processed} | Bulunan: {found} | Hata: {errors}")

def update_progress_bar(self, value):
self.progress_bar.setValue(value)

def scan_finished(self):
global running
running = False
self.start_btn.setEnabled(True)
self.stop_btn.setEnabled(False)
self.status_label.setText(f"[✓] Tarama tamamlandı! | Bulunan: {found_count}")
self.log_message(f"Tarama tamamlandı. Toplam bulunan: {found_count}")

def start_scan(self):
global running, found_count, processed_count, error_count, total_ips
running = True
found_count = 0
processed_count = 0
error_count = 0
total_ips = 0

self.start_btn.setEnabled(False)
self.stop_btn.setEnabled(True)
self.status_label.setText("[•] IP blokları alınıyor...")
self.log_message("Tarama başlatılıyor...")

country_code = self.combo.currentText()
threading.Thread(target=self.run_scan, args=(country_code,), daemon=True).start()

def stop_scan(self):
global running
running = False
self.status_label.setText("[✖] Durduruluyor...")
self.log_message("Kullanıcı tarafından durduruldu...")

def run_scan(self, code):
global running, found_count, processed_count, error_count, total_ips

blocks = get_ip_blocks(code)
if not blocks:
self.signals.log_signal.emit("[HATA] IP blokları alınamadı!")
self.signals.scan_complete.emit()
return

total_ips = 0
valid_blocks = []
for block in blocks:
try:
net = ip_network(block, strict=False)
total_ips += net.num_addresses
valid_blocks.append(block)
except ValueError:
self.signals.log_signal.emit(f"[UYARI] Geçersiz IP bloğu: {block}")

if not valid_blocks:
self.signals.log_signal.emit("[HATA] Geçerli IP bloğu bulunamadı!")
self.signals.scan_complete.emit()
return

self.signals.log_signal.emit(f"Toplam {len(valid_blocks)} IP bloğu bulundu, {total_ips} IP adresi taranacak")
self.signals.status_signal.emit("[•] Tarama başladı...")
self.signals.update_progress.emit(0)
self.progress_bar.setRange(0, total_ips)

try:
with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
f.write("")
except Exception as e:
self.signals.log_signal.emit(f"[HATA] Dosya oluşturulamadı: {str(e)}")

BATCH_SIZE = 1500 # Daha büyük batch
processed_count = 0
batch = []

for ip in ip_generator(valid_blocks):
if not running:
break
batch.append(ip)

if len(batch) >= BATCH_SIZE:
self.process_batch(batch)
batch = []

if batch and running:
self.process_batch(batch)

self.signals.update_progress.emit(processed_count)
self.signals.update_stats_signal.emit(processed_count, found_count, error_count)
self.signals.scan_complete.emit()

def process_batch(self, batch):
global running, found_count, processed_count, error_count

with ThreadPoolExecutor(max_workers=THREAD_COUNT) as executor:
futures = {executor.submit(process_ip, ip): ip for ip in batch}
for future in as_completed(futures):
if not running:
return
try:
result = future.result()
if result:
found_count += 1
self.signals.log_signal.emit(f"Bulundu: {result}")
except:
error_count += 1
processed_count += 1

if processed_count % 20 == 0: # Daha az frekans
self.signals.update_progress.emit(processed_count)
self.signals.update_stats_signal.emit(processed_count, found_count, error_count)

def get_ip_blocks(code):
sources = [
f"https://ipverse.net/ipblocks/data/countries/{code}.cidr",
f"http://www.ipdeny.com/ipblocks/data/countries/{code.lower()}.zone"
]

blocks = []
for url in sources:
try:
r = requests.get(url, timeout=15, headers={'User-Agent': 'Mozilla/5.0'})
if r.status_code == 200:
for line in r.text.splitlines():
line = line.strip()
if is_valid_cidr(line):
blocks.append(line)
if blocks:
return blocks
except:
continue

hardcoded = hardcoded_blocks.get(code, [])
return [block for block in hardcoded if is_valid_cidr(block)]

def is_valid_cidr(cidr_str):
try:
if '/' not in cidr_str:
return False
ip_network(cidr_str)
return True
except ValueError:
return False

def port_scan(ip, port):
for _ in range(MAX_RETRIES):
try:
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.settimeout(TIMEOUT)
s.connect((ip, port))
return True
except:
time.sleep(0.05)
return False

def process_ip(ip):
global running
if not running:
return None
for port in PORT_LIST:
if port_scan(ip, port):
result = f"{ip}:{port}"
try:
with open(OUTPUT_FILE, "a", encoding="utf-8") as f:
f.write(result + "\n")
except:
pass
return result
return None

def ip_generator(blocks):
for block in blocks:
try:
network = ip_network(block, strict=False)
for ip in network:
if not running:
return
yield str(ip)
except:
continue

if __name__ == "__main__":
app = QApplication(sys.argv)
font = QFont("Consolas", 10)
app.setFont(font)
win = MatrixScannerGUI()
win.show()
sys.exit(app.exec_())
 
Üst Alt