# Herramientas

# Code Server: Editor de código basado en Visual Studio Code accesible desde cualquier navegador

---
Code-Server es una versión de VS Code accesible por navegador. Ideal para centralizar el entorno de desarrollo en un servidor y acceder desde cualquier parte.

---

### docker-compose.yml

```yaml
docker-compose.yml

services:
  code-server:
    image: lscr.io/linuxserver/code-server:latest
    container_name: code-server
    network_mode: bridge
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Madrid
      - PASSWORD=your_password
      - SUDO_PASSWORD=your_sudo_password
      - DEFAULT_WORKSPACE=/config/workspace
    volumes:
      - /path/to/code-server/config:/config
      - /path/to/host-directory:/workspace
    ports:
      - 6443:8443
    restart: unless-stopped
```

---

### Detalles clave

* **Puerto 6443**: acceso web desde navegador:

  ```
  http://<IP-del-servidor>:6443
  ```
* **PASSWORD**: protege el acceso con contraseña (sin necesidad de configurar proxy externo).
* **SUDO\_PASSWORD**: permite ejecutar comandos con privilegios dentro del contenedor.
* **DEFAULT\_WORKSPACE**: directorio que se abre por defecto al iniciar.
* **Volúmenes**:

  * `/config`: guarda configuración, extensiones y preferencias.
  * `/workspace`: carpeta del host donde se trabaja.

---

### Acceso y uso

1. **Levantar contenedor**:

   ```bash
   docker-compose up -d
   ```
2. **Acceder por navegador**:
   Usa la IP del servidor en el puerto 6443.
3. **Login con PASSWORD**.
4. **Trabajar normalmente**: abrir terminal, instalar extensiones, gestionar archivos...

---

### Notas personales

* Lo uso en servidores donde no tengo escritorio.
* Si lo expongo, siempre lo protejo con Authentik o equivalente (aunque tenga auth interna).

---

### Enlaces de interés

* [Documentación oficial de Code-Server (LinuxServer.io)](https://docs.linuxserver.io/images/docker-code-server/)
* [Wiki: proteger con Authentik](https://wiki.jtrapero.eu.org/books/contenedores-configuracion/page/authentik-proteger-nuestras-aplicaciones-web)
* [Repositorio personal de configuración (Gitea)](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/Code-Server)

# CyberChef: Herramienta versátil para procesamiento de datos y criptografía

---
CyberChef es una navaja suiza para el tratamiento de datos: codifica, cifra, decodifica, convierte, analiza... Todo desde una interfaz web sin instalar nada en el cliente.

---

### docker-compose.yml

```yaml
docker-compose.yml

services:
  cyberchef:
    container_name: Cyberchef
    image: mpepping/cyberchef
    network_mode: bridge
    ports:
      - '8300:8000'
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - capabilities: [gpu]
```

---

### Detalles clave

* **Puerto 8300**: acceso web desde el navegador:

  ```
  http://<IP-del-servidor>:8300
  ```
* **Imagen**: `mpepping/cyberchef`, lista para usar sin necesidad de configuración adicional.
* **GPU** (opcional): si hay disponible, se puede reservar para operaciones pesadas.

---

### Acceso y uso

1. **Levantar contenedor**:

   ```bash
   docker-compose up -d
   ```
2. **Abrir interfaz** desde navegador.
3. **Arrastrar datos o escribir texto** y aplicar operaciones en la columna de la izquierda.

---

### Notas personales

* Muy útil para conversiones puntuales o tests rápidos de hash, base64, json, binario, etc.
* Funciona perfecto sin conexión a internet.
* No requiere almacenamiento persistente.
* Si lo expongo, lo dejo tras Authentik como todo lo demás.

---

### Enlaces de interés

* [Repositorio oficial en GitHub](https://github.com/gchq/CyberChef)
* [Repositorio personal en Gitea](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/Cyberchef)
* [Wiki: proteger con Authentik](https://wiki.jtrapero.eu.org/books/contenedores-configuracion/page/authentik-proteger-nuestras-aplicaciones-web)

# Draw.io: Editor de diagramas

---

### Introducción

**Draw.io** es una aplicación web de diagramación que permite crear diagramas de flujo, mapas de red, esquemas técnicos y todo tipo de representaciones visuales. Su uso es completamente local o autoalojado, sin depender de servicios externos, lo que la convierte en una opción ideal para entornos donde se busca control total y privacidad.

En este caso se ha desplegado mediante Docker y se sirve públicamente a través de Caddy, ofreciendo acceso seguro y autenticado desde cualquier ubicación. El objetivo es disponer de un editor de diagramas accesible, pero bajo las mismas medidas de seguridad aplicadas al resto de servicios.

---

### Características

* Servicio web de diagramación basado en la imagen oficial [`jgraph/drawio`](https://hub.docker.com/r/jgraph/drawio).
* Expuesto públicamente a través de Caddy con TLS estricto.
* Autenticación centralizada mediante **Authentik** (opcional pero muy recomendable para evitar acceso abierto).
* Protección adicional mediante las directivas personales de Caddy (`seguridad_basica`, `tls_estricto`, `log_json_global`).
* Integración directa con el proxy inverso, sin HTTPS interno (Caddy gestiona el cifrado externo).

---

### Requisitos previos

* Caddy configurado con los imports personales definidos en [Directivas de Caddy – uso personal](https://wiki.jtrapero.eu.org/books/caddy/page/directivas-de-caddy-uso-personal).
  Esto es opcional pero recomendado, especialmente **Authentik**, para que no pueda usar la instancia cualquiera.
* Authentik operativo y con proveedor configurado para el dominio público de Draw.io.
* Docker Compose.

---

### Despliegue

La configuración completa se mantiene en Gitea:

* [`docker-compose.yml`](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/Draw.io/docker-compose.yml)
* [`Caddyfile`](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/Draw.io/Caddyfile)

El contenedor se lanza con la imagen oficial `jgraph/drawio`, exponiendo el puerto `8080` para que Caddy lo redirija desde el dominio público. La capa TLS y la autenticación se gestionan desde Caddy, garantizando acceso seguro y controlado mediante Authentik.

---

### Errores comunes o decisiones importantes

* **HTTPS interno deshabilitado**: se deja a Caddy el manejo del cifrado.
* **Acceso público controlado**: Authentik restringe el acceso únicamente a usuarios autorizados.
* **Revisión periódica del contenedor**: se recomienda actualizar la imagen `jgraph/drawio` para mantener las correcciones de seguridad.

---

### Resumen breve

* Imagen: `jgraph/drawio`.
* Proxy: Caddy + Authentik.
* Expuesto públicamente con TLS.
* Directivas personales de seguridad en Caddy.
* Código disponible en Gitea.

---

### Notas personales

Draw.io se usa como editor de diagramas accesible desde el exterior pero protegido por autenticación. Permite trabajar con diagramas `.drawio` de forma directa y mantener independencia de la versión online oficial.

# Homepage: Dashboard personalizable para centralizar accesos rápidos a servicios

---

Homepage es un panel de control personalizable para centralizar accesos y métricas de servicios, ideal como página de inicio en servidores autogestionados.

---

### Características

* Panel limpio y modular.
* Integración con Docker a través del **socket-proxy**, sin exponer el `docker.sock`.
* Widgets para clima, sistema, uptime, contenedores y accesos rápidos.
* Configuración íntegra mediante archivos YAML.

---

### Requisitos previos

* Carpeta local para `/config` y `/icons`.
* Red propia para Homepage.
* Unión opcional a la red **SocketProxy_NET** para la integración con Docker.

---

### Implementación

El compose se mantiene directamente en Gitea:

**[Docker Compose en Gitea](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/Homepage)**

Notas relevantes de la configuración actual:

* Escucha en el **puerto 4100**.
* `HOMEPAGE_ALLOWED_HOSTS` controla desde qué IP puede cargarse el panel.
* No se monta el socket de Docker. La integración se hace únicamente mediante la red compartida con el **socket-proxy**.
* Homepage entra en `SocketProxy_NET` solo si se quiere mostrar contenedores.
* DNS fijado a servidores externos para evitar saturar el DNS local.
* `TZ` y rutas limpias para `/config` y `/icons`.

---

### Archivos de configuración (`/config`)

La estructura sigue igual, pero con ajustes de orden y limpieza respecto a versiones anteriores:

* `bookmarks.yaml`: accesos rápidos.
* `services.yaml`: definición de servicios visibles.
* `docker.yaml`: integración con el socket-proxy.
* `widgets.yaml`: clima, uptime, sistema, etc.
* `settings.yaml`: ajustes globales y personalización.

#### Nota sobre `docker.yaml`

En caso de integrar Homepage con el **socket-proxy**, la configuración mínima queda así:

```yaml
---
# For configuration options and examples, please see:
# https://gethomepage.dev/en/configs/docker/

Docker:
  host: socket-proxy
  port: 2375

# my-docker:
#   socket: /var/run/docker.sock
```

Esto evita montar el `docker.sock` y delega toda la comunicación al proxy.

---

### Errores comunes o decisiones importantes

* **Nada de montar el `docker.sock`**. Toda la integración pasa por la red compartida con el proxy.
* `HOMEPAGE_ALLOWED_HOSTS` es obligatorio; si no coincide, Homepage rechaza el acceso.
* Cualquier cambio de red implica recrear los contenedores; sin eso no resuelven servicios.
* Cuando Homepage no detecta contenedores, casi siempre es que no está en la red del socket-proxy.

---

### Resumen breve

* Servicio en el puerto **4100**, con red propia.
* Integración Docker solo vía **SocketProxy_NET**.
* Configuración completa en `/config`.
* Compose y cambios siempre actualizados en Gitea.

---

### Referencias

* [SocketProxy: acceso controlado al daemon de Docker](https://wiki.jtrapero.eu.org/books/contenedores-instalacion/page/socketproxy-acceso-controlado-al-daemon-de-docker)

* [Sitio oficial de Homepage](https://gethomepage.dev/)

* [Repositorio en GitHub](https://github.com/gethomepage/homepage)

* [Compose actualizado en Gitea](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/Homepage)

# IT Tools: Colección de herramientas prácticas para redes e informática

---
**IT Tools** es un conjunto de utilidades web para tareas rápidas: hashes, expresiones regulares, conversión de formatos, etc. Corre todo en local, sin depender de servicios externos.

---

### docker-compose.yml

```yaml
services:
  it-tools:
    container_name: IT-Tools
    image: corentinth/it-tools
    network_mode: bridge
    ports:
      - '2580:80'
    restart: unless-stopped
```

---

### Detalles clave

* **Puerto 2580**: acceso desde el navegador:

  ```
  http://<IP-del-servidor>:2580
  ```
* **Imagen**: `corentinth/it-tools`, lista para usar sin configuración.
* **No requiere volumen**: toda la app funciona sin persistencia.

---

### Acceso y uso

1. **Levantar contenedor**:

   ```bash
   docker-compose up -d
   ```
2. **Abrir interfaz web**.
3. **Explorar herramientas** disponibles:
   hash generator, regex tester, base64, JSON, etc.

---

### Notas personales

* Lo tengo montado en local, accesible solo desde LAN.
* Lo uso a menudo junto con CyberChef para tareas rápidas.
* Protegido con Authentik, como el resto de herramientas.
* Muy útil cuando no quiero abrir sitios externos.

---

### Enlaces de interés

* [Sitio oficial](https://it-tools.tech)
* [Repositorio en GitHub](https://github.com/CorentinTh/it-tools)
* [Repositorio personal en Gitea](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/ITTools)
* [Wiki: proteger con Authentik](https://wiki.jtrapero.eu.org/books/contenedores-configuracion/page/authentik-proteger-nuestras-aplicaciones-web)

# LibreTranslate: API de traducción de texto autohospedada y sin dependencia de terceros

---
**LibreTranslate** es un traductor automático libre que puede desplegarse con soporte para CUDA. Esto permite usar la GPU para acelerar las traducciones, lo cual es útil si vas a montarlo en local y quieres buena respuesta.

---

### docker-compose.cuda.yml

```yaml
services:
  libretranslate-cuda:
    container_name: LT-CUDA
    build:
      context: .
      dockerfile: docker/cuda.Dockerfile
    environment:
      - LTHOST=127.0.0.1
      - LT_PORT=5000
      - LT_THREADS=24
      - LT_API_KEYS=true
      - LT_SUGGESTIONS=true
      - LT_API_KEYS_DB_PATH=/app/db/api_keys.db
      - LT_UPDATE_MODELS=true
      - LT_LOAD_ONLY=en,es
    volumes:
      - /ruta/a/tu/db:/app/db
      - /ruta/a/tus/modelos:/home/libretranslate/.local:rw
    ports:
      - "5006:5000"
    restart: unless-stopped
    tty: true
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    healthcheck:
      test: ['CMD-SHELL', './venv/bin/python scripts/healthcheck.py']

networks:
  default:
    name: LT_NET
```

---

### Detalles clave

* **GPU (CUDA):** necesita una tarjeta NVIDIA y drivers configurados correctamente.
* **Modelos:** deben estar descargados en la ruta indicada. Se pueden limitar los idiomas a cargar (`LT_LOAD_ONLY=en,es`).
* **API Keys:** puede limitar el uso de la API con claves almacenadas en SQLite.
* **Dockerfile:** construye desde `docker/cuda.Dockerfile`, no es una imagen prehecha.

---

### Uso

1. Clonar repo oficial:

   ```bash
   git clone https://github.com/LibreTranslate/LibreTranslate.git
   cd LibreTranslate
   ```

2. Editar rutas y variables en el YAML.

3. Levantar contenedor:

   ```bash
   docker-compose -f docker-compose.cuda.yml up -d
   ```

4. Acceso desde navegador:

   ```
   http://<IP-del-servidor>:5006
   ```

---

### Notas personales

* Lo uso en local, sin exponer.
* Lo tengo limitado a inglés y español por ahora.
* No he probado a integrar con Authentik porque no lo tengo accesible desde fuera.
* Si se expone, va tras Authentik sí o sí.

---

### Enlaces de interés

* [Repositorio oficial](https://github.com/LibreTranslate/LibreTranslate)
* [Sitio oficial](https://libretranslate.com)
* [Repositorio personal en Gitea](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/LibreTranslate)
* [Wiki: proteger con Authentik](https://wiki.jtrapero.eu.org/books/contenedores-configuracion/page/authentik-proteger-nuestras-aplicaciones-web)

# Linkwarden: Gestor de marcadores autohospedado para almacenar y organizar enlaces

---

### Introducción

Este artículo documenta **Linkwarden**, un gestor de marcadores autohospedado orientado a **centralizar, preservar y organizar enlaces** sin depender de servicios externos. Se integra dentro del stack como un servicio web interno, desplegado en contenedores y respaldado por una base de datos PostgreSQL persistente.

A diferencia de soluciones enfocadas en “leer más tarde”, Linkwarden está pensado como **archivo a largo plazo**: permite conservar enlaces incluso si el contenido original desaparece, facilitando búsquedas posteriores sobre material técnico, documentación, referencias o recursos personales.

---

### Enfoque general

Linkwarden actúa como una **biblioteca de enlaces**, no como una lista temporal. Cada marcador puede almacenarse junto con:

* Metadatos (título, descripción).
* Etiquetas y colecciones.
* Copia del contenido (HTML) y/o captura visual.

Este enfoque evita el *link rot* y permite consultar información incluso cuando la fuente original deja de estar disponible.

El servicio se expone vía HTTP y queda protegido externamente mediante proxy inverso y autenticación centralizada.

---

### Configuración utilizada (solo enlaces)

La configuración completa se mantiene versionada en Gitea:

[**Repositorio personal en Gitea – Linkwarden**](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/Linkwarden)

Incluye:

* `docker-compose.yml`
* `.env`
* Definición de volúmenes persistentes
* Conexión a PostgreSQL separada del contenedor principal

---

### Detalles clave del despliegue

* **Puerto expuesto:** `3009`
  Acceso directo en red interna:

  ```
  http://<IP-del-servidor>:3009
  ```

* **Base de datos PostgreSQL dedicada**
  Separar la base de datos permite:

  * Persistencia real de datos.
  * Backups independientes.
  * Actualizaciones del contenedor sin riesgo de pérdida.

* **Registro de usuarios deshabilitado por defecto**
  Controlado mediante:

  ```
  NEXT_PUBLIC_DISABLE_REGISTRATION=true
  ```

  Esto fuerza la creación inicial controlada y evita altas no deseadas si el servicio queda expuesto.

---

### Primeros pasos (resumen operativo)

Aunque la configuración real está en Gitea, el flujo general es:

1. Clonar el repositorio oficial de Linkwarden:

   ```
   git clone https://github.com/linkwarden/linkwarden.git
   cd linkwarden
   ```

2. Definir variables en el archivo `.env` (ver repositorio en Gitea para valores y estructura).

3. Levantar el stack:

   ```
   docker-compose up -d
   ```

4. Acceder vía navegador y crear el usuario inicial (solo posible si el registro está habilitado temporalmente o mediante configuración inicial).

Este apartado describe el **flujo lógico**, no sustituye la configuración real versionada.

---

### Validación

Comprobaciones básicas tras el despliegue:

* El contenedor web responde en el puerto configurado.
* La base de datos PostgreSQL acepta conexiones desde el servicio.
* No aparecen errores relevantes en los logs del contenedor.
* La interfaz web permite crear y consultar marcadores.
* Las capturas y archivos asociados se almacenan correctamente en los volúmenes persistentes.

---

### Notas personales

* Desplegado en local y accesible desde LAN y exterior.
* Protegido mediante Authentik a nivel de proxy.
* Usado como **almacén central de enlaces** (técnicos y personales).
* Especialmente útil para recuperar recursos ya guardados cuando no se recuerda su origen exacto.

---

### Referencias

* [Repositorio oficial en GitHub](https://github.com/linkwarden/linkwarden)
* [Repositorio personal en Gitea](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/Linkwarden)
* [Wiki: proteger con Authentik](https://wiki.jtrapero.eu.org/books/contenedores-configuracion/page/authentik-proteger-nuestras-aplicaciones-web)

# Pingvin Share: comparte archivos de forma sencilla y autohospedada

---
**Pingvin Share** es una herramienta para compartir archivos desde tu propio servidor. Parecida a WeTransfer, pero sin depender de terceros. Ligera, práctica y privada.

---

### docker-compose.yml

```yaml
docker-compose.yml

services:
  pingvin-share:
    image: stonith404/pingvin-share
    container_name: PGShare
    network_mode: bridge
    restart: unless-stopped
    ports:
      - 3008:3000
    environment:
      - TRUST_PROXY=true
    volumes:
      - "/mnt/shared/PGShare/data:/opt/app/backend/data"
      - "/mnt/shared/PGShare/data/images:/opt/app/frontend/public/img"
```

---

### Detalles clave

* **Puerto 3008**: acceso desde el navegador:

  ```
  http://<IP-del-servidor>:3008
  ```
* **Volúmenes**:

  * `/data`: archivos subidos
  * `/images`: imágenes de la interfaz
* **TRUST\_PROXY**: necesario si usas proxy inverso (Caddy, Nginx, etc.)

---

### Notas personales
* Si se usa con Cloudflare, conviene habilitar el troceado de archivos (chunks) para evitar el límite de 100 MB o bien evitar pasarlo por Cloudflare.
* El repositorio está actualmente sin mantenimiento (descontinuado), pero sigue funcionando bien.

---

### Enlaces de interés

* [Documentación oficial](https://stonith404.github.io/pingvin-share/)
* [Repositorio personal en Gitea](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/Pingvin%20Share)
* [Wiki: proteger con Authentik](https://wiki.jtrapero.eu.org/books/contenedores-configuracion/page/authentik-proteger-nuestras-aplicaciones-web)

# SearxNG: privacidad, control y velocidad

---
### Instalación de SearxNG

Instancia privada de SearxNG levantada en Docker, con Redis como backend opcional y configuración ajustada para uso personal.

---

### Características

* Búsquedas privadas y sin rastreo
* Interfaz ligera con tema oscuro
* Configurado para no ser listado como instancia pública
* IP protegida al cargar imágenes externas
* Integración con Redis para gestión eficiente de plugins

---

### Requisitos previos

* Docker y Docker Compose instalados
* Un dominio (opcional, pero recomendable)
* Conocimientos básicos de redes locales y puertos

---

### Estructura de archivos

* `docker-compose.yml`: define los servicios de SearxNG y Redis
* `searxng/settings.yml`: configuración principal del buscador
* `searxng/limiter.toml`: ajustes para detección de bots y gestión de IPs

---

### Paso 1: docker-compose.yml

Archivo básico para levantar los servicios:

```yaml
services:
  redis:
    container_name: redis
    image: docker.io/valkey/valkey:8-alpine
    command: valkey-server --save 30 1 --loglevel warning
    restart: unless-stopped
    volumes:
      - valkey-data:/data
    logging:
      driver: "json-file"
      options:
        max-size: "1m"
        max-file: "1"

  searxng:
    container_name: searxng
    image: docker.io/searxng/searxng:latest
    restart: unless-stopped
    ports:
      - "8163:8080"
    volumes:
      - ./searxng:/etc/searxng:rw
    environment:
      - SEARXNG_BASE_URL=https://${SEARXNG_HOSTNAME:-localhost}/
      - UWSGI_WORKERS=${SEARXNG_UWSGI_WORKERS:-4}
      - UWSGI_THREADS=${SEARXNG_UWSGI_THREADS:-4}
    logging:
      driver: "json-file"
      options:
        max-size: "1m"
        max-file: "1"

volumes:
  valkey-data:

networks:
  default:
    name: searxng_net
```

---

### Paso 2: settings.yml personalizado

Ajustes relevantes:

* Búsquedas vía POST (mejor privacidad)
* Instancia privada, no indexada
* Modo oscuro por defecto
* Plugins útiles como calculadora, conversor, etc.
* Image proxy activado

```yaml
# Fragmento relevante
server:
  port: "8080"
  bind_address: "127.0.0.1"
  base_url: "https://searxng.example.net/"
  limiter: true
  public_instance: false
  secret_key: "CAMBIA_ESTO_POR_UNA_LLAVE_SEGURA"
  image_proxy: true
  method: "POST"
```

---

### Paso 3: limiter.toml configurado

Permite excluir la red local del sistema de detección de bots:

```toml
[botdetection.ip_lists]
pass_ip = [
  "127.0.0.1",       # localhost
  "::1",             # localhost IPv6
  "10.0.0.0/24"      # red local o VPN de confianza
]
```

Esto evita que se apliquen restricciones innecesarias a las IPs propias.

---

Los archivos completos (`docker-compose.yml`, `settings.yml` y `limiter.toml`) están disponibles en mi Gitea:

[Repositorio en Gitea - ChronosCMPS](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/Searxng)

---

### Errores comunes o decisiones importantes

* Redis no es obligatorio, pero mejora el rendimiento de algunos plugins.
* No activar `debug: true` en producción.
* La clave secreta no debe ser corta ni predecible.
* `public_instance: true` hará que tu instancia aparezca listada públicamente. Dejarlo en `false`.

---

### Resumen breve

* Usa `docker-compose up -d` para levantar la instancia.
* Accede en `https://tudominio:8163` (o usa un proxy como Caddy).
* La configuración está en `./searxng/settings.yml`
* Protege la clave secreta y revisa los plugins activos.

---

### Notas personales

Si vas a exponer tu instancia a Internet, es **altamente recomendable protegerla con Authentik o un sistema de autenticación similar**, especialmente si no quieres que cualquiera pueda usarla. Así la tengo montada yo actualmente, integrada con Caddy y OIDC.

En los enlaces que dejo abajo hay recursos útiles para securizar SearxNG correctamente.

---

### Enlaces de interés

* [Authentik – Proteger nuestras aplicaciones web](https://wiki.jtrapero.eu.org/books/contenedores-configuracion/page/authentik-proteger-nuestras-aplicaciones-web)
* [Directivas de Caddy (uso personal)](https://wiki.jtrapero.eu.org/books/caddy/page/directivas-de-caddy-uso-personal)
* [Repositorio oficial de Docker para SearxNG](https://github.com/searxng/searxng-docker)
* [Caddy – Gestionar dominios fácilmente](https://wiki.jtrapero.eu.org/books/servicios/page/caddy-gestion-e-instalacion-sencilla-de-dominios)

# WebCheck: Análisis OSINT de sitios web

---

### Introducción

WebCheck es una herramienta OSINT orientada al análisis técnico de dominios y aplicaciones web desde una interfaz unificada. Permite centralizar comprobaciones que normalmente requerirían varias herramientas separadas como `dig`, `whois`, `nmap`, SSL Labs, Wappalyzer o distintos servicios públicos de reputación y análisis HTTP.

Dentro del stack encaja como una utilidad de diagnóstico y reconocimiento rápido para revisar dominios propios o externos, validar configuraciones expuestas hacia Internet y detectar información pública accesible sobre un servicio.

El proyecto está desarrollado principalmente en TypeScript y React, y combina múltiples fuentes y técnicas de reconocimiento desde una única interfaz web.

---

### Enfoque general

El despliegue se realiza mediante un único contenedor Docker expuesto detrás del reverse proxy. La aplicación funciona completamente desde navegador y ejecuta distintas comprobaciones OSINT y de reconocimiento sobre el dominio indicado.

Las integraciones opcionales mediante claves API permiten ampliar la información obtenida desde servicios externos como Shodan o WHOAPI.

---

### Desarrollo

#### Qué se hizo y por qué

Se desplegó WebCheck como una utilidad ligera de análisis y reconocimiento para revisar rápidamente dominios, servicios públicos y configuraciones expuestas hacia Internet.

El contenedor se publica internamente en el puerto `3100`, evitando conflictos con otros servicios ya presentes en el host.

También se añadieron variables de entorno para integrar claves API externas (puedes mirar más, en su documetación o Github):

- `REACT_APP_SHODAN_API_KEY`
- `REACT_APP_WHO_API_KEY`

Estas integraciones permiten enriquecer parte de la información OSINT mostrada desde la interfaz.

#### Configuración utilizada

- [Docker Compose de WebCheck](https://gitea.jtrapero.eu.org/R4di04kt1v3/ChronosCMPS/src/branch/main/Herramientas/WebCheck)

#### Validación

La validación mínima consiste en:

- Acceso correcto a la interfaz web
- Resolución funcional de dominios consultados
- Ejecución correcta de análisis DNS, headers HTTP y TLS
- Comprobación de funcionamiento de integraciones externas mediante las claves API
- Verificación de conectividad saliente del contenedor hacia Internet

---

### Decisiones importantes o problemas detectados

Parte de la información mostrada depende de servicios externos y puede variar según límites de API, rate limiting o disponibilidad de terceros.

Algunas comprobaciones OSINT también pueden devolver resultados incompletos si el dominio utiliza servicios intermedios como Cloudflare o proxies inversos agresivos.

---

### Resumen breve

WebCheck centraliza múltiples comprobaciones OSINT y de reconocimiento web desde una única interfaz, facilitando la validación rápida de dominios, servicios públicos y configuraciones expuestas mediante un despliegue Docker muy ligero.

---

### Referencias

- [Repositorio oficial de WebCheck](https://github.com/Lissy93/web-check)
- [Demo pública del proyecto](https://web-check.xyz/)