app.py

from auth import *
from flask import Flask, render_template, request, redirect, session, jsonify
from datetime import datetime, timedelta
import subprocess, re, os, socket, threading, time, requests, logging
from db import get_db

CACHE_INTERVALO   = 120
HISTORIAL_DIAS    = 30
DEFAULT_SESSION   = 8 * 3600

CACHE_RESULTADO   = []
_cache_lock       = threading.Lock()
_estado_anterior  = {}
_intervalo_actual = CACHE_INTERVALO

app = Flask(__name__)
app.secret_key = os.environ.get("SECRET_KEY", "lan_guard_secret")

iniciar_archivo_usuarios()

logger  = logging.getLogger("accesos")
logger.setLevel(logging.INFO)
handler = logging.FileHandler("data/accesos.log")
logger.addHandler(handler)
def registrar_log(m): logger.info(m)

def obtener_config(clave, defecto=""):
    db  = get_db()
    row = db.execute("SELECT valor FROM configuracion WHERE clave=?", (clave,)).fetchone()
    db.close()
    return row["valor"] if row else defecto

def guardar_config(clave, valor):
    db = get_db()
    db.execute("INSERT INTO configuracion(clave,valor) VALUES(?,?) ON CONFLICT(clave) DO UPDATE SET valor=excluded.valor",
               (clave, str(valor)))
    db.commit(); db.close()

def get_session_timeout():
    try:
        return int(obtener_config("session_timeout", str(DEFAULT_SESSION)))
    except Exception:
        return DEFAULT_SESSION

def get_telegram_config():
    token = obtener_config("telegram_token",   os.getenv("TELEGRAM_BOT_TOKEN", ""))
    chat  = obtener_config("telegram_chat_id", os.getenv("TELEGRAM_CHAT_ID",   ""))
    return token, chat

def get_intervalo():
    global _intervalo_actual
    try:
        _intervalo_actual = int(obtener_config("intervalo_monitoreo", str(CACHE_INTERVALO)))
    except Exception:
        _intervalo_actual = CACHE_INTERVALO
    return _intervalo_actual

@app.before_request
def verificar_sesion_timeout():
    rutas_publicas = ("/login", "/static")
    if any(request.path.startswith(r) for r in rutas_publicas):
        return
    if "usuario" in session:
        ultimo  = session.get("ultimo_acceso", 0)
        ahora   = time.time()
        timeout = get_session_timeout()
        if ahora - ultimo > timeout:
            session.clear()
            return redirect("/login?timeout=1")
        session["ultimo_acceso"] = ahora
        session.permanent = True
        app.permanent_session_lifetime = timedelta(seconds=timeout)

@app.route("/logout")
def logout():
    usuario = session.get("usuario")
    session.clear()
    registrar_log(f"Usuario {usuario} cerro sesion")
    return redirect("/login")

@app.route("/login", methods=["GET", "POST"])
def login():
    timeout = request.args.get("timeout")
    if request.method == "POST":
        usuario    = request.form["usuario"]
        contrasena = request.form["contrasena"]
        if verificar_login(usuario, contrasena):
            session["usuario"]       = usuario
            session["ultimo_acceso"] = time.time()
            session.permanent        = True
            if es_usuario_por_defecto(usuario) and es_contrasena_por_defecto(usuario):
                return redirect("/cambiar-credenciales")
            return redirect("/")
        return render_template("login.html", error="Usuario o contraseña incorrectos")
    return render_template("login.html", timeout=timeout)

@app.route("/cambiar-credenciales", methods=["GET", "POST"])
def cambiar_credenciales():
    if "usuario" not in session:
        return redirect("/login")
    if request.method == "POST":
        nuevo_usuario = request.form["nuevo_usuario"].strip().lower()
        nueva         = request.form["nueva_contrasena"]
        confirmar     = request.form["confirmar_contrasena"]
        if not re.match(r"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$", nuevo_usuario):
            return render_template("cambiar_credenciales.html", error="El usuario debe ser un correo válido")
        if nueva != confirmar:
            return render_template("cambiar_credenciales.html", error="Las contraseñas no coinciden")
        if not es_contrasena_segura(nueva):
            return render_template("cambiar_credenciales.html", error="La contraseña no cumple los requisitos")
        cambiar_usuario(session["usuario"], nuevo_usuario)
        cambiar_contrasena_usuario(nuevo_usuario, nueva)
        session["usuario"] = nuevo_usuario
        return redirect("/")
    return render_template("cambiar_credenciales.html")

@app.route('/api/cambiar-credenciales', methods=['POST'])
def api_cambiar_credenciales():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    data              = request.get_json()
    nuevo_usuario     = data.get("nuevo_usuario", "").strip().lower()
    nueva             = data.get("nueva_contrasena", "")
    confirmar         = data.get("confirmar_contrasena", "")
    contrasena_actual = data.get("contrasena_actual", "")

    if not verificar_login(session["usuario"], contrasena_actual):
        return jsonify({"success": False, "message": "La contraseña actual es incorrecta"})
    if nuevo_usuario and not re.match(r"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$", nuevo_usuario):
        return jsonify({"success": False, "message": "El correo no tiene un formato válido"})
    if nueva:
        if nueva != confirmar:
            return jsonify({"success": False, "message": "Las contraseñas nuevas no coinciden"})
        if not es_contrasena_segura(nueva):
            return jsonify({"success": False, "message": "La contraseña no cumple los requisitos de seguridad"})

    usuario_actual = session["usuario"]
    if nuevo_usuario and nuevo_usuario != usuario_actual:
        cambiar_usuario(usuario_actual, nuevo_usuario)
        session["usuario"] = nuevo_usuario
        usuario_actual = nuevo_usuario
    if nueva:
        cambiar_contrasena_usuario(usuario_actual, nueva)

    return jsonify({"success": True, "usuario": usuario_actual})

def obtener_confiables():
    db   = get_db()
    rows = db.execute("SELECT mac FROM mac_confiables").fetchall()
    db.close()
    return {r["mac"].lower() for r in rows}

def obtener_nombre(mac):
    db  = get_db()
    row = db.execute("SELECT nombre FROM nombres_dispositivos WHERE mac=?", (mac,)).fetchone()
    db.close()
    return row["nombre"] if row else None

def guardar_nombre(mac, nombre):
    db = get_db()
    db.execute("INSERT INTO nombres_dispositivos(mac,nombre) VALUES(?,?) ON CONFLICT(mac) DO UPDATE SET nombre=excluded.nombre", (mac, nombre))
    db.commit(); db.close()

def obtener_vendor_cache(oui):
    db  = get_db()
    row = db.execute("SELECT fabricante FROM vendor_cache WHERE oui=?", (oui,)).fetchone()
    db.close()
    return row["fabricante"] if row else None

def guardar_vendor_cache(oui, fabricante):
    db = get_db()
    db.execute("INSERT INTO vendor_cache(oui,fabricante) VALUES(?,?) ON CONFLICT(oui) DO UPDATE SET fabricante=excluded.fabricante", (oui, fabricante))
    db.commit(); db.close()

def obtener_deteccion(mac):
    db  = get_db()
    row = db.execute("SELECT * FROM detecciones_mac WHERE mac=?", (mac,)).fetchone()
    db.close()
    return row

def guardar_deteccion(mac, count, notificado, ultima):
    db = get_db()
    db.execute("INSERT INTO detecciones_mac(mac,count,notificado,ultima_vista) VALUES(?,?,?,?) ON CONFLICT(mac) DO UPDATE SET count=excluded.count,notificado=excluded.notificado,ultima_vista=excluded.ultima_vista",
               (mac, count, int(notificado), ultima))
    db.commit(); db.close()

def obtener_confiables_con_nombre():
    db   = get_db()
    rows = db.execute("SELECT c.mac, n.nombre FROM mac_confiables c LEFT JOIN nombres_dispositivos n ON c.mac=n.mac ORDER BY c.mac").fetchall()
    db.close()
    return rows

def guardar_historial(dispositivos, ahora):
    global _estado_anterior
    macs_actuales   = {d["mac"] for d in dispositivos}
    macs_anteriores = set(_estado_anterior.keys())
    nuevos        = macs_actuales - macs_anteriores
    desconectados = macs_anteriores - macs_actuales
    registros = []
    for d in dispositivos:
        if d["mac"] in nuevos:
            registros.append({**d, "evento": "conectado", "ahora": ahora})
    for mac in desconectados:
        d = _estado_anterior[mac]
        registros.append({**d, "evento": "desconectado", "ahora": ahora})
    _estado_anterior = {d["mac"]: d for d in dispositivos}
    if not registros:
        return
    db = get_db()
    db.executemany("INSERT INTO historial_dispositivos(mac,ip,fabricante,confiable,nombre,visto_en,evento) VALUES(:mac,:ip,:fabricante,:confiable,:nombre,:ahora,:evento)", registros)
    db.execute("DELETE FROM historial_dispositivos WHERE visto_en<?", (ahora - HISTORIAL_DIAS * 86400,))
    db.commit(); db.close()

def obtener_fabricante(mac):
    oui = mac.replace(":", "")[:6].upper()
    fab = obtener_vendor_cache(oui)
    if fab:
        return fab
    try:
        resp = requests.get(f"https://api.maclookup.app/v2/macs/{mac}", timeout=5)
        fab  = resp.json().get("company") or "Desconocido"
    except Exception:
        fab  = "Desconocido"
    if fab != "Desconocido":
        guardar_vendor_cache(oui, fab)
    return fab

def obtener_red_local():
    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
        s.connect(("8.8.8.8", 80))
        ip = s.getsockname()[0]
    return f"{ip}/24"

def escanear_red():
    red        = obtener_red_local()
    ahora      = time.time()
    confiables = obtener_confiables()
    salida     = subprocess.check_output(["nmap", "-sn", "-PR", "-T3", "-n", red], timeout=60).decode()
    ips_vivas  = [l.split()[-1] for l in salida.splitlines() if "Nmap scan report for" in l]
    arp_table  = {}
    try:
        salida_arp = subprocess.check_output(["ip", "neigh", "show"]).decode()
        for linea in salida_arp.splitlines():
            if not any(s in linea.upper() for s in ["REACHABLE", "STALE"]):
                continue
            m = re.match(r"(\d+\.\d+\.\d+\.\d+)\s+dev\s+\S+\s+lladdr\s+([\da-f:]{17})", linea, re.I)
            if m:
                arp_table[m.group(1)] = m.group(2).lower()
    except Exception as e:
        print(f"[!] Error leyendo ARP: {e}")
    dispositivos = []
    for ip in ips_vivas:
        mac = arp_table.get(ip)
        if not mac:
            continue
        fab       = obtener_fabricante(mac)
        confiable = mac in confiables
        nombre    = obtener_nombre(mac)
        dispositivos.append({"ip": ip, "mac": mac, "fabricante": fab, "confiable": confiable, "nombre": nombre})
        if not confiable:
            reg = obtener_deteccion(mac)
            if not reg:
                guardar_deteccion(mac, 1, False, ahora)
            else:
                count = reg["count"] + 1
                notificado = reg["notificado"]
                guardar_deteccion(mac, count, notificado, ahora)
                if count >= 3 and not notificado:
                    enviar_telegram(mac, ip, fab)
                    guardar_deteccion(mac, count, True, ahora)
    threading.Thread(target=guardar_historial, args=(dispositivos, ahora), daemon=True).start()
    return dispositivos

def enviar_telegram(mac, ip, fab):
    token, chat = get_telegram_config()
    if not token or not chat:
        return
    msg = f"?? NUEVO DISPOSITIVO\nIP: {ip}\nMAC: {mac}\nFAB: {fab}"
    try:
        requests.post(f"https://api.telegram.org/bot{token}/sendMessage",
                      data={"chat_id": chat, "text": msg}, timeout=5)
    except Exception:
        pass

def actualizar_cache():
    global CACHE_RESULTADO
    resultado = escanear_red()
    with _cache_lock:
        CACHE_RESULTADO = resultado

def escaneo_background():
    while True:
        try:
            actualizar_cache()
        except Exception as e:
            print(f"[!] Error en escaneo background: {e}")
        time.sleep(get_intervalo())

@app.route('/')
def index():
    if 'usuario' not in session:
        return redirect('/login')
    with _cache_lock:
        devs = list(CACHE_RESULTADO)
    return render_template("index.html",
        dispositivos=devs,
        lista_confiables=obtener_confiables_con_nombre(),
        session_timeout=get_session_timeout(),
        usuario_actual=session.get("usuario", "")
    )

@app.route('/api/scan')
def api_scan():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    with _cache_lock:
        return jsonify(list(CACHE_RESULTADO))

@app.route('/api/agregar', methods=['POST'])
def api_agregar():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    mac = request.json["mac"].lower()
    db  = get_db()
    db.execute("INSERT OR IGNORE INTO mac_confiables(mac) VALUES(?)", (mac,))
    db.commit(); db.close()
    actualizar_cache()
    return jsonify({"success": True})

@app.route('/api/eliminar', methods=['POST'])
def api_eliminar():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    mac = request.json["mac"].lower()
    db  = get_db()
    db.execute("DELETE FROM mac_confiables WHERE mac=?", (mac,))
    db.commit(); db.close()
    actualizar_cache()
    return jsonify({"success": True})

@app.route('/api/nombrar', methods=['POST'])
def api_nombrar():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    mac    = request.json["mac"].lower()
    nombre = request.json["nombre"]
    guardar_nombre(mac, nombre)
    global CACHE_RESULTADO
    with _cache_lock:
        for d in CACHE_RESULTADO:
            if d["mac"] == mac:
                d["nombre"] = nombre
    return jsonify({"success": True, "mac": mac, "nombre": nombre})

@app.route('/api/puertos', methods=['POST'])
def api_puertos():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    ip = request.get_json().get("ip", "").strip()
    if not ip:
        return jsonify({"success": False, "message": "IP no proporcionada"})
    # FIX alert #22: validate IP format before passing to subprocess,
    # and never expose the raw exception message to the client.
    if not re.match(r"^\d{1,3}(\.\d{1,3}){3}$", ip):
        return jsonify({"success": False, "message": "IP no válida"})
    try:
        salida  = subprocess.check_output(["nmap", "-T4", "-sT", "--top-ports", "100", "--open", "-n", ip], timeout=20).decode()
        puertos = [{"puerto": p.split()[0], "servicio": p.split()[-1]} for p in salida.splitlines() if "/tcp" in p and "open" in p]
        return jsonify({"success": True, "puertos": puertos})
    except subprocess.TimeoutExpired:
        return jsonify({"success": False, "message": "El escaneo tardó demasiado"})
    except Exception:
        # Do NOT expose exception details to the client (alert #22)
        logging.getLogger("accesos").warning("Error en escaneo de puertos para IP %s", ip)
        return jsonify({"success": False, "message": "Error al escanear puertos"})

@app.route('/api/historial')
def api_historial():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    mac    = request.args.get("mac", "").lower()
    evento = request.args.get("evento", "").lower()
    limit  = min(int(request.args.get("limit", 100)), 500)
    db     = get_db()
    where  = []; params = []
    if mac:
        where.append("mac=?"); params.append(mac)
    if evento in ("conectado", "desconectado"):
        where.append("evento=?"); params.append(evento)
    where_sql = f"WHERE {' AND '.join(where)}" if where else ""
    params.append(limit)
    rows = db.execute(f"SELECT mac,ip,fabricante,confiable,nombre,evento,datetime(visto_en,'unixepoch','localtime') AS fecha FROM historial_dispositivos {where_sql} ORDER BY visto_en DESC LIMIT ?", params).fetchall()
    db.close()
    return jsonify([dict(r) for r in rows])

@app.route('/api/historial/limpiar', methods=['POST'])
def api_historial_limpiar():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    db = get_db()
    db.execute("DELETE FROM historial_dispositivos")
    db.commit(); db.close()
    return jsonify({"success": True})

@app.route('/api/perfil', methods=['GET'])
def api_perfil_get():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    db  = get_db()
    row = db.execute(
        "SELECT nombre_display FROM usuarios WHERE usuario=?",
        (session['usuario'],)
    ).fetchone()
    db.close()
    return jsonify({
        "usuario":        session['usuario'],
        "nombre_display": row["nombre_display"] if row and row["nombre_display"] else ""
    })

@app.route('/api/perfil', methods=['POST'])
def api_perfil_set():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    data   = request.get_json()
    nombre = data.get("nombre_display", "").strip()
    db     = get_db()
    db.execute(
        "UPDATE usuarios SET nombre_display=? WHERE usuario=?",
        (nombre, session['usuario'])
    )
    db.commit()
    db.close()
    return jsonify({"success": True, "nombre_display": nombre})

@app.route('/api/configuracion', methods=['GET'])
def api_config_get():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    token, chat = get_telegram_config()
    return jsonify({
        "telegram_token":      token,
        "telegram_chat_id":    chat,
        "intervalo_monitoreo": obtener_config("intervalo_monitoreo", str(CACHE_INTERVALO)),
        "session_timeout":     obtener_config("session_timeout", str(DEFAULT_SESSION))
    })

@app.route('/api/configuracion', methods=['POST'])
def api_config_set():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    data = request.get_json()
    if "telegram_token" in data:
        guardar_config("telegram_token",   data["telegram_token"].strip())
    if "telegram_chat_id" in data:
        guardar_config("telegram_chat_id", data["telegram_chat_id"].strip())
    if "intervalo_monitoreo" in data:
        try:
            iv = max(30, int(data["intervalo_monitoreo"]))
            guardar_config("intervalo_monitoreo", iv)
            global _intervalo_actual
            _intervalo_actual = iv
        except Exception:
            return jsonify({"success": False, "message": "Intervalo inválido"})
    if "session_timeout" in data:
        try:
            st = max(300, int(data["session_timeout"]))
            guardar_config("session_timeout", st)
            app.permanent_session_lifetime = timedelta(seconds=st)
        except Exception:
            return jsonify({"success": False, "message": "Tiempo de sesión inválido"})
    return jsonify({"success": True})

@app.route('/api/telegram/test', methods=['POST'])
def api_telegram_test():
    if 'usuario' not in session:
        return jsonify({"error": "No autorizado"}), 401
    token, chat = get_telegram_config()
    if not token or not chat:
        return jsonify({"success": False, "message": "Token o Chat ID no configurados"})
    try:
        resp = requests.post(f"https://api.telegram.org/bot{token}/sendMessage",
                             data={"chat_id": chat, "text": "? LANGuard: conexión de prueba exitosa"}, timeout=5)
        ok = resp.json().get("ok", False)
        return jsonify({"success": ok, "message": "Mensaje enviado correctamente" if ok else "Error en Telegram"})
    except Exception:
        # FIX alert #23: do not expose exception details to the client
        return jsonify({"success": False, "message": "No se pudo conectar con Telegram"})

if __name__ == '__main__':
    threading.Thread(target=escaneo_background, daemon=True).start()
    app.run(host='0.0.0.0', port=5555)