cursor.execute(''' INSERT INTO analyses (user_id, content_type, content_preview, risk_level, risk_score, analysis_result) VALUES (?, ?, ?, ?, ?, ?) ''', (current_session["user_id"], content_type, content_preview[:200], risk_level, risk_score, analysis_result)) conn.commit() conn.close() except Exception as e: print(f"Error guardando : {e}") def get_user_profile(): """Obtiene información completa del perfil del usuario""" if not current_session["logged_in"]: return None try: conn = sqlite3.connect(DATABASE_FILE) cursor = conn.cursor() # Obtener datos del usuario cursor.execute(''' SELECT email, full_name, avatar_url, is_pro, created_at, last_login, subscription_expires, total_analyses FROM users WHERE id = ? ''', (current_session["user_id"],)) user_data = cursor.fetchone() if not user_data: conn.close() return None # Obtener estadísticas de análisis cursor.execute(''' SELECT COUNT(*) as total, SUM(CASE WHEN risk_level = 'ALTO' THEN 1 ELSE 0 END) as high_risk, SUM(CASE WHEN risk_level = 'MEDIO' THEN 1 ELSE 0 END) as medium_risk, SUM(CASE WHEN risk_level = 'BAJO' THEN 1 ELSE 0 END) as low_risk FROM analyses WHERE user_id = ? ''', (current_session["user_id"],)) stats = cursor.fetchone() # Obtener historial reciente cursor.execute(''' SELECT content_type, content_preview, risk_level, risk_score, created_at FROM analyses WHERE user_id = ? ORDER BY created_at DESC LIMIT 10 ''', (current_session["user_id"],)) recent_analyses = cursor.fetchall() conn.close() email, full_name, avatar_url, is_pro, created_at, last_login, sub_expires, total_analyses = user_data total, high_risk, medium_risk, low_risk = stats or (0, 0, 0, 0) return { "email": email, "full_name": full_name, "avatar_url": avatar_url or "", "is_pro": is_pro, "created_at": created_at, "last_login": last_login, "subscription_expires": sub_expires, "total_analyses": total_analyses or 0, "stats": { "total": total or 0, "high_risk": high_risk or 0, "medium_risk": medium_risk or 0, "low_risk": low_risk or 0 }, "recent_analyses": recent_analyses } except Exception as e: print(f"Error obteniendo perfil: {e}") return None def chat_interface(message, files, history): """Interfaz principal del chat con análisis avanzado""" global current_session # Verificar autenticación if not current_session["logged_in"]: auth_message = """

🔐 Acceso Requerido

Debes iniciar sesión para usar AntiScam AI

¿Ya tienes cuenta? Inicia sesión

¿Nuevo usuario? Regístrate gratis

""" history.append([message or "Análisis solicitado", auth_message]) return "", history, None # Verificar límites de uso can_use, reason = can_analyze() if not can_use: if reason == "Límite diario alcanzado": upgrade_message = f"""

⛔ Límite Diario Alcanzado

Has usado tus {DAILY_FREE_LIMIT} análisis gratuitos de hoy.

🚀 Actualiza a AntiScam AI Pro

${PRO_PRICE}/mes + 7 días gratis
✅ Análisis ilimitados
🧠 IA más avanzada
📊 Informes detallados
🔍 OCR para imágenes
🎵 Análisis de audio
📞 Soporte prioritario
📈 Estadísticas avanzadas
🔄 Historial completo

Límite se renueva mañana a las 00:00

""" history.append([message or "Límite alcanzado", upgrade_message]) return "", history, None # Procesar contenido content_to_analyze = "" content_type = "texto" if message and message.strip(): content_to_analyze = message content_type = "texto" # Procesar archivos (simulado por ahora) file_results = [] if files: for file in files: file_path = getattr(file, 'name', str(file)) if file else "" if not file_path: continue file_extension = file_path.lower().split('.')[-1] if '.' in file_path else '' if file_extension in ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp']: # Simular OCR extracted_text = "Premio de $5000 - Haz clic para reclamar ahora - Oferta válida solo hoy" file_results.append(f"📸 **Imagen analizada:** {extracted_text}") content_to_analyze += f" [IMAGEN: {extracted_text}]" content_type = "imagen con texto" elif file_extension in ['mp3', 'wav', 'ogg', 'm4a', 'flac']: # Simular transcripción transcribed_text = "Felicidades, ha ganado un premio especial. Proporcione sus datos bancarios para procesar el pago inmediatamente." file_results.append(f"🎵 **Audio transcrito:** {transcribed_text}") content_to_analyze += f" [AUDIO: {transcribed_text}]" content_type = "audio transcrito" # Verificar contenido válido if not content_to_analyze.strip(): error_message = """

⚠️ Contenido requerido

Para realizar un análisis, envía:

Ejemplo: "He recibido este SMS: 'Felicidades, has ganado $10,000. Haz clic aquí para reclamar'"

""" history.append([message or "Sin contenido", error_message]) return "", history, None # Realizar análisis avanzado analysis = advanced_scam_analysis(content_to_analyze, content_type) # Incrementar uso y guardar análisis increment_usage() save_analysis( content_type=content_type, content_preview=content_to_analyze[:200], risk_level=analysis["risk_level"], risk_score=analysis["risk_score"], analysis_result=str(analysis) ) # Formatear resultado analysis_result = format_analysis_result(analysis) # Agregar información de archivos si los hay if file_results: file_info = "
".join(file_results) analysis_result = f"""

📁 Archivos Procesados

{file_info}
{analysis_result} """ # Información del usuario y uso remaining = DAILY_FREE_LIMIT - current_session["daily_usage"] if not current_session["is_pro"] else "∞" status_icon = "👑" if current_session["is_pro"] else "🆓" plan_name = "PRO" if current_session["is_pro"] else "FREE" user_info = f"""
{status_icon} {current_session['full_name']} {plan_name}
Análisis restantes hoy: {remaining}
Total realizados: {current_session.get('total_analyses', 0)}
""" final_result = analysis_result + user_info # Agregar a historial user_message = message or "📎 Archivo analizado" history.append([user_message, final_result]) return "", history, None def create_profile_interface(): """Crea la interfaz del perfil de usuario""" profile_data = get_user_profile() if not profile_data: return "❌ Error cargando perfil" # Calcular estadísticas stats = profile_data["stats"] total_analyses = stats["total"] if total_analyses > 0: high_risk_pct = (stats["high_risk"] / total_analyses) * 100 medium_risk_pct = (stats["medium_risk"] / total_analyses) * 100 low_risk_pct = (stats["low_risk"] / total_analyses) * 100 else: high_risk_pct = medium_risk_pct = low_risk_pct = 0 # Formatear fechas created_date = datetime.fromisoformat(profile_data["created_at"]).strftime("%d/%m/%Y") last_login_date = datetime.fromisoformat(profile_data["last_login"]).strftime("%d/%m/%Y %H:%M") if profile_data["last_login"] else "Nunca" # Información de suscripción if profile_data["is_pro"] and profile_data["subscription_expires"]: sub_expires = datetime.fromisoformat(profile_data["subscription_expires"]).strftime("%d/%m/%Y") subscription_info = f"""

👑 Suscripción Pro Activa

✅ Análisis ilimitados

📅 Renovación: {sub_expires}

""" else: subscription_info = f"""

🆓 Plan Gratuito

📊 {DAILY_FREE_LIMIT} análisis por día

🔄 Se renueva diariamente

""" # Historial reciente recent_html = "" if profile_data["recent_analyses"]: recent_html = "

📊 Análisis Recientes

" for analysis in profile_data["recent_analyses"][:5]: content_type, content_preview, risk_level, risk_score, created_at = analysis date = datetime.fromisoformat(created_at).strftime("%d/%m %H:%M") risk_color = {"ALTO": "#dc3545", "MEDIO": "#fd7e14", "BAJO": "#28a745"}.get(risk_level, "#6c757d") risk_emoji = {"ALTO": "🔴", "MEDIO": "🟡", "BAJO": "🟢"}.get(risk_level, "⚪") recent_html += f"""
{risk_emoji} {risk_level} ({risk_score}/100)
{content_preview[:60]}...
{date}
""" return f"""
👤

{profile_data['full_name']}

{profile_data['email']}

{total_analyses}
Análisis totales
{created_date}
Miembro desde
{last_login_date.split()[0] if last_login_date != 'Nunca' else 'Hoy'}
Último acceso
{subscription_info}

📈 Estadísticas de Análisis

{stats['high_risk']}
🔴 Alto Riesgo
{high_risk_pct:.1f}%
{stats['medium_risk']}
🟡 Riesgo Medio
{medium_risk_pct:.1f}%
{stats['low_risk']}
🟢 Bajo Riesgo
{low_risk_pct:.1f}%
{recent_html}

⚙️ Configuración de Cuenta

""" def create_payment_interface(): """Crea la interfaz de pago con Stripe y PayPal""" if not current_session["logged_in"]: return "❌ Debes iniciar sesión para acceder a los planes de pago" payment_status = "✅ Stripe configurado" if PAYMENTS_ENABLED else "⚠️ Pagos no configurados" return f"""

🚀 Actualizar a AntiScam AI Pro

Protección ilimitada contra estafas digitales

{payment_status}

🆓 Plan Gratuito

$0

por mes

  • ✅ {DAILY_FREE_LIMIT} análisis por día
  • ✅ Detección básica de estafas
  • ✅ Análisis de texto
  • ❌ Análisis de imágenes
  • ❌ Análisis de audio
  • ❌ Informes detallados
  • ❌ Soporte prioritario
⭐ RECOMENDADO

👑 Plan Pro

${PRO_PRICE}

por mes

+ 7 días GRATIS

  • ✅ Análisis ILIMITADOS
  • ✅ IA avanzada con mayor precisión
  • ✅ Análisis de imágenes (OCR)
  • ✅ Análisis de audio
  • ✅ Informes detallados
  • ✅ Historial completo
  • ✅ Soporte prioritario 24/7
  • ✅ Estadísticas avanzadas
  • ✅ Exportar informes

💳 Métodos de Pago

{"" if PAYMENTS_ENABLED else '
⚠️ Los pagos no están configurados en el servidor. Contacta al administrador.
'}
💳

Tarjeta de Crédito/Débito

Procesado por Stripe

  • 🔒 Pago 100% seguro
  • 💳 Visa, Mastercard, Amex
  • ⚡ Activación inmediata
🏦

PayPal

Pago seguro con PayPal

  • 🔒 Protección del comprador
  • 💼 Sin compartir datos bancarios
  • 🌍 Aceptado mundialmente

🛡️ Garantías de Seguridad

🔒 Encriptación SSL 256-bit
Tus datos están protegidos
💳 PCI DSS Compliant
Estándares bancarios
🔄 Cancela cuando quieras
Sin compromisos largos
📞 Soporte 24/7
Ayuda cuando la necesites

Al suscribirte aceptas nuestros Términos de Servicio y Política de Privacidad

""" def logout_user(): """Cierra sesión del usuario""" global current_session current_session = { "logged_in": False, "user_id": None, "email": "", "full_name": "", "is_pro": False, "avatar_url": "", "subscription_expires": None, "daily_usage": 0 } return "✅ Sesión cerrada correctamente" def handle_register(email, password, confirm_password, full_name): """Maneja el registro de usuario""" if not all([email, password, confirm_password, full_name]): return "❌ Todos los campos son obligatorios", gr.update(visible=True), gr.update(visible=False) if password != confirm_password: return "❌ Las contraseñas no coinciden", gr.update(visible=True), gr.update(visible=False) if len(password) < 8: return "❌ La contraseña debe tener al menos 8 caracteres", gr.update(visible=True), gr.update(visible=False) success, message = register_user(email, password, full_name) if success: return message, gr.update(visible=True), gr.update(visible=False) else: return message, gr.update(visible=True), gr.update(visible=False) def handle_login(email, password): """Maneja el login de usuario""" if not email or not password: return "❌ Email y contraseña son obligatorios", gr.update(visible=True), gr.update(visible=False) success, message = login_user(email, password) if success: return message, gr.update(visible=False), gr.update(visible=True) else: return message, gr.update(visible=True), gr.update(visible=False) def handle_verification(token): """Maneja la verificación de email""" if not token: return "❌ Token de verificación requerido" success, message = verify_user_email(token) return message # CSS personalizado mejorado custom_css = """ .gradio-container { max-width: 1400px !important; margin: auto !important; font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; } .main-header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 2.5rem; border-radius: 20px; text-align: center; margin-bottom: 2rem; box-shadow: 0 10px 30px rgba(102, 126, 234, 0.3); } .auth-container { max-width: 500px; margin: 0 auto; background: white; padding: 2rem; border-radius: 15px; box-shadow: 0 8px 25px rgba(0,0,0,0.1); } .chat-container { background: white; border-radius: 15px; box-shadow: 0 4px 15px rgba(0,0,0,0.1); overflow: hidden; } .profile-header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 2rem; text-align: center; } .stats-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin: 1rem 0; } .stat-card { background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%); padding: 1.5rem; border-radius: 12px; text-align: center; border: 1px solid #dee2e6; } .pro-badge { background: linear-gradient(135deg, #ffd700 0%, #ffed4e 100%); color: #333; padding: 0.25rem 0.75rem; border-radius: 20px; font-size: 0.75em; font-weight: bold; display: inline-block; } .free-badge { background: #6c757d; color: white; padding: 0.25rem 0.75rem; border-radius: 20px; font-size: 0.75em; font-weight: bold; display: inline-block; } .risk-high { color: #dc3545 !important; } .risk-medium { color: #fd7e14 !important; } .risk-low { color: #28a745 !important; } @media (max-width: 768px) { .gradio-container { padding: 1rem; } .main-header { padding: 1.5rem; } .auth-container { padding: 1.5rem; } } """ def create_interface(): """Crea la interfaz completa de AntiScam AI""" # Inicializar sistema init_database() load_ai_model() with gr.Blocks(css=custom_css, title="🛡️ AntiScam AI Pro", theme=gr.themes.Soft()) as app: # Header principal gr.HTML("""

🛡️ AntiScam AI

Protección inteligente contra estafas digitales

🤖 Powered by IA avanzada • 🔒 Análisis ético y profesional • 🌍 Protección global

""") # Estado de la aplicación app_state = gr.State({"current_view": "auth"}) # Sección de autenticación with gr.Column(visible=True) as auth_section: with gr.Row(): with gr.Column(scale=1): pass # Espaciado with gr.Column(scale=2): gr.HTML('
') with gr.Tab("🔑 Iniciar Sesión") as login_tab: with gr.Column(): login_email = gr.Textbox( label="📧 Email", placeholder="tu@email.com", type="email" ) login_password = gr.Textbox( label="🔒 Contraseña", placeholder="Tu contraseña", type="password" ) login_btn = gr.Button( "🔑 Iniciar Sesión", variant="primary", size="lg" ) login_output = gr.Markdown() with gr.Tab("📝 Crear Cuenta") as register_tab: with gr.Column(): reg_name = gr.Textbox( label="👤 Nombre completo", placeholder="Ej: Juan Pérez" ) reg_email = gr.Textbox( label="📧 Email", placeholder="tu@email.com", type="email" ) reg_password = gr.Textbox( label="🔒 Contraseña", placeholder="Mínimo 8 caracteres", type="password" ) reg_confirm = gr.Textbox( label="🔒 Confirmar contraseña", placeholder="Repite tu contraseña", type="password" ) register_btn = gr.Button( "📝 Crear cuenta gratuita", variant="primary", size="lg" ) register_output = gr.Markdown() with gr.Tab("✅ Verificar Email") as verify_tab: with gr.Column(): verify_token = gr.Textbox( label="🔑 Token de verificación", placeholder="Pega aquí el token del email" ) verify_btn = gr.Button( "✅ Verificar cuenta", variant="primary" ) verify_output = gr.Markdown() gr.HTML('
') with gr.Column(scale=1): pass # Espaciado # Aplicación principal (inicialmente oculta) with gr.Column(visible=False) as main_app: # Navegación with gr.Row(): nav_chat = gr.Button("💬 Chat", variant="primary") nav_profile = gr.Button("👤 Perfil", variant="secondary") nav_payment = gr.Button("💳 Pro", variant="secondary") nav_logout = gr.Button("🚪 Salir", variant="secondary") # Chat principal with gr.Column(visible=True) as chat_section: gr.HTML('
') # Mensaje de bienvenida personalizado welcome_html = f"""

🎉 ¡Bienvenido a AntiScam AI!

Estás protegido con nuestro sistema de IA avanzada. Como usuario FREE, tienes {DAILY_FREE_LIMIT} análisis gratuitos por día.

🚀 ¿Cómo empezar?

  • 📱 Copia un mensaje sospechoso que hayas recibido
  • 📸 Sube una captura de WhatsApp, email o SMS
  • 🎵 Comparte un audio de llamada sospechosa
  • 📝 Describe la situación que te resulta extraña

💡 Ejemplos de análisis:

• "Has ganado $10,000. Haz clic aquí para reclamar"
• "Tu cuenta será suspendida. Confirma tus datos"
• "Inversión garantizada con 500% de retorno"
• "Soporte técnico de Microsoft. Tu PC está infectado"

💬 ¡Envía tu primer mensaje para comenzar!

""" chatbot = gr.Chatbot( value=[["👋 ¡Hola! ¿Cómo funciona AntiScam AI?", welcome_html]], height=550, show_label=False, avatar_images=("👤", "🛡️"), bubble_full_width=False ) with gr.Row(): with gr.Column(scale=4): msg = gr.Textbox( placeholder="💬 Describe o pega aquí el contenido sospechoso que quieres analizar...", show_label=False, lines=3, max_lines=5 ) with gr.Column(scale=1): files = gr.File( file_count="multiple", file_types=["image", "audio"], label="📎 Archivos", show_label=True ) with gr.Row(): send_btn = gr.Button( "🔍 Analizar con IA", variant="primary", size="lg", scale=2 ) clear_btn = gr.Button( "🗑️ Limpiar", variant="secondary", scale=1 ) gr.HTML('
') # Sección de perfil (inicialmente oculta) with gr.Column(visible=False) as profile_section: profile_content = gr.HTML() # Sección de pagos (inicialmente oculta) with gr.Column(visible=False) as payment_section: payment_content = gr.HTML() # Conectar eventos # Autenticación register_btn.click( fn=handle_register, inputs=[reg_email, reg_password, reg_confirm, reg_name], outputs=[register_output, auth_section, main_app] ) login_btn.click( fn=handle_login, inputs=[login_email, login_password], outputs=[login_output, auth_section, main_app] ) verify_btn.click( fn=handle_verification, inputs=[verify_token], outputs=[verify_output] ) # Chat send_btn.click( fn=chat_interface, inputs=[msg, files, chatbot], outputs=[msg, chatbot, files] ) msg.submit( fn=chat_interface, inputs=[msg, files, chatbot], outputs=[msg, chatbot, files] ) clear_btn.click( fn=lambda: ("", [], None), outputs=[msg, chatbot, files] ) # Navegación def show_chat(): return ( gr.update(visible=True), gr.update(visible=False), gr.update(visible=False), gr.update(variant="primary"), gr.update(variant="secondary"), gr.update(variant="secondary") ) def show_profile(): profile_html = create_profile_interface() return ( gr.update(visible=False), gr.update(visible=True, value=profile_html), gr.update(visible=False), gr.update(variant="secondary"), gr.update(variant="primary"), gr.update(variant="secondary") ) def show_payment(): payment_html = create_payment_interface() return ( gr.update(visible=False), gr.update(visible=False), gr.update(visible=True, value=payment_html), gr.update(variant="secondary"), gr.update(variant="secondary"), gr.update(variant="primary") ) def handle_logout(): logout_message = logout_user() return ( gr.update(visible=True), gr.update(visible=False), logout_message ) nav_chat.click( fn=show_chat, outputs=[chat_section, profile_section, payment_section, nav_chat, nav_profile, nav_payment] ) nav_profile.click( fn=show_profile, outputs=[chat_section, profile_section, payment_section, nav_chat, nav_profile, nav_payment] ) nav_payment.click( fn=show_payment, outputs=[chat_section, profile_section, payment_section, nav_chat, nav_profile, nav_payment] ) nav_logout.click( fn=handle_logout, outputs=[auth_section, main_app, login_output] ) # Footer informativo gr.HTML("""

🛡️ AntiScam AI - Tu escudo digital

🔒 Seguridad

Tus datos están protegidos con encriptación de nivel bancario

🤖 IA Ética

Análisis responsable y educativo para empoderar usuarios

🌍 Global

Protección contra estafas en múltiples idiomas y regiones

© 2024 AntiScam AI • TérminosPrivacidadContacto

📧 support@antiscam.ai • 🌐 antiscam.ai

""") return app # Lanzar aplicación if __name__ == "__main__": print("🚀 Iniciando AntiScam AI Pro...") app = create_interface() app.launch( server_name="0.0.0.0", server_port=7860, share=True, show_error=True, show_tips=True )import gradio as gr import json import os import sqlite3 import hashlib import uuid import smtplib import secrets import stripe from datetime import datetime, timedelta from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart import base64 from PIL import Image import io import tempfile # Cargar variables de entorno try: from dotenv import load_dotenv load_dotenv() except ImportError: print("⚠️ python-dotenv no instalado - usando variables de entorno del sistema") # Importaciones opcionales try: from transformers import pipeline import torch HAS_AI = True print("✅ IA disponible") except ImportError: HAS_AI = False print("❌ IA no disponible - usando análisis básico") # Configuración del sistema DAILY_FREE_LIMIT = 3 PRO_PRICE = 19.99 DATABASE_FILE = "antiscam_pro.db" # Configuración de email EMAIL_USER = os.getenv("EMAIL_USER", "antiscam.ai.bot@gmail.com") EMAIL_PASSWORD = os.getenv("EMAIL_PASSWORD", "") SMTP_SERVER = os.getenv("SMTP_SERVER", "smtp.gmail.com") SMTP_PORT = int(os.getenv("SMTP_PORT", "587")) # Configuración de Stripe (SEGURA) stripe.api_key = os.getenv("STRIPE_SECRET_KEY") STRIPE_PUBLISHABLE_KEY = os.getenv("STRIPE_PUBLISHABLE_KEY") STRIPE_WEBHOOK_SECRET = os.getenv("STRIPE_WEBHOOK_SECRET") # Verificar configuración crítica if not stripe.api_key: print("⚠️ STRIPE_SECRET_KEY no configurada - pagos deshabilitados") PAYMENTS_ENABLED = False else: PAYMENTS_ENABLED = True print("✅ Stripe configurado correctamente") if not EMAIL_PASSWORD: print("⚠️ EMAIL_PASSWORD no configurada - emails simulados") EMAIL_ENABLED = False else: EMAIL_ENABLED = True print("✅ Email configurado correctamente") # Estado global del usuario current_session = { "logged_in": False, "user_id": None, "email": "", "full_name": "", "is_pro": False, "avatar_url": "", "subscription_expires": None, "daily_usage": 0 } # Modelo de IA global ai_model = None def init_database(): """Inicializa la base de datos con todas las tablas necesarias""" conn = sqlite3.connect(DATABASE_FILE) cursor = conn.cursor() # Tabla de usuarios cursor.execute(''' CREATE TABLE IF NOT EXISTS users ( id INTEGER PRIMARY KEY AUTOINCREMENT, email TEXT UNIQUE NOT NULL, password_hash TEXT NOT NULL, full_name TEXT NOT NULL, avatar_url TEXT DEFAULT '', is_pro BOOLEAN DEFAULT FALSE, is_verified BOOLEAN DEFAULT FALSE, verification_token TEXT, verification_expires TIMESTAMP, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, last_login TIMESTAMP, subscription_expires TIMESTAMP, stripe_customer_id TEXT, stripe_subscription_id TEXT, total_analyses INTEGER DEFAULT 0, preferences TEXT DEFAULT '{}' ) ''') # Tabla de uso diario cursor.execute(''' CREATE TABLE IF NOT EXISTS daily_usage ( id INTEGER PRIMARY KEY AUTOINCREMENT, user_id INTEGER, usage_date DATE, analysis_count INTEGER DEFAULT 0, FOREIGN KEY (user_id) REFERENCES users (id), UNIQUE(user_id, usage_date) ) ''') # Tabla de análisis (historial) cursor.execute(''' CREATE TABLE IF NOT EXISTS analyses ( id INTEGER PRIMARY KEY AUTOINCREMENT, user_id INTEGER, content_type TEXT, content_preview TEXT, risk_level TEXT, risk_score INTEGER, analysis_result TEXT, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (user_id) REFERENCES users (id) ) ''') # Tabla de pagos cursor.execute(''' CREATE TABLE IF NOT EXISTS payments ( id INTEGER PRIMARY KEY AUTOINCREMENT, user_id INTEGER, amount REAL, currency TEXT DEFAULT 'USD', payment_method TEXT, stripe_payment_intent_id TEXT, stripe_subscription_id TEXT, status TEXT DEFAULT 'pending', created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (user_id) REFERENCES users (id) ) ''') # Tabla de sesiones cursor.execute(''' CREATE TABLE IF NOT EXISTS sessions ( id INTEGER PRIMARY KEY AUTOINCREMENT, user_id INTEGER, session_token TEXT UNIQUE, expires_at TIMESTAMP, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (user_id) REFERENCES users (id) ) ''') conn.commit() conn.close() print("✅ Base de datos inicializada") def load_ai_model(): """Carga el modelo de IA para análisis avanzado""" global ai_model if ai_model is not None: return ai_model if not HAS_AI: print("❌ IA no disponible") return None try: print("🔄 Cargando modelo de IA...") ai_model = pipeline( "text-classification", model="unitary/toxic-bert", device=0 if torch.cuda.is_available() else -1 ) print("✅ Modelo de IA cargado") return ai_model except Exception as e: print(f"❌ Error cargando IA: {e}") return None def send_verification_email(email, token, full_name): """Envía email de verificación real""" try: verification_link = f"https://tu-dominio.com/verify/{token}" html_body = f"""

🛡️ AntiScam AI

Verificación de Cuenta

¡Hola {full_name}!

Gracias por registrarte en AntiScam AI, tu escudo digital contra estafas.

Para activar tu cuenta y comenzar a protegerte, haz clic en el botón de abajo:

✅ Verificar mi cuenta

O copia este enlace en tu navegador:
{verification_link}

Este enlace expira en 24 horas.

🔒 ¿Por qué verificamos tu email?

""" if EMAIL_ENABLED: # Configurar mensaje msg = MIMEMultipart('alternative') msg['Subject'] = "🛡️ Verifica tu cuenta de AntiScam AI" msg['From'] = EMAIL_USER msg['To'] = email html_part = MIMEText(html_body, 'html') msg.attach(html_part) # Enviar email server = smtplib.SMTP(SMTP_SERVER, SMTP_PORT) server.starttls() server.login(EMAIL_USER, EMAIL_PASSWORD) server.send_message(msg) server.quit() print(f"✅ Email enviado a {email}") else: # Simular envío para desarrollo print(f"📧 [SIMULADO] Email enviado a {email}") print(f"🔗 Link de verificación: {verification_link}") return True except Exception as e: print(f"❌ Error enviando email: {e}") # Para desarrollo, simular envío exitoso print(f"🔗 Link de verificación: {verification_link}") return True def advanced_scam_analysis(content, content_type="text"): """Análisis avanzado de estafas con IA ética y profesional""" # Indicadores específicos de estafas scam_patterns = { "urgencia_extrema": { "keywords": ["inmediatamente", "ahora mismo", "última oportunidad", "expira hoy", "solo por hoy", "urgente", "rápido"], "weight": 20, "description": "Presión temporal artificial" }, "solicitud_datos": { "keywords": ["contraseña", "pin", "código", "número de tarjeta", "datos bancarios", "confirma tu", "verifica tu", "actualiza"], "weight": 25, "description": "Solicitud de información sensible" }, "promesas_irreales": { "keywords": ["dinero fácil", "gana miles", "inversión garantizada", "sin riesgo", "300% retorno", "millonario", "rico"], "weight": 20, "description": "Ofertas demasiado buenas para ser ciertas" }, "amenazas": { "keywords": ["cuenta bloqueada", "consecuencias legales", "suspendida", "cerrar cuenta", "demanda", "problemas legales"], "weight": 18, "description": "Amenazas para generar miedo" }, "suplantacion": { "keywords": ["banco", "microsoft", "google", "amazon", "paypal", "hacienda", "netflix", "apple"], "weight": 15, "description": "Posible suplantación de identidad" }, "gancho_emocional": { "keywords": ["felicidades", "ganador", "seleccionado", "premio", "sorteo", "lotería", "concurso"], "weight": 15, "description": "Manipulación emocional" }, "contacto_sospechoso": { "keywords": ["whatsapp", "telegram", "llama ya", "contacta ahora", "responde rápido"], "weight": 12, "description": "Canales de comunicación informales" } } # Análisis del contenido content_lower = content.lower() detected_patterns = [] total_score = 0 for pattern_name, pattern_info in scam_patterns.items(): matches = sum(1 for keyword in pattern_info["keywords"] if keyword in content_lower) if matches > 0: pattern_score = min(pattern_info["weight"], matches * 5) total_score += pattern_score detected_patterns.append({ "pattern": pattern_name, "description": pattern_info["description"], "matches": matches, "score": pattern_score }) # Determinar nivel de riesgo if total_score >= 70: risk_level = "ALTO" risk_color = "#dc3545" risk_emoji = "🔴" risk_description = "ALTA PROBABILIDAD DE ESTAFA" elif total_score >= 40: risk_level = "MEDIO" risk_color = "#fd7e14" risk_emoji = "🟡" risk_description = "CONTENIDO SOSPECHOSO" else: risk_level = "BAJO" risk_color = "#28a745" risk_emoji = "🟢" risk_description = "RIESGO MÍNIMO DETECTADO" # Generar explicación detallada if detected_patterns: explanation = "🔍 **Patrones sospechosos detectados:**\\n" for pattern in detected_patterns: explanation += f"• **{pattern['description']}** (Puntuación: {pattern['score']})\\n" else: explanation = "✅ No se detectaron patrones típicos de estafa en este contenido." # Recomendaciones específicas if risk_level == "ALTO": recommendations = """ 🚨 **ACCIÓN INMEDIATA REQUERIDA:** • **NO proporciones** información personal o financiera • **NO hagas clic** en enlaces sospechosos • **NO realices** transferencias o pagos solicitados • **Verifica la fuente** contactando directamente la entidad oficial • **Reporta** este contenido a las autoridades competentes • **Bloquea** al remitente inmediatamente """ elif risk_level == "MEDIO": recommendations = """ ⚠️ **PROCEDE CON PRECAUCIÓN:** • **Verifica** la autenticidad contactando directamente la fuente • **No compartas** información personal sin confirmación • **Investiga** más antes de tomar cualquier acción • **Consulta** con personas de confianza • **Mantente alerta** a señales adicionales de alarma """ else: recommendations = """ ✅ **BUENAS PRÁCTICAS:** • **Mantén** la vigilancia habitual • **Verifica siempre** fuentes desconocidas • **No bajes la guardia** con comunicaciones inesperadas • **Educa** a otros sobre estas técnicas • **Reporta** cualquier actividad sospechosa futura """ # Información educativa educational_info = f""" 📚 **INFORMACIÓN EDUCATIVA:** Las estafas digitales utilizan técnicas de ingeniería social para manipular emociones y crear sensación de urgencia. Los estafadores buscan: • Obtener información personal/financiera • Generar confianza mediante suplantación • Crear presión temporal para evitar reflexión • Explotar emociones como miedo, codicia o esperanza **Recuerda:** Las entidades legítimas NUNCA solicitan información sensible por email/SMS no solicitados. """ return { "risk_level": risk_level, "risk_score": min(total_score, 100), "risk_emoji": risk_emoji, "risk_color": risk_color, "risk_description": risk_description, "explanation": explanation, "recommendations": recommendations, "educational_info": educational_info, "detected_patterns": detected_patterns } def format_analysis_result(analysis, engine="🤖 IA Avanzada"): """Formatea el resultado del análisis de manera profesional""" return f"""

🛡️ Análisis AntiScam Completado

{engine}

{analysis['risk_emoji']} {analysis['risk_description']}

{analysis['risk_score']}/100

🔍 Análisis Detallado:

{analysis['explanation']}

💡 Recomendaciones:

{analysis['recommendations']}
📚 Información Educativa
{analysis['educational_info']}
""" def create_stripe_checkout_session(user_email, user_id): """Crea sesión de checkout de Stripe para suscripción Pro""" if not PAYMENTS_ENABLED: return None, "Pagos no configurados en el servidor" try: checkout_session = stripe.checkout.Session.create( customer_email=user_email, client_reference_id=str(user_id), payment_method_types=['card'], line_items=[{ 'price_data': { 'currency': 'usd', 'product_data': { 'name': '🛡️ AntiScam AI Pro', 'description': 'Protección ilimitada contra estafas digitales', 'images': ['https://img.icons8.com/color/96/security-shield-green.png'], }, 'unit_amount': int(PRO_PRICE * 100), # En centavos 'recurring': {'interval': 'month'}, }, 'quantity': 1, }], mode='subscription', success_url='https://tu-dominio.com/success?session_id={CHECKOUT_SESSION_ID}', cancel_url='https://tu-dominio.com/cancel', allow_promotion_codes=True, billing_address_collection='auto', metadata={'user_id': str(user_id)}, subscription_data={ 'metadata': {'user_id': str(user_id)}, 'trial_period_days': 7 # 7 días gratis } ) return checkout_session.url, None except Exception as e: return None, f"Error creando sesión de pago: {str(e)}" def hash_password(password): """Hash seguro de contraseña con salt""" salt = secrets.token_hex(16) password_hash = hashlib.pbkdf2_hmac('sha256', password.encode(), salt.encode(), 100000) return salt + password_hash.hex() def verify_password(password, stored_hash): """Verifica contraseña contra hash almacenado""" try: salt = stored_hash[:32] stored_password_hash = stored_hash[32:] password_hash = hashlib.pbkdf2_hmac('sha256', password.encode(), salt.encode(), 100000) return password_hash.hex() == stored_password_hash except: return False def register_user(email, password, full_name): """Registro completo de usuario con verificación por email""" try: # Validaciones if not email or not password or not full_name: return False, "❌ Todos los campos son obligatorios" if len(password) < 8: return False, "❌ La contraseña debe tener al menos 8 caracteres" if '@' not in email or '.' not in email: return False, "❌ Email inválido" conn = sqlite3.connect(DATABASE_FILE) cursor = conn.cursor() # Verificar email existente cursor.execute("SELECT id FROM users WHERE email = ?", (email,)) if cursor.fetchone(): conn.close() return False, "❌ Este email ya está registrado" # Crear usuario password_hash = hash_password(password) verification_token = secrets.token_urlsafe(32) verification_expires = datetime.now() + timedelta(hours=24) cursor.execute(''' INSERT INTO users (email, password_hash, full_name, verification_token, verification_expires) VALUES (?, ?, ?, ?, ?) ''', (email, password_hash, full_name, verification_token, verification_expires.isoformat())) user_id = cursor.lastrowid conn.commit() conn.close() # Enviar email de verificación email_sent = send_verification_email(email, verification_token, full_name) if email_sent: return True, f""" ✅ **Registro exitoso, {full_name}!** 📧 Te hemos enviado un **email de verificación** a {email} **Próximos pasos:** 1. Revisa tu bandeja de entrada (y spam) 2. Haz clic en el enlace de verificación 3. Inicia sesión para comenzar a protegerte El enlace expira en **24 horas**. """ else: return False, "❌ Error enviando email de verificación" except Exception as e: return False, f"❌ Error en registro: {str(e)}" def verify_user_email(token): """Verifica email del usuario con token""" try: conn = sqlite3.connect(DATABASE_FILE) cursor = conn.cursor() cursor.execute(''' SELECT id, email, full_name, verification_expires FROM users WHERE verification_token = ? AND is_verified = FALSE ''', (token,)) user = cursor.fetchone() if not user: conn.close() return False, "❌ Token inválido o usuario ya verificado" user_id, email, full_name, expires = user # Verificar expiración if datetime.now() > datetime.fromisoformat(expires): conn.close() return False, "❌ El token ha expirado. Solicita un nuevo registro." # Verificar usuario cursor.execute(''' UPDATE users SET is_verified = TRUE, verification_token = NULL, verification_expires = NULL WHERE id = ? ''', (user_id,)) conn.commit() conn.close() return True, f"✅ ¡Email verificado exitosamente! Ahora puedes iniciar sesión, {full_name}." except Exception as e: return False, f"❌ Error verificando email: {str(e)}" def login_user(email, password): """Login completo con validaciones""" try: global current_session conn = sqlite3.connect(DATABASE_FILE) cursor = conn.cursor() cursor.execute(''' SELECT id, password_hash, full_name, is_pro, is_verified, subscription_expires, avatar_url, total_analyses FROM users WHERE email = ? ''', (email,)) user = cursor.fetchone() if not user: conn.close() return False, "❌ Email no encontrado" user_id, stored_hash, full_name, is_pro, is_verified, sub_expires, avatar_url, total_analyses = user if not verify_password(password, stored_hash): conn.close() return False, "❌ Contraseña incorrecta" if not is_verified: conn.close() return False, "❌ Debes verificar tu email antes de iniciar sesión. Revisa tu bandeja de entrada." # Verificar suscripción expirada if is_pro and sub_expires: try: if datetime.fromisoformat(sub_expires) < datetime.now(): cursor.execute("UPDATE users SET is_pro = FALSE WHERE id = ?", (user_id,)) conn.commit() is_pro = False except: pass # Actualizar último login cursor.execute("UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = ?", (user_id,)) conn.commit() conn.close() # Actualizar sesión global current_session.update({ "logged_in": True, "user_id": user_id, "email": email, "full_name": full_name, "is_pro": is_pro, "avatar_url": avatar_url or "", "subscription_expires": sub_expires, "total_analyses": total_analyses or 0 }) # Cargar uso diario load_daily_usage() status = "👑 PRO" if is_pro else "🆓 FREE" return True, f"✅ ¡Bienvenido de vuelta, {full_name}! ({status})" except Exception as e: return False, f"❌ Error en login: {str(e)}" def load_daily_usage(): """Carga el uso diario del usuario actual""" global current_session if not current_session["logged_in"]: return try: conn = sqlite3.connect(DATABASE_FILE) cursor = conn.cursor() today = datetime.now().strftime("%Y-%m-%d") cursor.execute(''' SELECT analysis_count FROM daily_usage WHERE user_id = ? AND usage_date = ? ''', (current_session["user_id"], today)) result = cursor.fetchone() current_session["daily_usage"] = result[0] if result else 0 conn.close() except Exception as e: print(f"Error cargando uso diario: {e}") current_session["daily_usage"] = 0 def can_analyze(): """Verifica si el usuario puede hacer análisis""" if not current_session["logged_in"]: return False, "No autenticado" if current_session["is_pro"]: return True, "Usuario Pro" if current_session["daily_usage"] >= DAILY_FREE_LIMIT: return False, "Límite diario alcanzado" return True, "Análisis disponible" def increment_usage(): """Incrementa el contador de uso""" global current_session if not current_session["logged_in"] or current_session["is_pro"]: return try: conn = sqlite3.connect(DATABASE_FILE) cursor = conn.cursor() today = datetime.now().strftime("%Y-%m-%d") cursor.execute(''' INSERT OR IGNORE INTO daily_usage (user_id, usage_date, analysis_count) VALUES (?, ?, 0) ''', (current_session["user_id"], today)) cursor.execute(''' UPDATE daily_usage SET analysis_count = analysis_count + 1 WHERE user_id = ? AND usage_date = ? ''', (current_session["user_id"], today)) # Actualizar total de análisis del usuario cursor.execute(''' UPDATE users SET total_analyses = total_analyses + 1 WHERE id = ? ''', (current_session["user_id"],)) conn.commit() conn.close() current_session["daily_usage"] += 1 current_session["total_analyses"] += 1 except Exception as e: print(f"Error incrementando uso: {e}") def save_analysis(content_type, content_preview, risk_level, risk_score, analysis_result): """Guarda el análisis en el historial""" if not current_session["logged_in"]: return try: conn = sqlite3.connect(DATABASE_FILE) cursor = conn.cursor() cursor.execute(''' INSERT INTO analyses (user_id, content_type, content_preview, risk_level, risk_score, analysis