511 Zeilen
19 KiB
Python
511 Zeilen
19 KiB
Python
# social_networks/x/x_verification.py
|
|
|
|
"""
|
|
X (Twitter) Verification - Klasse für Account-Verifizierungsprozesse bei X
|
|
"""
|
|
|
|
import time
|
|
import re
|
|
from typing import Dict, Any, Optional, List
|
|
|
|
from .x_selectors import XSelectors
|
|
from .x_workflow import XWorkflow
|
|
from utils.logger import setup_logger
|
|
|
|
# Konfiguriere Logger
|
|
logger = setup_logger("x_verification")
|
|
|
|
class XVerification:
|
|
"""
|
|
Klasse für die Verifizierung von X-Konten.
|
|
Behandelt verschiedene Verifizierungsmethoden und Sicherheitsabfragen.
|
|
"""
|
|
|
|
def __init__(self, automation):
|
|
"""
|
|
Initialisiert die X-Verifizierung.
|
|
|
|
Args:
|
|
automation: Referenz auf die Hauptautomatisierungsklasse
|
|
"""
|
|
self.automation = automation
|
|
self.selectors = XSelectors()
|
|
self.workflow = XWorkflow.get_verification_workflow()
|
|
|
|
logger.debug("X-Verifizierung initialisiert")
|
|
|
|
def verify_account(self, verification_code: str = None, **kwargs) -> Dict[str, Any]:
|
|
"""
|
|
Führt den Verifizierungsprozess für einen X-Account durch.
|
|
|
|
Args:
|
|
verification_code: Optionaler Verifizierungscode
|
|
**kwargs: Weitere Parameter (method, phone_number, email)
|
|
|
|
Returns:
|
|
Dict[str, Any]: Ergebnis der Verifizierung
|
|
"""
|
|
logger.info("Starte X-Account-Verifizierung")
|
|
|
|
try:
|
|
# Prüfe welche Art von Verifizierung benötigt wird
|
|
verification_type = self._detect_verification_type()
|
|
|
|
if not verification_type:
|
|
logger.info("Keine Verifizierung erforderlich")
|
|
return {
|
|
"success": True,
|
|
"message": "Keine Verifizierung erforderlich"
|
|
}
|
|
|
|
logger.info(f"Verifizierungstyp erkannt: {verification_type}")
|
|
self.automation._emit_customer_log(f"🔐 Verifizierung erforderlich: {verification_type}")
|
|
|
|
# Führe entsprechende Verifizierung durch
|
|
if verification_type == "email":
|
|
return self._handle_email_verification(verification_code, **kwargs)
|
|
elif verification_type == "phone":
|
|
return self._handle_phone_verification(verification_code, **kwargs)
|
|
elif verification_type == "captcha":
|
|
return self._handle_captcha_verification()
|
|
elif verification_type == "arkose":
|
|
return self._handle_arkose_challenge()
|
|
else:
|
|
return {
|
|
"success": False,
|
|
"error": f"Unbekannter Verifizierungstyp: {verification_type}"
|
|
}
|
|
|
|
except Exception as e:
|
|
error_msg = f"Unerwarteter Fehler bei der Verifizierung: {str(e)}"
|
|
logger.error(error_msg, exc_info=True)
|
|
|
|
return {
|
|
"success": False,
|
|
"error": error_msg,
|
|
"stage": "exception"
|
|
}
|
|
|
|
def _detect_verification_type(self) -> Optional[str]:
|
|
"""
|
|
Erkennt welche Art von Verifizierung benötigt wird.
|
|
|
|
Returns:
|
|
Optional[str]: Verifizierungstyp oder None
|
|
"""
|
|
try:
|
|
page = self.automation.browser.page
|
|
|
|
# E-Mail-Verifizierung
|
|
if page.is_visible(self.selectors.REGISTRATION["verification_code_input"], timeout=2000):
|
|
return "email"
|
|
|
|
# Telefon-Verifizierung
|
|
if page.is_visible(self.selectors.VERIFICATION["phone_verification_input"], timeout=2000):
|
|
return "phone"
|
|
|
|
# Captcha
|
|
if page.is_visible(self.selectors.VERIFICATION["captcha_frame"], timeout=2000):
|
|
return "captcha"
|
|
|
|
# Arkose Challenge
|
|
if page.is_visible(self.selectors.VERIFICATION["challenge_frame"], timeout=2000):
|
|
return "arkose"
|
|
|
|
# Prüfe auf Text-Hinweise
|
|
if page.is_visible('text="Verifiziere deine E-Mail"', timeout=1000):
|
|
return "email"
|
|
if page.is_visible('text="Verifiziere deine Telefonnummer"', timeout=1000):
|
|
return "phone"
|
|
|
|
return None
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler bei Verifizierungstyp-Erkennung: {e}")
|
|
return None
|
|
|
|
def _handle_email_verification(self, verification_code: str = None, **kwargs) -> Dict[str, Any]:
|
|
"""
|
|
Behandelt E-Mail-Verifizierung.
|
|
|
|
Args:
|
|
verification_code: Verifizierungscode
|
|
**kwargs: Weitere Parameter (email)
|
|
|
|
Returns:
|
|
Dict[str, Any]: Ergebnis der Verifizierung
|
|
"""
|
|
try:
|
|
page = self.automation.browser.page
|
|
|
|
# Wenn kein Code übergeben wurde, versuche ihn abzurufen
|
|
if not verification_code:
|
|
email = kwargs.get("email")
|
|
if not email:
|
|
return {
|
|
"success": False,
|
|
"error": "E-Mail-Adresse für Verifizierung fehlt"
|
|
}
|
|
|
|
self.automation._emit_customer_log("📧 Warte auf Verifizierungs-E-Mail...")
|
|
verification_code = self._retrieve_email_code(email)
|
|
|
|
if not verification_code:
|
|
return {
|
|
"success": False,
|
|
"error": "Konnte keinen Verifizierungscode aus E-Mail abrufen"
|
|
}
|
|
|
|
# Code eingeben
|
|
self.automation._emit_customer_log(f"✍️ Gebe Verifizierungscode ein: {verification_code}")
|
|
if not self._enter_verification_code(verification_code):
|
|
return {
|
|
"success": False,
|
|
"error": "Fehler beim Eingeben des Verifizierungscodes"
|
|
}
|
|
|
|
# Bestätigen
|
|
if not self._submit_verification():
|
|
return {
|
|
"success": False,
|
|
"error": "Fehler beim Bestätigen der Verifizierung"
|
|
}
|
|
|
|
# Warte auf Erfolg
|
|
if self._check_verification_success():
|
|
logger.info("E-Mail-Verifizierung erfolgreich")
|
|
self.automation._emit_customer_log("✅ E-Mail erfolgreich verifiziert!")
|
|
return {
|
|
"success": True,
|
|
"method": "email",
|
|
"code": verification_code
|
|
}
|
|
else:
|
|
return {
|
|
"success": False,
|
|
"error": "Verifizierung fehlgeschlagen"
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler bei E-Mail-Verifizierung: {e}")
|
|
return {
|
|
"success": False,
|
|
"error": f"E-Mail-Verifizierung fehlgeschlagen: {str(e)}"
|
|
}
|
|
|
|
def _handle_phone_verification(self, verification_code: str = None, **kwargs) -> Dict[str, Any]:
|
|
"""
|
|
Behandelt Telefon-Verifizierung.
|
|
|
|
Args:
|
|
verification_code: Verifizierungscode
|
|
**kwargs: Weitere Parameter (phone_number)
|
|
|
|
Returns:
|
|
Dict[str, Any]: Ergebnis der Verifizierung
|
|
"""
|
|
try:
|
|
page = self.automation.browser.page
|
|
|
|
# Telefonnummer eingeben wenn erforderlich
|
|
phone_number = kwargs.get("phone_number")
|
|
if phone_number and page.is_visible(self.selectors.VERIFICATION["phone_verification_input"]):
|
|
logger.info(f"Gebe Telefonnummer ein: {phone_number}")
|
|
phone_input = page.wait_for_selector(self.selectors.VERIFICATION["phone_verification_input"])
|
|
self.automation.human_behavior.type_text(phone_input, phone_number)
|
|
|
|
# Code senden
|
|
if page.is_visible(self.selectors.VERIFICATION["send_code_button"]):
|
|
page.click(self.selectors.VERIFICATION["send_code_button"])
|
|
self.automation.human_behavior.random_delay(2, 3)
|
|
|
|
# Wenn kein Code übergeben wurde, warte auf manuelle Eingabe
|
|
if not verification_code:
|
|
self.automation._emit_customer_log("📱 Bitte gib den SMS-Code manuell ein...")
|
|
# Warte bis Code eingegeben wurde (max 5 Minuten)
|
|
start_time = time.time()
|
|
while time.time() - start_time < 300: # 5 Minuten
|
|
code_input = page.query_selector(self.selectors.VERIFICATION["verification_code_input"])
|
|
if code_input:
|
|
current_value = code_input.get_attribute("value")
|
|
if current_value and len(current_value) >= 6:
|
|
verification_code = current_value
|
|
break
|
|
time.sleep(2)
|
|
|
|
if not verification_code:
|
|
return {
|
|
"success": False,
|
|
"error": "Kein SMS-Code eingegeben (Timeout)"
|
|
}
|
|
else:
|
|
# Code eingeben
|
|
self.automation._emit_customer_log(f"✍️ Gebe SMS-Code ein: {verification_code}")
|
|
if not self._enter_verification_code(verification_code):
|
|
return {
|
|
"success": False,
|
|
"error": "Fehler beim Eingeben des SMS-Codes"
|
|
}
|
|
|
|
# Bestätigen
|
|
if not self._submit_verification():
|
|
return {
|
|
"success": False,
|
|
"error": "Fehler beim Bestätigen der Telefon-Verifizierung"
|
|
}
|
|
|
|
# Warte auf Erfolg
|
|
if self._check_verification_success():
|
|
logger.info("Telefon-Verifizierung erfolgreich")
|
|
self.automation._emit_customer_log("✅ Telefonnummer erfolgreich verifiziert!")
|
|
return {
|
|
"success": True,
|
|
"method": "phone",
|
|
"phone_number": phone_number
|
|
}
|
|
else:
|
|
return {
|
|
"success": False,
|
|
"error": "Telefon-Verifizierung fehlgeschlagen"
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler bei Telefon-Verifizierung: {e}")
|
|
return {
|
|
"success": False,
|
|
"error": f"Telefon-Verifizierung fehlgeschlagen: {str(e)}"
|
|
}
|
|
|
|
def _handle_captcha_verification(self) -> Dict[str, Any]:
|
|
"""
|
|
Behandelt Captcha-Verifizierung.
|
|
|
|
Returns:
|
|
Dict[str, Any]: Ergebnis der Verifizierung
|
|
"""
|
|
try:
|
|
logger.warning("Captcha-Verifizierung erkannt")
|
|
self.automation._emit_customer_log("🤖 Captcha erkannt - manuelle Lösung erforderlich")
|
|
|
|
# Screenshot für Debugging
|
|
self.automation._take_screenshot("captcha_challenge")
|
|
|
|
# Hier könnte Integration mit Captcha-Solving-Service erfolgen
|
|
# Für jetzt: Warte auf manuelle Lösung
|
|
|
|
return {
|
|
"success": False,
|
|
"error": "Captcha-Lösung erforderlich - bitte manuell lösen",
|
|
"type": "captcha",
|
|
"manual_intervention_required": True
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler bei Captcha-Behandlung: {e}")
|
|
return {
|
|
"success": False,
|
|
"error": f"Captcha-Behandlung fehlgeschlagen: {str(e)}"
|
|
}
|
|
|
|
def _handle_arkose_challenge(self) -> Dict[str, Any]:
|
|
"""
|
|
Behandelt Arkose Labs Challenge.
|
|
|
|
Returns:
|
|
Dict[str, Any]: Ergebnis der Verifizierung
|
|
"""
|
|
try:
|
|
logger.warning("Arkose Challenge erkannt")
|
|
self.automation._emit_customer_log("🛡️ Arkose Challenge erkannt - erweiterte Verifizierung erforderlich")
|
|
|
|
# Screenshot für Debugging
|
|
self.automation._take_screenshot("arkose_challenge")
|
|
|
|
return {
|
|
"success": False,
|
|
"error": "Arkose Challenge erkannt - manuelle Intervention erforderlich",
|
|
"type": "arkose",
|
|
"manual_intervention_required": True
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler bei Arkose Challenge: {e}")
|
|
return {
|
|
"success": False,
|
|
"error": f"Arkose Challenge fehlgeschlagen: {str(e)}"
|
|
}
|
|
|
|
def _retrieve_email_code(self, email: str) -> Optional[str]:
|
|
"""
|
|
Ruft Verifizierungscode aus E-Mail ab.
|
|
|
|
Args:
|
|
email: E-Mail-Adresse
|
|
|
|
Returns:
|
|
Optional[str]: Verifizierungscode oder None
|
|
"""
|
|
try:
|
|
logger.info(f"Rufe Verifizierungscode für {email} ab")
|
|
|
|
# Warte auf E-Mail
|
|
self.automation.human_behavior.random_delay(5, 10)
|
|
|
|
# Hole E-Mails
|
|
emails = self.automation.email_handler.get_emails(
|
|
email,
|
|
subject_filter="X Verifizierungscode"
|
|
)
|
|
|
|
if not emails:
|
|
# Versuche alternative Betreff-Filter
|
|
emails = self.automation.email_handler.get_emails(
|
|
email,
|
|
subject_filter="Twitter"
|
|
)
|
|
|
|
if not emails:
|
|
logger.error("Keine Verifizierungs-E-Mail gefunden")
|
|
return None
|
|
|
|
# Extrahiere Code aus der neuesten E-Mail
|
|
latest_email = emails[0]
|
|
subject = latest_email.get('subject', '')
|
|
body = latest_email.get('body', '')
|
|
|
|
# Suche nach 6-stelligem Code
|
|
# Erst im Betreff
|
|
code_match = re.search(r'(\d{6})', subject)
|
|
if code_match:
|
|
code = code_match.group(1)
|
|
logger.info(f"Code aus Betreff extrahiert: {code}")
|
|
return code
|
|
|
|
# Dann im Body
|
|
code_match = re.search(r'(\d{6})', body)
|
|
if code_match:
|
|
code = code_match.group(1)
|
|
logger.info(f"Code aus E-Mail-Body extrahiert: {code}")
|
|
return code
|
|
|
|
logger.error("Konnte keinen Code aus E-Mail extrahieren")
|
|
return None
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Abrufen des E-Mail-Codes: {e}")
|
|
return None
|
|
|
|
def _enter_verification_code(self, code: str) -> bool:
|
|
"""
|
|
Gibt einen Verifizierungscode ein.
|
|
|
|
Args:
|
|
code: Verifizierungscode
|
|
|
|
Returns:
|
|
bool: True bei Erfolg
|
|
"""
|
|
try:
|
|
page = self.automation.browser.page
|
|
|
|
# Finde Code-Eingabefeld
|
|
code_selectors = [
|
|
self.selectors.REGISTRATION["verification_code_input"],
|
|
self.selectors.VERIFICATION["verification_code_input"],
|
|
'input[autocomplete="one-time-code"]',
|
|
'input[name="code"]'
|
|
]
|
|
|
|
for selector in code_selectors:
|
|
try:
|
|
code_input = page.wait_for_selector(selector, timeout=3000)
|
|
if code_input:
|
|
logger.info(f"Code-Eingabefeld gefunden: {selector}")
|
|
self.automation.human_behavior.type_text(code_input, code)
|
|
self.automation.human_behavior.random_delay(0.5, 1)
|
|
return True
|
|
except:
|
|
continue
|
|
|
|
logger.error("Kein Code-Eingabefeld gefunden")
|
|
return False
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Eingeben des Codes: {e}")
|
|
return False
|
|
|
|
def _submit_verification(self) -> bool:
|
|
"""
|
|
Bestätigt die Verifizierung.
|
|
|
|
Returns:
|
|
bool: True bei Erfolg
|
|
"""
|
|
try:
|
|
page = self.automation.browser.page
|
|
|
|
# Submit-Button Selektoren
|
|
submit_selectors = [
|
|
'button:has-text("Weiter")',
|
|
'button:has-text("Bestätigen")',
|
|
'button:has-text("Verifizieren")',
|
|
'button:has-text("Next")',
|
|
'button:has-text("Verify")',
|
|
'button:has-text("Submit")'
|
|
]
|
|
|
|
for selector in submit_selectors:
|
|
if page.is_visible(selector, timeout=2000):
|
|
logger.info(f"Submit-Button gefunden: {selector}")
|
|
page.click(selector)
|
|
self.automation.human_behavior.random_delay(2, 3)
|
|
return True
|
|
|
|
# Alternativ: Enter drücken
|
|
page.keyboard.press("Enter")
|
|
logger.info("Enter gedrückt zur Bestätigung")
|
|
return True
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Bestätigen: {e}")
|
|
return False
|
|
|
|
def _check_verification_success(self) -> bool:
|
|
"""
|
|
Prüft ob Verifizierung erfolgreich war.
|
|
|
|
Returns:
|
|
bool: True bei Erfolg
|
|
"""
|
|
try:
|
|
page = self.automation.browser.page
|
|
|
|
# Warte auf Weiterleitung oder Erfolgsmeldung
|
|
self.automation.human_behavior.random_delay(2, 3)
|
|
|
|
# Erfolgsindikatoren
|
|
success_indicators = [
|
|
# Fehlen von Verifizierungsfeldern
|
|
lambda: not page.is_visible(self.selectors.REGISTRATION["verification_code_input"], timeout=2000),
|
|
# Vorhandensein von Account-Elementen
|
|
lambda: page.is_visible(self.selectors.NAVIGATION["home_link"], timeout=2000),
|
|
# URL-Änderung
|
|
lambda: "/home" in page.url or "/welcome" in page.url
|
|
]
|
|
|
|
for indicator in success_indicators:
|
|
if indicator():
|
|
logger.info("Verifizierung erfolgreich")
|
|
return True
|
|
|
|
# Prüfe auf Fehlermeldungen
|
|
error_msg = self.automation.ui_helper.check_for_errors()
|
|
if error_msg:
|
|
logger.error(f"Verifizierungsfehler: {error_msg}")
|
|
return False
|
|
|
|
return False
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler bei Erfolgsprüfung: {e}")
|
|
return False |