3 de mayo de 2026 • 12 min lectura

Guía completa para instalar OpenVAS en Ubuntu Server (2026)

h3st4k3r

En esta guía vamos a instalar OpenVAS en Ubuntu Server. Para ser precisos, lo que realmente vamos a desplegar es Greenbone Community Edition, también conocido como GVM, junto con el motor de escaneo OpenVAS.

OpenVAS sigue siendo el nombre más conocido, pero hoy el ecosistema completo se compone de varios servicios: gestor, interfaz web, escáner, base de datos, feeds, Redis y componentes auxiliares. No es una herramienta de “instalar y listo” si queremos hacerlo bien.

Qué vamos a montar

La instalación se hará sobre Ubuntu Server 24.04 LTS, siguiendo el enfoque de compilación desde código fuente. He elegido esta vía porque es la documentada oficialmente por Greenbone para Ubuntu 24.04 y evita depender de paquetes mantenidos por terceros, que pueden variar bastante entre distribuciones.

Eso sí: la propia documentación oficial indica que esta instalación desde código fuente no está pensada como despliegue de producción soportado. Para producción real, Greenbone recomienda sus productos comerciales o appliances.

Componentes principales

Componente	Función
`gvm-libs`	Librerías base usadas por el resto de componentes
`gvmd`	Demonio principal de gestión, usuarios, tareas y reportes
`pg-gvm`	Extensión de PostgreSQL usada por Greenbone
`gsa` / `gsad`	Interfaz web de administración
`openvas-scanner`	Motor de escaneo de vulnerabilidades
`ospd-openvas`	Servicio que conecta Greenbone con el escáner OpenVAS
`openvasd`	Servicio usado para Notus y detección de productos
`greenbone-feed-sync`	Sincronización de feeds
`redis`	Almacenamiento intermedio usado por el escáner
`postgresql`	Base de datos central

Requisitos recomendados

Recurso	Mínimo	Recomendado
CPU	2 núcleos	4 núcleos o más
RAM	4 GB	8 GB o más
Disco	20 GB	60 GB o más

Si vas a escanear bastantes activos, usar escaneos autenticados o mantener históricos de reportes, no te quedes corto. Greenbone consume bastante disco y los feeds tardan en descargarse y cargarse.

Puertos importantes

9392/TCP: interfaz web de Greenbone.
873/TCP: usado normalmente para sincronización de feeds vía rsync.
22/TCP: escaneos autenticados por SSH.
445/TCP y 139/TCP: escaneos autenticados contra Windows por SMB.
161/UDP: SNMP para dispositivos de red.

Preparar Ubuntu

Partimos de un Ubuntu Server limpio.

sudo apt update
sudo apt full-upgrade -y
sudo reboot

Cuando el sistema vuelva a arrancar:

sudo apt update
sudo apt install -y ca-certificates curl gnupg build-essential cmake pkg-config python3 python3-pip

Crear el usuario de Greenbone

sudo useradd -r -M -U -G sudo -s /usr/sbin/nologin gvm
sudo usermod -aG gvm $USER
su $USER

El comando su $USER sirve para recargar los grupos en la sesión actual.

Variables de trabajo

export INSTALL_PREFIX=/usr/local
export PATH=$PATH:$INSTALL_PREFIX/sbin

export SOURCE_DIR=$HOME/source
mkdir -p $SOURCE_DIR

export BUILD_DIR=$HOME/build
mkdir -p $BUILD_DIR

export INSTALL_DIR=$HOME/install
mkdir -p $INSTALL_DIR

Importar la clave de Greenbone

curl -f -L https://www.greenbone.net/GBCommunitySigningKey.asc -o /tmp/GBCommunitySigningKey.asc
gpg --import /tmp/GBCommunitySigningKey.asc
echo "8AE4BE429B60A59B311C2E739823FAA60ED1E580:6:" | gpg --import-ownertrust

Este paso es importante porque vamos a descargar código fuente firmado. No tiene sentido montar un escáner de vulnerabilidades ignorando la verificación de integridad del propio software.

Compilar los componentes

La instalación completa consiste en descargar, verificar, compilar e instalar cada componente. El patrón se repite:

Definir versión.
Instalar dependencias.
Descargar código fuente y firma.
Verificar con GPG.
Compilar con CMake o pip.
Instalar bajo /usr/local.

Para no convertir este artículo en una copia infinita de comandos, en el repositorio dejo el instalador completo preparado por bloques. Aun así, el flujo manual principal sería este para cada componente:

curl -f -L URL_DEL_TARBALL -o $SOURCE_DIR/componente.tar.gz
curl -f -L URL_DE_LA_FIRMA -o $SOURCE_DIR/componente.tar.gz.asc

gpg --verify $SOURCE_DIR/componente.tar.gz.asc $SOURCE_DIR/componente.tar.gz

tar -C $SOURCE_DIR -xvzf $SOURCE_DIR/componente.tar.gz

cmake -S $SOURCE_DIR/componente -B $BUILD_DIR/componente \
  -DCMAKE_INSTALL_PREFIX=$INSTALL_PREFIX \
  -DCMAKE_BUILD_TYPE=Release \
  -DSYSCONFDIR=/etc \
  -DLOCALSTATEDIR=/var

cmake --build $BUILD_DIR/componente -j$(nproc)

mkdir -p $INSTALL_DIR/componente
cd $BUILD_DIR/componente
make DESTDIR=$INSTALL_DIR/componente install
sudo cp -rv $INSTALL_DIR/componente/* /

Los componentes que hay que compilar o instalar son:

gvm-libs
gvmd
pg-gvm
gsa
gsad
openvas-smb, recomendable si vas a escanear Windows
openvas-scanner
ospd-openvas
openvasd
greenbone-feed-sync
gvm-tools, opcional para automatización por línea de comandos

Configurar Redis

OpenVAS usa Redis como almacenamiento intermedio. Sin Redis bien configurado, el escáner no va a funcionar correctamente.

sudo apt install -y redis-server

sudo cp $SOURCE_DIR/openvas-scanner-$OPENVAS_SCANNER_VERSION/config/redis-openvas.conf /etc/redis/
sudo chown redis:redis /etc/redis/redis-openvas.conf

echo "db_address = /run/redis-openvas/redis.sock" | sudo tee -a /etc/openvas/openvas.conf

sudo systemctl start redis-server@openvas.service
sudo systemctl enable redis-server@openvas.service

sudo usermod -aG redis gvm

Permisos necesarios

sudo mkdir -p /var/lib/notus
sudo mkdir -p /run/gvmd

sudo chown -R gvm:gvm /var/lib/gvm
sudo chown -R gvm:gvm /var/lib/openvas
sudo chown -R gvm:gvm /var/lib/notus
sudo chown -R gvm:gvm /var/log/gvm
sudo chown -R gvm:gvm /run/gvmd

sudo chmod -R g+srw /var/lib/gvm
sudo chmod -R g+srw /var/lib/openvas
sudo chmod -R g+srw /var/log/gvm

sudo chown gvm:gvm /usr/local/sbin/gvmd
sudo chmod 6750 /usr/local/sbin/gvmd

Permitir ejecución del escáner

El escáner necesita ejecutar ciertas comprobaciones con privilegios elevados. Para ello se permite a miembros del grupo gvm ejecutar OpenVAS vía sudo sin contraseña.

echo "%gvm ALL = NOPASSWD: /usr/local/sbin/openvas" | sudo tee /etc/sudoers.d/gvm
sudo chmod 0440 /etc/sudoers.d/gvm

Esto no debe tomarse a la ligera. Conviene limitar muy bien quién pertenece al grupo gvm, porque no es un grupo administrativo cualquiera.

Configurar PostgreSQL

sudo apt install -y postgresql
sudo systemctl start postgresql@16-main

Creamos usuario y base de datos:

sudo -u postgres bash
cd
createuser -DRS gvm
createdb -O gvm gvmd
psql gvmd -c "create role dba with superuser noinherit; grant dba to gvm;"
exit

Crear el usuario administrador

Podemos dejar que Greenbone genere una contraseña automáticamente:

/usr/local/sbin/gvmd --create-user=admin

O podemos definirla nosotros:

/usr/local/sbin/gvmd --create-user=admin --password='TuPasswordSegura'

Si algo falla, el primer sitio donde mirar es el log de gvmd:

sudo tail -n 100 /var/log/gvm/gvmd.log

Definir el Feed Import Owner

Este paso es clave. Si no se define correctamente, pueden no aparecer configuraciones como Full and fast, listas de puertos o formatos de reporte.

/usr/local/sbin/gvmd --modify-setting 78eceaec-3385-11ea-b237-28d24461215b --value `/usr/local/sbin/gvmd --get-users --verbose | grep admin | awk '{print $2}'`

Servicios systemd

Para que Greenbone arranque correctamente necesitamos crear servicios para:

ospd-openvas
gvmd
gsad
openvasd

Después de crear los ficheros en /etc/systemd/system/, recargamos systemd:

sudo systemctl daemon-reload

Sincronizar el feed inicial

Este paso suele tardar bastante. No es raro que la primera sincronización tarde desde varios minutos hasta horas, según la máquina y la conexión.

sudo /usr/local/bin/greenbone-feed-sync

Una vez descargado, todavía queda la carga interna del feed por parte de los servicios. Que el comando termine no significa que la plataforma esté lista para escanear.

Arrancar servicios

sudo systemctl start openvasd
sudo systemctl start ospd-openvas
sudo systemctl start gvmd
sudo systemctl start gsad

sudo systemctl enable openvasd
sudo systemctl enable ospd-openvas
sudo systemctl enable gvmd
sudo systemctl enable gsad

Comprobar estado

sudo systemctl status redis-server@openvas.service
sudo systemctl status openvasd
sudo systemctl status ospd-openvas
sudo systemctl status gvmd
sudo systemctl status gsad

También conviene revisar logs:

sudo tail -f /var/log/gvm/gvmd.log
sudo tail -f /var/log/gvm/ospd-openvas.log

Acceder a la interfaz web

Por defecto, lo más recomendable es dejar la interfaz escuchando solo en localhost:

http://127.0.0.1:9392

Si administras el servidor de forma remota, puedes usar un túnel SSH:

ssh -L 9392:127.0.0.1:9392 usuario@tu-servidor

Y luego abrir en tu navegador:

http://127.0.0.1:9392

Exponer la GUI en red

Si necesitas acceder desde otra máquina de tu red, puedes hacer que gsad escuche en todas las interfaces.

Edita:

/etc/systemd/system/gsad.service

Y cambia:

ExecStart=/usr/local/sbin/gsad --foreground --listen=127.0.0.1 --port=9392 --http-only

por:

ExecStart=/usr/local/sbin/gsad --foreground --listen=0.0.0.0 --port=9392 --http-only

Después:

sudo systemctl daemon-reload
sudo systemctl restart gsad

Mi recomendación práctica es no publicar el puerto 9392 directamente en Internet. Mejor dejarlo detrás de VPN, túnel SSH o proxy inverso con TLS.

Actualizar el feed

Para actualizar todos los feeds manualmente:

sudo /usr/local/bin/greenbone-feed-sync

También podemos actualizar partes concretas:

sudo greenbone-feed-sync --type nvt
sudo greenbone-feed-sync --type scap
sudo greenbone-feed-sync --type cert
sudo greenbone-feed-sync --type gvmd-data

Automatizar actualización del feed

Podemos crear un servicio y un temporizador de systemd para lanzar la sincronización periódicamente.

Servicio:

# /etc/systemd/system/greenbone-feed-sync.service

[Unit]
Description=Actualizar Greenbone Community Feed
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/greenbone-feed-sync

Temporizador:

# /etc/systemd/system/greenbone-feed-sync.timer

[Unit]
Description=Ejecución programada del feed sync de Greenbone

[Timer]
OnCalendar=*-*-* 03:30:00
Persistent=true

[Install]
WantedBy=timers.target

Activación:

sudo systemctl daemon-reload
sudo systemctl enable --now greenbone-feed-sync.timer
sudo systemctl list-timers | grep greenbone-feed-sync

Primer escaneo no autenticado

Un escaneo no autenticado es el enfoque clásico de caja negra. No usa credenciales y analiza lo que el objetivo expone por red.

Desde la interfaz web:

Ir a Configuration → Targets.
Crear un nuevo target.
Indicar IP, rango o dominio.
No añadir credenciales.
Ir a Scans → Tasks.
Crear una nueva tarea.
Seleccionar el target.
Usar OpenVAS como scanner.
Usar Full and fast como configuración base.
Guardar y lanzar.

Escaneos autenticados

Los escaneos autenticados son mucho más útiles en entornos internos, porque permiten comprobar parches instalados, versiones reales, paquetes, configuraciones y software local.

Tipo	Uso habitual	Puertos
SSH	Linux / Unix	22/TCP
SMB	Windows	445/TCP, 139/TCP
SNMP	Dispositivos de red	161/UDP
ESXi	VMware ESXi	Según configuración

El flujo es sencillo:

Crear credencial en Configuration → Credentials.
Asociarla al target.
Crear la tarea con ese target.
Lanzar el escaneo.
Revisar si el reporte indica que la autenticación ha funcionado.

Ejemplo de usuario para escaneo SSH

En un servidor Linux objetivo podemos crear un usuario dedicado:

sudo adduser svc_openvas
sudo apt update
sudo apt install -y plocate

Si vamos a usar clave SSH:

sudo mkdir -p /home/svc_openvas/.ssh
sudo chmod 700 /home/svc_openvas/.ssh
sudo chown -R svc_openvas:svc_openvas /home/svc_openvas/.ssh

Después añadimos la clave pública en:

/home/svc_openvas/.ssh/authorized_keys

Y ajustamos permisos:

sudo chmod 600 /home/svc_openvas/.ssh/authorized_keys
sudo chown svc_openvas:svc_openvas /home/svc_openvas/.ssh/authorized_keys

Escaneo autenticado de Windows

Para Windows, lo normal es usar credenciales SMB. Conviene comprobar que el servidor Greenbone alcanza los puertos 445/TCP y 139/TCP del objetivo.

En entornos corporativos, un usuario con privilegios administrativos suele ofrecer mucha más cobertura, aunque esto debe gestionarse con cuidado y con una cuenta dedicada.

Escaneo SNMP

Para equipos de red, SNMP puede ser muy útil, pero hay un detalle importante: muchas listas de puertos por defecto no incluyen UDP. Si vas a usar SNMP, asegúrate de que la lista de puertos incluye 161/UDP.

Flujo recomendado

Para un entorno realista, yo seguiría este orden:

Escaneo no autenticado de superficie externa o DMZ.
Escaneo autenticado interno por SSH, SMB o SNMP.
Uso de Full and fast como base.
Revisión de falsos positivos.
Priorización por exposición, criticidad y explotabilidad.
Automatización de feeds y copias de seguridad.

Automatización con gvm-tools

Si queremos lanzar tareas desde línea de comandos o integrarlo con otros sistemas, podemos usar gvm-tools.

gvm-cli socket --xml "<get_version/>"

Ejemplo simplificado para crear un objetivo:

gvm-cli socket --xml "<create_target><name>Servidor de prueba</name><hosts>192.168.1.10</hosts></create_target>"

En entornos reales suele ser más cómodo crear primero targets y credenciales desde la interfaz web y luego automatizar el arranque y consulta de tareas.

Resolución rápida de problemas

La interfaz web no abre

sudo systemctl status gsad
sudo ss -ltnp | grep 9392

Si solo escucha en 127.0.0.1, usa túnel SSH o cambia el parámetro --listen.

No aparecen configuraciones de escaneo

Normalmente se debe a una de estas causas: el feed no ha terminado de cargar, no se ha definido el Feed Import Owner o hay errores en gvmd u ospd-openvas.

sudo tail -n 200 /var/log/gvm/gvmd.log
sudo tail -n 200 /var/log/gvm/ospd-openvas.log

El escaneo autenticado por SSH falla

Revisa conectividad, usuario, contraseña o clave, permisos de authorized_keys, configuración de SSH y privilegios reales del usuario.

SNMP no devuelve resultados

Comprueba que la lista de puertos incluye 161/UDP. Si no está incluido, los tests SNMP pueden no ejecutarse aunque la credencial sea correcta.

Copias de seguridad

En una instalación mínimamente seria conviene guardar la base de datos y los directorios principales.

sudo -u postgres pg_dump gvmd > /var/backups/gvmd-$(date +%F).sql

sudo tar czf /var/backups/gvm-files-$(date +%F).tar.gz \
  /etc/openvas \
  /var/lib/openvas \
  /var/lib/notus \
  /var/lib/gvm

Endurecimiento básico

Algunas medidas razonables para no dejar una instalación débil:

Mantener gsad en localhost siempre que sea posible.
Usar túnel SSH, VPN o proxy inverso con TLS.
Restringir 9392/TCP por cortafuegos.
Controlar muy bien los usuarios del grupo gvm.
Programar sincronización periódica del feed.
Hacer copia de seguridad de PostgreSQL y directorios críticos.

Ejemplo básico con UFW para permitir acceso solo desde una red de administración:

sudo ufw allow from 192.168.100.0/24 to any port 9392 proto tcp
sudo ufw enable

Alternativa con contenedores

Greenbone también documenta una instalación mediante contenedores oficiales. Esta opción puede ser más limpia si no quieres llenar el sistema base de dependencias de compilación.

La instalación con contenedores se basa en varios servicios separados y se orquesta normalmente con Docker Compose. No es simplemente ejecutar un único contenedor y olvidarse, ya que Greenbone necesita varios componentes trabajando juntos.

Para laboratorio, pruebas y despliegues rápidos, puede ser una opción muy cómoda. Para entender bien qué está ocurriendo por debajo, la instalación desde fuente sigue siendo más didáctica.

Conclusión

OpenVAS, o mejor dicho Greenbone Community Edition, no es una herramienta ligera, pero sigue siendo una de las opciones abiertas más potentes para montar un entorno de análisis de vulnerabilidades.

La clave está en no quedarse solo en “instalar y lanzar escaneos”. Hay que cuidar feeds, credenciales, tareas, alcance, rendimiento, reportes, falsos positivos y mantenimiento. Si lo montamos bien, puede ser una pieza muy útil dentro de un laboratorio, una pequeña plataforma de gestión de vulnerabilidades o un entorno de aprendizaje profesional.

Como siguiente paso natural, lo interesante sería automatizar la creación de objetivos, el lanzamiento de tareas y la exportación de informes usando gvm-tools, igual que hicimos con OWASP ZAP mediante API.