Skip to main content

Wireguard

image.png

La mejor manera de instalar WireGuard en Ubuntu 24.04 es usando APT, ya que WireGuard está completamente integrado en el kernel de Linux moderno y sus paquetes están en los repos oficiales de Ubuntu.

Enlaces

https://www.wireguard.com/

https://www.server-world.info/en/note?os=Ubuntu_22.04&p=wireguard&f=1

✅ Instalación

1. Actualizar el sistema

sudo apt update && sudo apt upgrade -y

2. Instalar WireGuard y herramientas necesarias

sudo apt install wireguard wireguard-tools -y

Esto instala:

  • wg → cliente de línea de comandos

  • wg-quick → herramienta de alto nivel para subir/bajar interfaces

  • Módulo del kernel WireGuard (wireguard.ko), ya incluido en 24.04

3. Habilitar IP forwarding (si actúa como gateway)

echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf sudo sysctl -p

Diagrama

  +------------------------+
  | [  WireGuard Server  ] |10.0.0.1 (VPN IP)
  |      tu_servidor.com   +--------+
  |                        |wg0     |
  +-----------+------------+        |
          eth0|192.168.1.201/24     |
              |                     |
              |       Local Network |
       +------+-----+               |
       |  Router_1  |               |
       +------+-----+               |
              |                     |
    Internet  |  Internet           |
              |                     |
       +------+-----+               |
       |  Router_2  |               |
       +------+-----+               |
              |       Local Network |
              |                     |
          eth0|192.168.10.30/24     |
  +-----------+------------+        |
  |  [ WireGuard Client ]  |wg0     |
  |                        +--------+
  |                        |10.0.0.2 (VPN IP)
  +------------------------+

A partir de aquí, usaremos usuario root para que los fichero se creen con los permisos adecuados

# con usuario root
sudo su
umask 077

Estructura final de los ficheros en el servidor:

/etc/wireguard/
├── wg0.conf               # Config servidor
├── server.key             # Clave privada servidor
├── server.pub             # Clave pública servidor
├── client.key             # Clave privada cliente
├── client.pub             # Clave pública cliente
└── client.conf            # Config cliente

4. Generar claves

# generate private key for server
wg genkey | tee /etc/wireguard/server.key

# generate public key for server
cat /etc/wireguard/server.key | wg pubkey | tee /etc/wireguard/server.pub

# generate private key for client
wg genkey | tee /etc/wireguard/client.key

# generate public key for client
cat /etc/wireguard/client.key | wg pubkey | tee /etc/wireguard/client.pub

5. Archivo de configuración

Servidor

Ubicación típica: /etc/wireguard/wg0.conf 

[Interface]
PrivateKey = <clave_privada_servidor>  # Contenido de /etc/wireguard/server.key
Address = 10.0.0.1 # IP_address for VPN interface
ListenPort = 51820 # UDP port WireGuard server listens

# Commands after WireGuard starts/stops.Set routing rules like follows to access to local network via VPN session
# [wg0] ⇒ VPN interface name
# [eth0] ⇒ Ethernet interface name
PostUp = echo 1 > /proc/sys/net/ipv4/ip_forward; iptables -A FORWARD -i wg0 -j ACCEPT; iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
PostDown = echo 0 > /proc/sys/net/ipv4/ip_forward; iptables -D FORWARD -i wg0 -j ACCEPT; iptables -t nat -D POSTROUTING -o eth0 -j MASQUERADE

[Peer]
PublicKey = <clave_publica_cliente>  # Contenido de /etc/wireguard/client.pub
# clients' VPN IP addresses you allow to connect
AllowedIPs = 10.0.0.0/24
Cliente

Ubicación típica: /etc/wireguard/client.conf

[Interface]
PrivateKey = <clave_privada_del_cliente>  # Contenido de /etc/wireguard/client.key
Address = 10.0.0.2/24  # IP del cliente en la VPN
DNS = 1.1.1.1  # Opcional

[Peer]
PublicKey = <clave_pública_del_servidor>  # Contenido de /etc/wireguard/server.pub
Endpoint = tu_servidor.com:51820  # IP o dominio del servidor + puerto
AllowedIPs = 0.0.0.0/0  # Enruta todo el tráfico por la VPN (o usa 10.0.0.0/24 para solo la red VPN)
PersistentKeepalive = 25  # Opcional: Mantiene la conexión activa tras NAT

6. Activar y habilitar la interfaz

sudo wg-quick up wg0 sudo systemctl enable wg-quick@wg0

Comandos

# interfaces activas y estadísticas
sudo wg show
# detalles específicos de una interfaz
sudo wg show wg0
# estado del servicio
sudo systemctl status wg-quick@wg0
# Reiniciar WireGuard d (para aplicar cambios en la configuración)
sudo systemctl restart wg-quick@wg0
# Monitorizar conexiones en tiempo real
sudo journalctl -u wg-quick@wg0 -f

QR para autoconfigurar los clientes Wireguard

Para generar un código QR que permita a los clientes de WireGuard (especialmente móviles) configurarse fácilmente, sigue estos pasos:

Instalar qrencode

sudo apt update && sudo apt install qrencode -y

Generar el código QR

qrencode -t ansiutf8 < /etc/wireguard/client.conf # Muestra el QR en la terminal (copiable)

Creación de clientes automática

Ejecuta estos comandos con root $ sudo su

script completo y automatizado para crear nuevos peers en WireGuard, incluyendo:

  • Generación de claves pública/privada
  • Creación del archivo de configuración del cliente (.conf)
  • Actualización automática del servidor (wg0.conf)
  • Generación de código QR (opcional)

Funciones incluidas

  1. Validación de IP:

    • Formato correcto (ej. 10.0.0.2).

    • Evita duplicados en wg0.conf.

  2. Sistema de Backup:

    • Crea copias de wg0.conf en /etc/wireguard/backups/ con timestamp.

  3. Manejo de Errores:

    • Revertir cambios si falla la recarga de WireGuard.

    • Logs detallados en /var/log/wireguard_peers.log.

  4. Interfaz Mejorada:

    • Colores para mensajes (rojo/verde/amarillo).

    • Soporte para generar QR con el argumento qr.

  5. Seguridad:

    • Permisos 600 para archivos .conf.

    • Verificación de ejecución como root.

#!/bin/bash
# Descripción: Crea peers en WireGuard con validación de IPs, backup y logs
# Uso: sudo ./crear_peer_wg.sh <nombre_del_peernombre_peer> <ip_del_peerip_peer> [opcional: generar QR]qr]

# --- Configuración (ajusta estas variables) ---
WG_DIR="/etc/wireguard"
SERVER_PUBKEY=$(cat "$WG_DIR/server.pub")
# Clave pública del servidor
SERVER_ENDPOINT="tu-servidor.com:51820"
# IP/Dominio + puerto del servidor
DNS="1.1.1.1"                              # DNS para el cliente
ALLOWED_IPS="0.0.0.0/0"
LOG_FILE="/var/log/wireguard_peers.log"
BACKUP_DIR="/etc/wireguard/backups"

# Redes--- accesiblesColores apara travésterminal del---
VPNRED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# --- Funciones ---
validar_ip() {
    local ip="$1"
    local stat=1
    if [[ $ip =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then
        IFS='.' read -ra octetos <<< "$ip"
        [[ ${octetos[0]} -le 255 && ${octetos[1]} -le 255 && \
           ${octetos[2]} -le 255 && ${octetos[3]} -le 255 ]]
        stat=$?
    fi
    return $stat
}

ip_en_uso() {
    grep -q "$1/32" "$WG_DIR/wg0.conf"
}

crear_backup() {
    mkdir -p "$BACKUP_DIR"
    local timestamp=$(date +"%Y%m%d_%H%M%S")
    cp "$WG_DIR/wg0.conf" "$BACKUP_DIR/wg0.conf_$timestamp"
}

# --- Validación de argumentosinicial ---
if [ "$(id -u)" -ne 0 ]; then
    echo -e "${RED}Error: Este script debe ejecutarse como root.${NC}" | tee -a "$LOG_FILE"
    exit 1
fi

if [ -z "$1" ] || [ -z "$2" ]; then
    echo "Error: Faltan argumentos."
    echo-e "${RED}Uso: $0 <nombre_del_peernombre_peer> <ip_del_peerip_peer> [qr]${NC}" | tee -a "$LOG_FILE"
    echo -e "Ejemplo: ${YELLOW}$0 juan-laptopsmartphone 10.0.0.2"2 qr${NC}" | tee -a "$LOG_FILE"
    exit 1
fi

PEER_NAME="$1"
PEER_IP="$2"
GENERAR_QR="$3"

# --- Validar IP ---
if ! validar_ip "$PEER_IP"; then
    echo -e "${RED}Error: La IP $PEER_IP no es válida.${NC}" | tee -a "$LOG_FILE"
    exit 1
fi

if ip_en_uso "$PEER_IP"; then
    echo -e "${RED}Error: La IP $PEER_IP ya está en uso.${NC}" | tee -a "$LOG_FILE"
    exit 1
fi

# --- Crear backup ---
crear_backup
echo -e "${GREEN}Backup creado en $BACKUP_DIR/${NC}" | tee -a "$LOG_FILE"

# --- Generar claves ---
PEER_PRIVKEY=$(wg genkey)
PEER_PUBKEY=$(echo "$PEER_PRIVKEY" | wg pubkey)
PEER_CONF="$WG_DIR/${PEER_NAME}.conf"

# --- Crear archivo de configuración del peer ---
cat > "$PEER_CONF" <<EOF
[Interface]
PrivateKey = $PEER_PRIVKEY
Address = $PEER_IP/24
DNS = $DNS

[Peer]
PublicKey = $SERVER_PUBKEY
Endpoint = $SERVER_ENDPOINT
AllowedIPs = $ALLOWED_IPS
PersistentKeepalive = 25
EOF

chmod 600 "$PEER_CONF"

# --- Actualizar wg0.conf del servidor ---
cat >> "$WG_DIR/wg0.conf" <<EOF

# Peer: $PEER_NAME ($(date +"%Y-%m-%d"))
[Peer]
PublicKey = $PEER_PUBKEY
AllowedIPs = $PEER_IP/32
EOF

# --- Recargar configuración ---
if ! wg syncconf wg0 <(wg-quick strip wg0 2>/dev/null); then
    echo -e "${RED}Error al recargar WireGuard. Revertiendo cambios...${NC}" | tee -a "$LOG_FILE"
    mv "$BACKUP_DIR/wg0.conf_$timestamp" "$WG_DIR/wg0.conf"
    rm "$PEER_CONF"
    exit 1
fi

# --- Generar QR (opcional) ---
if [[ "$GENERAR_QR" == "qr" ]] && command -v qrencode &> /dev/nullnull; &&then
    [echo -ne "\n${YELLOW}=== Código QR para $PEER_NAME ===${NC}" | tee -a "$3" ]; thenLOG_FILE"
    qrencode -t ansiutf8 < "$PEER_CONF"
echo "Código QR generado para $PEER_NAME"
fi

# --- RecargarResultado WireGuard ---
wg syncconf wg0 <(wg-quick strip wg0)

# --- Resultadosfinal ---
echo -e "\n${GREEN}✔ Peer '$PEER_NAME' creado correctamente.exitosamente.${NC}" | tee -a "$LOG_FILE"
echo -e "Clave pública: ${YELLOW}$PEER_PUBKEY${NC}" | tee -a "$LOG_FILE"
echo -e "Archivo de configuración: $PEER_CONF"{YELLOW}$PEER_CONF${NC}" | tee -a "$LOG_FILE"
echo -e "ClaveIP pública:asignada: $PEER_PUBKEY"{YELLOW}$PEER_IP${NC}" | tee -a "$LOG_FILE"

Cómo Usarlo

  1. Guarda el script en /usr/local/bin/crear_peer_wg.sh y dale permisos:

    chmod +x /usr/local/bin/crear_peer_wg.sh

  2. Ejecútalo (como root):

    crear_peer_wg.sh juan-smartphone 10.0.0.2 qr  # El último argumento genera QR

Failover Cluster

Requisitos

Script

Script para copiar el contenido del directorio /etc/wireguard desde un servidor MASTER a un BACKUP:

sudo vi /usr/local/bin/wg_backup.sh
#!/bin/bash
# Descripción: Copia /etc/wireguard desde MASTER a BACKUP vía rsync (requiere SSH sin password)
# Uso: Ejecutar como root en el MASTER

# Variables (ajusta según tu entorno)
BACKUP_USER="root"
BACKUP_SERVER="ip_del_backup"  # Ej: 192.168.1.100
WG_DIR="/etc/wireguard"
LOG_FILE="/var/log/wg_backup.log"

# ---- Copia segura con rsync ----
echo "==== Iniciando copia el $(date) ====" >> "$LOG_FILE"
rsync -avz --delete \
    -e "ssh -o StrictHostKeyChecking=no -i /root/.ssh/id_rsa_wgbackup" \
    "$WG_DIR/" "$BACKUP_USER@$BACKUP_SERVER:$WG_DIR/" >> "$LOG_FILE" 2>&1

# Verifica el resultado
if [ $? -eq 0 ]; then
    echo "[OK] Copia completada exitosamente." >> "$LOG_FILE"
else
    echo "[ERROR] Fallo en la copia. Revisa $LOG_FILE" >> "$LOG_FILE"
fi

Permisos del script

sudo chmod 700 /usr/local/bin/wg_backup.sh
sudo chown root:root /usr/local/bin/wg_backup.sh

Verificación y Monitoreo

Ejecuta estos comandos con root $ sudo su

  • Revisa el log de copia:

    cat /var/log/wg_backup.log

  • Prueba el script manualmente:

    /usr/local/bin/wg_backup.sh

Automatiza con cron

Configuración de Cron (Ejecución diaria a las 00:00)

  1. Abre el cron de root:

    sudo crontab -e

  2. Añade esta línea al final:

    0 0 * * * /usr/local/bin/wg_backup.sh

Back to top