Come installare GVM Vulnerability Scanner su Ubuntu 20.04

GVM (Greenbone Vulnerability Management) è una soluzione open source per la scansione e la gestione delle vulnerabilità. GVM era precedentemente noto come OpenVAS .

Greenbone Vulnerability Manager e OpenVAS sono ampiamente utilizzati da un certo numero di persone nel mondo, inclusi esperti di sicurezza e utenti comuni che hanno utilizzato tutto questo in un'unica suite di strumenti che funziona insieme per eseguire i test sui computer client utilizzando il proprio database di punti deboli noti e exploit.

In questo articolo mostreremo come installare e configurare GVM su Ubuntu 20.04 per assicurarci che i tuoi server siano protetti dagli attacchi.

Sistema di base

Installeremo Greenbone Vulnerability Manager 20.08 con l'installazione di base dei pacchetti di sistema su Ubuntu 20.04.

Installa i prerequisiti

Per prima cosa installa i seguenti pacchetti di dipendenze.

sudo su -
apt update &&\
apt -y dist-upgrade &&\
apt -y autoremove &&\
apt install -y software-properties-common &&\
apt install -y build-essential cmake pkg-config libglib2.0-dev libgpgme-dev libgnutls28-dev uuid-dev libssh-gcrypt-dev libldap2-dev doxygen graphviz libradcli-dev libhiredis-dev libpcap-dev bison libksba-dev libsnmp-dev gcc-mingw-w64 heimdal-dev libpopt-dev xmltoman redis-server xsltproc libical-dev postgresql postgresql-contrib postgresql-server-dev-all gnutls-bin nmap rpm nsis curl wget fakeroot gnupg sshpass socat snmp smbclient libmicrohttpd-dev libxml2-dev python3-polib gettext rsync xml-twig-tools python3-paramiko python3-lxml python3-defusedxml python3-pip python3-psutil python3-impacket virtualenv vim git &&\
apt install -y texlive-latex-extra --no-install-recommends &&\
apt install -y texlive-fonts-recommended &&\
curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - &&\
echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list &&\
apt update &&\
apt -y install yarn &&\
yarn install &&\
yarn upgrade

Crea l'utente GVM

Incolla i seguenti comandi sul terminale per creare l'utente gvm che verrà utilizzato nel processo di installazione e compilazione:

echo 'export PATH="$PATH:/opt/gvm/bin:/opt/gvm/sbin:/opt/gvm/.local/bin"' | tee -a /etc/profile.d/gvm.sh &&\
chmod 0755 /etc/profile.d/gvm.sh &&\
source /etc/profile.d/gvm.sh &&\
bash -c 'cat < /etc/ld.so.conf.d/gvm.conf
# gmv libs location
/opt/gvm/lib
EOF'

mkdir /opt/gvm &&\
adduser gvm --disabled-password --home /opt/gvm/ --no-create-home --gecos '' &&\
usermod -aG redis gvm &&\
chown gvm:gvm /opt/gvm/

Ora accedi come utente gvm. D'ora in poi, le intestazioni del titolo verranno contrassegnate con quale utente è necessario per eseguire i comandi come.

sudo su - gvm

Scarica e installa software (GVM)

Ora crea la cartella src e git clona il codice sorgente GVM:

mkdir src &&\
cd src &&\
export PKG_CONFIG_PATH=/opt/gvm/lib/pkgconfig:$PKG_CONFIG_PATH

git clone -b gvm-libs-20.08 --single-branch  https://github.com/greenbone/gvm-libs.git &&\
git clone -b openvas-20.08 --single-branch https://github.com/greenbone/openvas.git &&\
git clone -b gvmd-20.08 --single-branch https://github.com/greenbone/gvmd.git &&\
git clone -b master --single-branch https://github.com/greenbone/openvas-smb.git &&\
git clone -b gsa-20.08 --single-branch https://github.com/greenbone/gsa.git &&\
git clone -b ospd-openvas-20.08 --single-branch  https://github.com/greenbone/ospd-openvas.git &&\
git clone -b ospd-20.08 --single-branch https://github.com/greenbone/ospd.git

Installa gvm-libs (GVM)

In questo passaggio compileremo le gvm-libs da github:

cd gvm-libs &&\
export PKG_CONFIG_PATH=/opt/gvm/lib/pkgconfig:$PKG_CONFIG_PATH &&\
mkdir build &&\
cd build &&\
cmake -DCMAKE_INSTALL_PREFIX=/opt/gvm .. &&\
make &&\
make doc &&\
make install &&\
cd /opt/gvm/src

Installa openvas-smb (GVM)

Ora entra nella directory openvas-smb e compila il codice sorgente:

cd openvas-smb &&\
export PKG_CONFIG_PATH=/opt/gvm/lib/pkgconfig:$PKG_CONFIG_PATH &&\
mkdir build &&\
cd build/ &&\
cmake -DCMAKE_INSTALL_PREFIX=/opt/gvm .. &&\
make &&\
make install &&\
cd /opt/gvm/src

Installa lo scanner (GVM)

Come nei passaggi precedenti, ora creeremo e installeremo openvas scanner:

cd openvas &&\
export PKG_CONFIG_PATH=/opt/gvm/lib/pkgconfig:$PKG_CONFIG_PATH &&\
mkdir build &&\
cd build/ &&\
cmake -DCMAKE_INSTALL_PREFIX=/opt/gvm .. &&\
make &&\
make doc &&\
make install &&\
cd /opt/gvm/src

Correzione redis per installazione OpenVAS (root)

Ora dobbiamo disconnetterci dalla sessione corrente per tornare all'utente privilegiato digitando 'exit' nel terminale.
Ora incolla il seguente codice sul terminale:

export LC_ALL="C" &&\
ldconfig &&\
cp /etc/redis/redis.conf /etc/redis/redis.orig &&\
cp /opt/gvm/src/openvas/config/redis-openvas.conf /etc/redis/ &&\
chown redis:redis /etc/redis/redis-openvas.conf &&\
echo "db_address = /run/redis-openvas/redis.sock" > /opt/gvm/etc/openvas/openvas.conf &&\
systemctl enable [email protected] &&\
systemctl start [email protected]

sysctl -w net.core.somaxconn=1024 &&\
sysctl vm.overcommit_memory=1 &&\
echo "net.core.somaxconn=1024"  >> /etc/sysctl.conf &&\
echo "vm.overcommit_memory=1" >> /etc/sysctl.conf

cat << /etc/systemd/system/disable-thp.service
[Unit]
Description=Disable Transparent Huge Pages (THP)

[Service]
Type=simple
ExecStart=/bin/sh -c "echo 'never' > /sys/kernel/mm/transparent_hugepage/enabled && echo 'never' > /sys/kernel/mm/transparent_hugepage/defrag"

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload &&\
systemctl start disable-thp &&\
systemctl enable disable-thp &&\
systemctl restart redis-server

Aggiungi il percorso /opt/gvm/sbin alla variabile secure_path:

sed 's/Defaults\s.*secure_path=\"\/usr\/local\/sbin:\/usr\/local\/bin:\/usr\/sbin:\/usr\/bin:\/sbin:\/bin:\/snap\/bin\"/Defaults secure_path=\"\/usr\/local\/sbin:\/usr\/local\/bin:\/usr\/sbin:\/usr\/bin:\/sbin:\/bin:\/snap\/bin:\/opt\/gvm\/sbin\"/g' /etc/sudoers | EDITOR='tee' visudo

Consenti all'utente che esegue ospd-openvas di avviarsi con i permessi di root:

echo "gvm ALL = NOPASSWD: /opt/gvm/sbin/openvas" > /etc/sudoers.d/gvm
echo "gvm ALL = NOPASSWD: /opt/gvm/sbin/gsad" >> /etc/sudoers.d/gvm

Aggiorna NVT (GVM)

Ora eseguiremo greenbone-nvt-sync per aggiornare le definizioni dei file di vulnerabilità.
Per prima cosa torna alla sessione utente GVM:

sudo su – gvm

Ed eseguire quanto segue:

greenbone-nvt-sync

Se si verificano errori di timeout, è molto probabile che sia presente un firewall nel modo. Assicurati di aprire la porta TCP 873. Se ricevi errori di connessione rifiutata, attendi un po' e riprova.

Questo richiede molto tempo, quindi dovrai essere paziente.

Carica plugin in redis con OpenVAS (GVM)

Questa operazione potrebbe richiedere un po' di tempo a seconda dell'hardware e non ti dà alcun feedback quando esegui il comando.

sudo openvas -u

Nota:se ricevi errori di libreria mancanti, digita quanto segue (una riga alla volta):

exit
echo "/opt/gvm/lib > /etc/ld.so.conf.d/gvm.conf 
ldconfig
sudo su - gvm

Gestione installazione (GVM)

Ora entra nella directory gvmd per costruire e installare Greenbone Manager:

cd /opt/gvm/src/gvmd &&\
export PKG_CONFIG_PATH=/opt/gvm/lib/pkgconfig:$PKG_CONFIG_PATH &&\
mkdir build &&\
cd build/ &&\
cmake -DCMAKE_INSTALL_PREFIX=/opt/gvm .. &&\
make &&\
make doc &&\
make install &&\
cd /opt/gvm/src

Configura PostgreSQL (utente Sudoers)

Passa a un utente in sudoers (non usare root o gvm per questo). La sessione utente verrà cambiata con il comando "sudo -u postgres bash" qui sotto.
Esegui una riga alla volta.

exit
cd /
sudo -u postgres bash
export LC_ALL="C"
createuser -DRS gvm
createdb -O gvm gvmd

psql gvmd
create role dba with superuser noinherit;
grant dba to gvm;
create extension "uuid-ossp";
create extension "pgcrypto";
exit
exit

Riparare i certificati (GVM)

Digita una riga alla volta:

sudo su - gvm
gvm-manage-certs -a

Crea utente amministratore (GVM)

Questo creerà un nome utente e una password iniziali. Ricordati di cambiarlo in seguito.

gvmd --create-user=admin --password=admin

Configura e aggiorna feed (GVM)

Affinché i feed si aggiornino completamente, dovremo impostare "Proprietario importazione feed" sull'UUID dell'amministratore. Innanzitutto, trova l'UUID del nuovo utente amministratore

gvmd --get-users --verbose

Dovresti ottenere qualcosa del genere:

admin fb019c52-75ec-4cb6-b176-5a55a9b360bf

Usa la stringa accanto all'amministratore nel comando successivo:

gvmd --modify-setting 78eceaec-3385-11ea-b237-28d24461215b --value (output string from the above command fb019c52-75ec-4cb6-b176-5a55a9b360bf)

Quindi il comando di esempio sarebbe:

$ gvmd --get-users --verbose
admin fb019c52-75ec-4cb6-b176-5a55a9b360bf
$ gvmd --modify-setting 78eceaec-3385-11ea-b237-28d24461215b --value fb019c52-75ec-4cb6-b176-5a55a9b360bf

Esegui i tre comandi successivi una riga alla volta. Se ricevi errori di connessione rifiutata, prova di nuovo il comando finché non riesce. Anche questi comandi richiederanno del tempo.

greenbone-feed-sync --type GVMD_DATA
greenbone-feed-sync --type SCAP
greenbone-feed-sync --type CERT

Installa gsa (GVM)

Sempre come nei passaggi precedenti, entra nella cartella gsa e compila il codice sorgente gsa:

cd /opt/gvm/src/gsa &&\
export PKG_CONFIG_PATH=/opt/gvm/lib/pkgconfig:$PKG_CONFIG_PATH &&\
mkdir build &&\
cd build/ &&\
cmake -DCMAKE_INSTALL_PREFIX=/opt/gvm .. &&\
make &&\
make doc &&\
make install &&\
touch /opt/gvm/var/log/gvm/gsad.log &&\
cd /opt/gvm/src

Configura OSPD-OpenVAS

Installa virtualenv (GVM)

Nota:potrebbe essere necessario modificare –python python3.8 in modo che corrisponda alla versione python installata.

cd /opt/gvm/src &&\
export PKG_CONFIG_PATH=/opt/gvm/lib/pkgconfig:$PKG_CONFIG_PATH &&\
virtualenv --python python3.8  /opt/gvm/bin/ospd-scanner/ &&\
source /opt/gvm/bin/ospd-scanner/bin/activate

Installa ospd (GVM)

Installeremo ospd usando il programma di installazione pip:

mkdir /opt/gvm/var/run/ospd/ &&\
cd ospd &&\
pip3 install . &&\
cd /opt/gvm/src

Installa ospd-openvas (GVM)

Anche in questo caso per ospd-openvas utilizzeremo il programma di installazione pip con il pacchetto clonato da github:

cd ospd-openvas &&\
pip3 install . &&\
cd /opt/gvm/src

Crea script di avvio (root)

Per prima cosa digita exit per uscire dalla sessione di root, quindi incolla quanto segue nel terminale:

cat << EOF > /etc/systemd/system/gvmd.service
[Unit]
Description=Open Vulnerability Assessment System Manager Daemon
Documentation=man:gvmd(8) https://www.greenbone.net
Wants=postgresql.service ospd-openvas.service
After=postgresql.service ospd-openvas.service

[Service]
Type=forking
User=gvm
Group=gvm
PIDFile=/opt/gvm/var/run/gvmd.pid
WorkingDirectory=/opt/gvm
ExecStart=/opt/gvm/sbin/gvmd --osp-vt-update=/opt/gvm/var/run/ospd.sock
ExecReload=/bin/kill -HUP $MAINPID
KillMode=mixed
Restart=on-failure
RestartSec=2min
KillMode=process
KillSignal=SIGINT
GuessMainPID=no
PrivateTmp=true

[Install]
WantedBy=multi-user.target
EOF

cat << EOF > /etc/systemd/system/gsad.service
[Unit]
Description=Greenbone Security Assistant (gsad)
Documentation=man:gsad(8) https://www.greenbone.net
After=network.target
Wants=gvmd.service


[Service]
Type=forking
PIDFile=/opt/gvm/var/run/gsad.pid
WorkingDirectory=/opt/gvm
ExecStart=/opt/gvm/sbin/gsad --drop-privileges=gvm
Restart=on-failure
RestartSec=2min
KillMode=process
KillSignal=SIGINT
GuessMainPID=no
PrivateTmp=true

[Install]
WantedBy=multi-user.target
EOF

cat << EOF > /etc/systemd/system/ospd-openvas.service 
[Unit]
Description=Job that runs the ospd-openvas daemon
Documentation=man:gvm
After=network.target [email protected]
[email protected]

[Service]
Environment=PATH=/opt/gvm/bin/ospd-scanner/bin:/opt/gvm/bin:/opt/gvm/sbin:/opt/gvm/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
Type=forking
User=gvm
Group=gvm
WorkingDirectory=/opt/gvm
PIDFile=/opt/gvm/var/run/ospd-openvas.pid
ExecStart=/opt/gvm/bin/ospd-scanner/bin/python /opt/gvm/bin/ospd-scanner/bin/ospd-openvas --pid-file /opt/gvm/var/run/ospd-openvas.pid --unix-socket=/opt/gvm/var/run/ospd.sock --log-file /opt/gvm/var/log/gvm/ospd-scanner.log --lock-file-dir /opt/gvm/var/run/ospd/
Restart=on-failure
RestartSec=2min
KillMode=process
KillSignal=SIGINT
GuessMainPID=no
PrivateTmp=true

[Install]
WantedBy=multi-user.target
EOF

Abilita e avvia i servizi (root)

Ora abiliteremo e avvieremo i servizi GVM, anche come utente root:

systemctl daemon-reload &&\
systemctl enable gvmd &&\
systemctl enable gsad &&\
systemctl enable ospd-openvas &&\
systemctl start gvmd &&\
systemctl start gsad &&\
systemctl start ospd-openvas

Controlla i servizi (root)

Assicurati che tutti e tre i servizi siano in esecuzione (digita una riga alla volta).

systemctl status gvmd
systemctl status gsad
systemctl status ospd-openvas

Modifica scanner predefinito (GVM)

Torna alla tua sessione GVM.

sudo su - gvm

Innanzitutto, ottieni l'UUID dello scanner che ha il socket (ospd.sock)

gvmd --get-scanners

Quindi modifica lo scanner:

gvmd --modify-scanner=(INSERT SCANNER UUID HERE) --scanner-host=/opt/gvm/var/run/ospd.sock

Esempio:

gvmd --get-scanners
08b69003-5fc2-4037-a479-93b440211c73  OpenVAS  /var/run/ospd/ospd.sock  0  OpenVAS Default
6acd0832-df90-11e4-b9d5-28d24461215b  CVE    0  CVE

gvmd --modify-scanner=08b69003-5fc2-4037-a479-93b440211c73 --scanner-host=/opt/gvm/var/run/ospd.sock
Scanner modified.

Questo è tutto. Ora puoi accedere all'interfaccia web di GVM.

Conclusione

Abbiamo completato con successo l'installazione di GVM su Ubuntu 20.04. Ora puoi accedere utilizzando l'indirizzo IP del tuo server. L'accesso predefinito è admin/admin come impostato sopra. Facci sapere cosa ne pensi del tutorial nei commenti qui sotto.