Ricerca nel sito web

Come installare e utilizzare Vuls Vulnerability Scanner su Ubuntu 24.04


In questa pagina

  1. Prerequisiti
  2. Installazione delle dipendenze
  3. Installazione dei dizionari Vuls e Vuls
  4. Download dei database CVE (Common Vulnerabilities and Exposure).
  5. Scansione del computer locale con Vuls
  6. Scansione del server remoto con Vuls
  7. Conclusione

Vuls è uno scanner di vulnerabilità senza agente, gratuito e open source che può essere eseguito ovunque. Puoi eseguire Vuls su cloud, on-premise e Docker e supporta le principali distribuzioni. Vuls supporta più database di vulnerabilità come NVD, JVN, OVAL, RHSA/ALAS/ELSA/FreeBSD-SA.

Con Vuls puoi scansionare più sistemi operativi utilizzando più metodi. Puoi scansionare le localizzazioni del tuo host e puoi scansionare host/server remoti tramite SSH. Fornisce inoltre più metodi di scansione, una scansione veloce che non richiede privilegi di root e una scansione approfondita che richiede privilegi di root. I VUL possono scansionare più server di destinazione contemporaneamente. Al termine della scansione, puoi inviare il risultato tramite e-mail e Slack.

In questa guida ti mostreremo come installare Vuls Vulnerability Scanner sul server Ubuntu 24.04. Installerai Vuls, genererai database CVE e scansionerai Ubuntu/Debian tramite scansioni locali e remote.

Prerequisiti

Per iniziare con questa guida, assicurati di avere quanto segue:

  • Un server Ubuntu 24.04
  • Un utente non root con privilegi root
  • Macchina Ubuntu/Debian aggiuntiva per la scansione remota tramite Vuls

Installazione delle dipendenze

Prima di installare Vuls, devi assicurarti che Golang sia installato sul tuo sistema. Per ora, l'ultima versione di Vuls richiede l'ultimo Golang, quindi è necessario installare Golang manualmente scaricando il pacchetto binario.

Innanzitutto, esegui il comando seguente per aggiornare l'indice del tuo pacchetto Ubuntu e installare dipendenze come 'sqlite3', 'git', 'make', e 'gcc'.

sudo apt update
sudo apt install sqlite3 git debian-goodies gcc make wget -y

Dopo aver installato le dipendenze, devi installare Golang sul tuo sistema. In questo esempio, avrai l'ultima versione di Golang tramite l'installazione manuale del binario.

Seleziona la tua versione Golang con quanto segue. Quindi ad esempio Golang 1.23.2:

export latest_version=1.23.2

Esegui il comando 'wget' qui sotto per scaricare Golang ed estrailo nella directory '/usr/local' con il comando 'tar'.

wget https://dl.google.com/go/go$latest_version.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go$latest_version.linux-amd64.tar.gz

Una volta installato Golang, accedi al tuo utente e crea una nuova directory "go" all'interno della directory home.

su - arvd
mkdir $HOME/go

Successivamente, crea un nuovo file env '/etc/profile.d/go-env.sh' con l'editor 'nano'.

sudo nano /etc/profile.d/go-env.sh

Incolla la seguente configurazione per impostare PATH per Golang.

export GOROOT=/usr/local/go
export GOPATH=$HOME/go
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

Salvare e uscire dal file una volta terminato.

Ora rendi eseguibile '/etc/profile.d/go-env.sh' e caricalo nella sessione corrente con il comando 'source'.

sudo chmod +x /etc/profile.d/go-env.sh
source /etc/profile.d/go-env.sh

Infine, controlla il file binario per 'go' e controlla la sua versione con quanto segue:

which go
go version

Come puoi vedere di seguito, Golang '1.23.2' è installato in '/usr/local/go/bin/go'.

Installazione dei dizionari Vuls e Vuls

Dopo l'installazione di Golang, compilerai e installerai Vuls e i suoi componenti per creare database CVE in formato sqlite3. Di seguito sono riportati alcuni componenti Vuls che installerai:

  • 'go-cve-dictionary' viene utilizzato per creare il NVD (National Vulnerabilities Database)
  • 'goval-dictionary' per creare il database OVAL che contiene CVE per la maggior parte delle distribuzioni Linux come Debian, Ubuntu e RedHat
  • "go-exploitdb" per la ricerca di exploit dai database exploitdb
  • 'go-msfdb' per la ricerca di CVE all'interno dei database Metasploit
  • 'go-kev' per creare una copia locale di KEV (Known Exploited Vulnerabilities) fornita da CISA
  • "go-cti" che verrà utilizzato per creare il database CVE da CTI (Cyber Threat Intelligence)

Innanzitutto, esegui il comando seguente per creare nuove directory di registro e modificare la proprietà del tuo utente, ad esempio "arvd".

sudo mkdir /var/log/{vuls,go-exploitdb,go-msfdb,go-kev,go-cti}
sudo chown arvd /var/log/{vuls,go-exploitdb,go-msfdb,go-kev,go-cti}
sudo chmod 700 /var/log/{vuls,go-exploitdb,go-msfdb,go-kev,go-cti}

Crea una nuova directory '$GOPATH/src/github.com/vulsio' con quanto segue:

mkdir -p $GOPATH/src/github.com/vulsio

Passa alla directory '$GOPATH/src/github.com/vulsio', scarica il codice sorgente dello strumento 'go-cve-dictionary' tramite 'git', quindi compilalo e installalo.

cd $GOPATH/src/github.com/vulsio
git clone https://github.com/vulsio/go-cve-dictionary.git
cd go-cve-dictionary; make install

Ora esegui il comando seguente per scaricare, compilare e installare lo strumento "dizionario goval".

cd $GOPATH/src/github.com/vulsio
git clone https://github.com/vulsio/goval-dictionary.git
cd goval-dictionary; make install

Dopo aver installato "goval-dictionary", passa allo strumento successivo per installare lo strumento "go-exploitdb".

cd $GOPATH/src/github.com/vulsio
git clone https://github.com/vulsio/go-exploitdb.git
cd go-exploitdb; make install
ln -s $GOPATH/src/github.com/vulsio/go-exploitdb/go-exploitdb.sqlite3 $HOME/go-exploitdb.sqlite3

Successivamente, esegui il comando seguente per installare e compilare lo strumento "go-msfdb".

cd $GOPATH/src/github.com/vulsio
git clone https://github.com/vulsio/go-msfdb.git
cd go-msfdb; make install

Successivamente, installa lo strumento 'go-kev' per creare database CVE per KEV (Known Exploited Vulnerabilities) di CIS by CISA.

cd $GOPATH/src/github.com/vulsio
git clone https://github.com/vulsio/go-kev.git
cd go-kev; make install
ln -s $GOPATH/src/github.com/vulsio/go-kev/go-kev.sqlite3 $HOME/go-kev.sqlite3

Quindi installa lo strumento "go-cti" che verrà utilizzato per creare CVE da CTI (Cyber Threat Intelligence).

cd $GOPATH/src/github.com/vulsio
git clone https://github.com/vulsio/go-cti.git
cd go-cti; make install
ln -s $GOPATH/src/github.com/vulsio/go-cti/go-cti.sqlite3 $HOME/go-cti.sqlite3

Successivamente, esegui il comando seguente per scaricare, compilare e installare "vuls" sul tuo computer Ubuntu.

mkdir -p $GOPATH/src/github.com/future-architect
cd $GOPATH/src/github.com/future-architect
git clone https://github.com/future-architect/vuls.git
cd vuls; make install

Una volta installato tutto, il file binario per ciascuno strumento sarà disponibile nella directory '$GOPATH/bin'. Esegui il comando seguente per controllare quella directory.

ls $GOPATH/bin/

Di seguito puoi vedere il file binario per 'vuls', 'go-cve-dictionary', 'goval-dictionary', ' go-exploitdb', 'go-msfdb', 'go-kev' e 'go-cti'.

Infine, puoi anche controllare il comando 'vuls' qui sotto. Questo ti mostrerà il messaggio di aiuto per 'vuls'.

vuls help

Download dei database CVE (Common Vulnerabilities and Exposure).

In questo esempio, scaricherai i database CVE per:

  • NVD (database nazionale delle vulnerabilità) tramite 'go-cve-dictionary'
  • OVAL (Open Vulnerability and Assessment Language) per Ubuntu 24.04 tramite 'dizionario goval'
  • Database ExploitDB tramite 'go-exploitdb'
  • Database Metasploit tramite 'go-msfdb'
  • Catalogo KEV (Known Exploited Vulnerabilities) di CISA tramite 'go-kev'
  • Database MITRE ATT&CK e CAPEC tramite 'go-cti'

Vai alla tua home directory con quanto segue:

cd $HOME

Ora esegui il comando seguente per scaricare e creare database CVE (Common Vulnerabilities and Exposures).

go-cve-dictionary fetch nvd
goval-dictionary fetch ubuntu 24.04
go-exploitdb fetch exploitdb
go-msfdb fetch msfdb
go-kev fetch kevuln
go-cti fetch threat

Una volta completato il processo, i tuoi database CVE saranno disponibili nella tua directory home con il formato ".sqlite3". Verificare l'elenco dei database con quanto segue:

ls -ah *.sqlite3

Scansione del computer locale con Vuls

Ora che hai installato Vuls e i suoi componenti inclusi i database CVE. In questa sezione eseguirai la scansione della tua macchina Ubuntu locale con Vuls.

All'interno della tua directory home, crea un nuovo file 'config.toml' con l'editor 'nano'.

nano config.toml

Inserisci la configurazione qui sotto per impostare la scansione per localhost con la modalità 'veloce.

[servers]
[servers.localhost]
host = "localhost"
port = "local"
scanMode = [ "fast" ]
#scanMode = ["fast", "fast-root", "deep", "offline"]

Salvare il file ed uscire dall'editor.

Ora esegui il comando "vuls" di seguito per verificare il file "config.toml".

vuls configtest

Se la configurazione è corretta, vedrai un output come il seguente:

Successivamente, esegui la scansione dell'host locale con il comando 'vuls scan' riportato di seguito.

sudo vuls scan

Di seguito puoi vedere che il processo di scansione è completo.

Per ottenere i dettagli del rapporto di scansione, utilizza il comando "vuls tui" di seguito. Questo ti mostrerà l'interfaccia utente del terminale del report Vuls.

sudo vuls tui

Puoi premere "CTRL+c" per uscire dall'interfaccia utente di Vuls.

Scansione del server remoto con Vuls

In questa sezione imparerai come impostare una scansione remota con Vuls. Quindi eseguirai la scansione del sistema remoto tramite SSH con Vuls. In questo esempio, eseguirai la scansione del server di destinazione Debian 12 con l'indirizzo IP "192.168.10.10" e l'utente è "alice" .

Innanzitutto, esegui il comando seguente per scaricare il database OVAL per Debian 12.

goval-dictionary fetch debian 12

Ora genera chiavi pubbliche e private SSH, quindi caricale sul server di destinazione con il comando 'ssh-copy-id'.

ssh-keygen -t ed25519
ssh-copy-id [email 

Connettersi al server di destinazione '192.168.10.10', quindi aggiornare l'indice del pacchetto e installare le dipendenze come 'debian-goodies' e 'reboot-notifier'.

ssh [email 
sudo apt update && sudo apt install debian-goodies reboot-notifier -y

Digita "esci" per disconnetterti dal server di destinazione.

Successivamente, apri la configurazione di Vuls 'config.toml' utilizzando l'editor 'nano'.

nano ~/config.toml

Inserisci la configurazione seguente per aggiungere i dettagli del server di destinazione. In questo caso, il nuovo server di destinazione verrà denominato "debian12" con l'indirizzo IP "192.168.10.10" e l'autenticazione tramite chiave SSH.

[servers.debian12]
host = "192.168.10.10"
port = "22"
user = "alice"
keyPath = "~/.ssh/id_ed25519"
scanMode = [ "fast-root" ] # "fast", "fast-root" or "deep"

Salvare il file ed uscire dall'editor.

Ora esegui il comando 'vuls' di seguito per verificare la tua configurazione. Assicurati di avere la configurazione corretta e corretta.

vuls configtest

Successivamente, scansiona il server remoto 'debian12' con il comando seguente.

vuls scan debian12

Puoi vedere qui sotto che la scansione remota tramite Vuls è stata completata.

Conclusione

Congratulazioni! Hai completato l'installazione di Vuls Vulnerability Scanner sul server Ubuntu 24.04. Hai anche imparato come generare database CVE con Vuls, scansionando server locali e remoti con Vuls. Da qui, ora puoi integrare Vuls con un altro scanner come NMAP per la scansione delle porte, oppure puoi anche installare Vulsrepo per l'interfaccia grafica e basata sul web.

Articoli correlati: