vulnerscom/nmap-vulnersScript NSE di Nmap che interroga l'API di Vulners per identificare vulnerabilità note (CVE) per i servizi di rete rilevati, migliorando la scansione delle porte standard con ricerca automatica di CVE e punteggio CVSS.
<div align="center">
# nmap-vulners
**Trasforma una scansione dei servizi di nmap in una lista classificata di CVE, exploit e di ciò che viene attaccato in natura.**
Uno script NSE che prende il software già identificato da nmap, interroga il database di [Vulners](https://vulners.com) per sapere cosa è noto al riguardo e stampa la risposta all'interno del report di scansione - dal peggiore al migliore, in base a ciò che è realmente sfruttabile.
[](https://github.com/vulnersCom/nmap-vulners/actions)
[](LICENSE)
[](https://nmap.org)
[](https://vulners.com)
[](https://github.com/vulnersCom/nmap-vulners/stargazers)
<img src="https://assets.kitploit.com/production/public/readmes/1680/0a17fe209e2ad4d8bbd8bf49c72243a8c8b3f0fb9e603317b21c8a2cd6982b0f.gif" alt="Tre scansioni: una porta SSH senza chiave API, la stessa porta con una chiave, e una porta web dove la scansione identifica il Tomcat dietro un banner Coyote" width="900">
<sub>Scansioni reali di host pubblicati per essere scansionati. Nessuna chiave, poi una chiave, poi una porta web: l'opzione <code>-sV</code> di nmap riporta un banner Coyote e la scansione identifica il Tomcat e la jQuery dietro di esso.</sub>
</div>
---
## Cosa fa
Per ogni porta aperta cerca il software identificato da nmap - i CPE prodotti da `-sV` - e stampa ciò che Vulners sa al riguardo: dal peggiore al migliore in base a ciò che viene sfruttato piuttosto che solo al punteggio, e ogni riga è un collegamento alla pagina corrispondente.
Su una porta HTTP esegue anche il fingerprinting dello stack web stesso, che identifica software che `-sV` non può vedere - un framework applicativo, un CMS, la versione di PHP dietro un reverse proxy. 721 regole leggono le parti di una risposta che contengono una versione: l'header `Server`, `X-Powered-By`, i cookie, il titolo della pagina, i tag `<meta>`, i nomi dei file `<script src>` e il corpo. Anche quelle identità vengono cercate e pubblicate sulla porta così che il resto della scansione possa usarle.
Due cose che fa oltre alla scansione:
* **legge il banner di servizio di nmap stesso.** Quando `-sV` non riesce a identificare un servizio, il banner grezzo viene confrontato con regole per FTP, SMTP, SSH, MySQL, DNS, NTP, LDAP e altro. Questo non costa alcuna richiesta extra, ed è il caso in cui una porta altrimenti non riporterebbe nulla.
* **interroga un prodotto che non vuole rivelarsi.** Un CMS che dichiara il proprio nome ma nasconde la versione è comune, e nessuna quantità di pattern matching può estrarre un numero che non è sulla pagina. Quando il prodotto viene riconosciuto ma la versione no, una richiesta va al posto che risponde - `/CHANGELOG.txt` per Drupal, `/administrator/manifests/files/joomla.xml` per Joomla. A un host che non esegue nessuno dei sei prodotti sondati non viene inviato nulla di extra.```sh
nmap -sV --script vulners <target>
```
Questa è l'intera interfaccia. Funziona senza una chiave API; con una ti fornisce
più informazioni. Non c'è alcun cambio di modalità.```
PORT STATE SERVICE VERSION
80/tcp open http Apache httpd 2.4.7 ((Ubuntu))
| vulners: cpe:/a:apache:http_server:2.4.7 272 findings, 56 exploitable
| SEVERITY CVSS AI FLAGS LINK
| ======== ==== ==== ======= ==============================================================
| CRITICAL 10.0 8.8 EXP https://vulners.com/gitee/3E6BA608-776F-5B1F-9BA5-589CD2A5A351
| CRITICAL 9.8 9.9 EXP https://vulners.com/zdt/1337DAY-ID-39214
| CRITICAL 9.8 9.6 EXP https://vulners.com/packetstorm/PACKETSTORM:171631
| CRITICAL 9.8 9.9 https://vulners.com/cve/CVE-2021-44790
| CRITICAL 9.8 9.8 https://vulners.com/cve/CVE-2023-25690
|_ 262 more not shown; -v shows all, -vv adds where each was found
```
Con una chiave, la stessa scansione dello stesso host risponde in modo diverso: `KEV` indica che CISA ha registrato la vulnerabilità come sfruttata in natura, mentre `EPSS` è la probabilità pubblicata che venga sfruttata:```
| vulners: cpe:/a:apache:http_server:2.4.7 272 findings, 78 exploitable
| SEVERITY CVSS EPSS FLAGS LINK
| ======== ==== ==== ======= ==============================================================
| CRITICAL 9.1 >99% KEV EXP https://vulners.com/cve/CVE-2024-38475
| CRITICAL 9.0 >99% KEV EXP https://vulners.com/cve/CVE-2021-40438
| CRITICAL 9.1 >99% KEV https://vulners.com/cnvd/CNVD-2024-36387
| CRITICAL 10.0 71% EXP https://vulners.com/gitee/3E6BA608-776F-5B1F-9BA5-589CD2A5A351
| CRITICAL 9.8 97% EXP https://vulners.com/cve/CVE-2021-44790
|_ 262 more not shown; -v shows all, -vv adds where each was found
```
Stessi 272 risultati, un ordine diverso, una prima riga diversa - e 22 in più
noti come sfruttabili, perché una chiave collega ogni exploit alle CVE che
sfrutta. Entrambe sono risposte reali di vulners.com, catturate contro un
server locale che presenta quel banner.
## Classifica
I fatti superano le previsioni. I risultati sono ordinati:
1. **CISA KEV** - registrato come sfruttato in natura
2. **SSVC `active`** - il giudizio di un coordinatore che lo sfruttamento è in corso
3. **esiste un exploit** - il codice è pubblicato, per questo o per una CVE che nomina
4. **EPSS alto** - un modello prevede lo sfruttamento
5. tutto il resto
Il CVSS rompe i pareggi all'interno di una fascia, non tra le fasce: un 7.5 sfruttato è un problema
peggiore di un 9.8 non sfruttato, e questo è l'ordine che lo dice.
Le colonne seguono i dati. Un segnale che la risposta non conteneva perde la sua colonna
piuttosto che mostrare una cella vuota, perché un EPSS vuoto si legge come "tranquillo", e
questa è un'affermazione che un campo assente non può sostenere.
## Cosa aggiunge una chiave API
| | |
|---|---|
| **Senza chiave** | Ogni CPE trovato da nmap viene cercato sull'endpoint gratuito. Risultati, punteggi, flag di exploit e il punteggio AI di Vulners. Nessun credito, nessun account |
| **Una chiave, nessun credito** | Ogni risultato ottiene ciò che l'endpoint id conosce: titoli, date, la pagina dell'advisory o dell'exploit a monte, il collegamento exploit-CVE, CISA KEV e - a seconda della licenza - EPSS e SSVC |
| **Una chiave, un credito** | Il software che il percorso gratuito non poteva nominare affatto viene identificato dal suo banner grezzo. Questa è l'unica cosa qui che costa qualcosa, e solo per un servizio senza CPE |
Una porta che ha già un CPE non costa mai un credito: misurato su quattro
prodotti, la ricerca gratuita restituisce le **stesse CVE** di quella a pagamento per un CPE.
Ciò che un credito compra è l'identificazione, non più vulnerabilità.
Le chiavi gratuite sono su [vulners.com/userinfo](https://vulners.com/userinfo).
## Installazione
**macOS, Linux, Kali, WSL** - una riga, nessun argomento:```sh
curl -fsSL https://raw.githubusercontent.com/vulnersCom/nmap-vulners/master/install.sh | sh
```
**Windows** - PowerShell come Amministratore:```powershell
irm https://raw.githubusercontent.com/vulnersCom/nmap-vulners/master/install.ps1 | iex
```
L'installatore chiede a nmap dove conserva i propri dati, copia lì gli script e i loro file di dati, ricostruisce il database degli script e poi verifica che `--script vulners` risolva davvero a ciò che ha appena installato: nmap include una propria `vulners.nse`, e questa la sostituisce.
<details>
<summary><b>Senza root e altre opzioni</b></summary>```sh
# into ~/.nmap, no sudo; the installer prints the NMAPDIR line to add to your profile
curl -fsSL https://raw.githubusercontent.com/vulnersCom/nmap-vulners/master/install.sh | sh -s -- --user
# a specific directory
./install.sh --prefix /usr/local/share/nmap
# a specific release
./install.sh --ref v2.0
# remove everything it installed
./install.sh --uninstall
```
PowerShell accetta le stesse opzioni: `-User`, `-Prefix`, `-Ref`, `-Uninstall`.
</details>
<details>
<summary><b>Da un checkout</b></summary>```sh
git clone https://github.com/vulnersCom/nmap-vulners
cd nmap-vulners
./install.sh
```
L'installer utilizza i file che si trovano accanto ad esso, quindi installa esattamente ciò che hai
clonato. Eseguire gli script direttamente dalla checkout funziona anche:```sh
nmap -sV --script "$PWD/vulners.nse" <target>
```
> Quando si esegue da un checkout, usare un percorso **assoluto**. nmap risolve
> un `--script ./vulners.nse` relativo prima contro il proprio `script.db`, e
> esegue silenziosamente la copia inclusa in nmap invece della vostra.
</details>
<details>
<summary><b>A mano</b></summary>
Un solo file: copiare `vulners.nse` in `<nmap data dir>/scripts/` ed eseguire
`sudo nmap --script-updatedb`. Non c'è altro da posizionare - lo script
scarica i propri dizionari al momento della scansione e non scrive nulla su
disco - e quindi nulla da dimenticare, cosa che in passato produceva uno
script che veniva eseguito, non trovava nulla e non diceva nulla sul perché.
Se si sta effettuando un aggiornamento dalla versione 1.x, eliminare anche
`vulners_enterprise.nse` e `http-vulners-regex.nse` da quella directory. Un
`http-vulners-regex.nse` residuo mantiene ancora la categoria `default` e
continua a scansionare i target con un semplice `-sC`. L'installer lo fa per
voi.
La directory dati di nmap è di solito `/usr/share/nmap` (Debian, Ubuntu, Kali),
`/usr/local/share/nmap` (compilato dai sorgenti), `/opt/homebrew/share/nmap`
(Homebrew) o `C:\Program Files (x86)\Nmap` (Windows). Per esserne certi,
chiedete a nmap:```sh
nmap -d2 --script-help probe 2>&1 | grep nse_main.lua
```
La directory che contiene `nse_main.lua` è quella che usa questo nmap.
</details>
## Argomenti dello script
| Argomento | Predefinito | Significato |
|---|---|---|
| `vulners.mincvss` | `0` | Nasconde i risultati al di sotto di questa soglia. I bollettini senza punteggio e tutto ciò che ha un exploit noto vengono mostrati a prescindere dalla soglia |
| `vulners.paths` | i 939 percorsi pubblicati | Percorsi per la scansione web: una lista Lua, una stringa che indica un file con un percorso per riga, oppure `none` per disattivare la scansione. Un file da te indicato che non può essere letto interrompe la scansione e lo segnala, invece di ripiegare sull'elenco pubblicato |
| `vulners.width` | `80` | Larghezza del terminale per cui è impostata la tabella |
| `vulners.max_items` | `32` | Tetto massimo di elementi addebitati per l'intera scansione |
| `vulners.api_key` | - | Token API. Dispersivo: nmap copia la propria riga di comando in `-oX` |
| `vulners.api_key_file` | - | Percorso assoluto di un file la cui prima riga è il token |
| `vulners.api_host` | `vulners.com` | Nome host dell'API |
| `vulners.api_port` | `443` | Porta su `api_host` |
Funziona anche un semplice nome, quindi `--script-args mincvss=7` è sufficiente.
I prefissi degli argomenti della versione 1.x - `vulners_enterprise.*` e
`http-vulners-regex.paths` - sono accettati per una release e stampano un
avviso di deprecazione.
## Dove conservare la chiave API
In ordine di preferenza:
1. `~/.nmap/vulners.key`, una riga, modalità 600 - l'installer offre di scriverla
2. `VULNERS_API_KEY` nell'ambiente
3. `--script-args vulners.api_key_file=/percorso/assoluto`
4. `--script-args vulners.api_key=<token>`
L'ultima è comoda e dispersiva: nmap copia la propria riga di comando in ogni
report, quindi il token finisce nell'attributo `args` dell'output `-oX` e nella
cronologia della tua shell. Lo script stesso non scrive mai il token da nessuna
parte, incluso il suo output di debug - esiste un test di regressione che lo
dichiara.
Un file chiave indicato esplicitamente che non può essere letto interrompe
l'esecuzione invece di ripiegare silenziosamente - un operatore che indica un
file intende quel file - e il report indica quale file era. Un percorso
digitato male non può sembrare una scansione pulita.
## Da dove provengono le impronte digitali
Lo script non le contiene. Scarica tre dizionari una volta per scansione,
prima che venga toccato il primo host:```
https://raw.githubusercontent.com/vulnersCom/nmap-vulners/catalog/
index.json what exists, at which serial
fingerprints.json 721 product and version rules
paths.json 939 paths the sweep requests
probes.json targeted version probes
```
Quattro richieste per scansione - una per file, non per host e non per porta -
per 40 KB compressi su 250 KB di JSON, nella fase pre-scan di nmap. Misurato
rispetto al ramo pubblicato. Uno script installato quindi acquisisce nuove
impronte digitali senza essere aggiornato.
**Non scrive nulla sul tuo filesystem.** I dizionari vengono mantenuti per la
durata della scansione e poi rilasciati, che è come si comporta ogni script
fornito con nmap: dei 611, 26 aprono un file per la scrittura e ognuno scrive
solo dove un argomento dello script glielo ha indicato. Nessuno mantiene una
cache, e nemmeno questo.
**Se non possono essere scaricati, la scansione viene comunque eseguita.** I
dizionari alimentano il web fingerprinting e nient'altro, quindi una macchina
senza rotta verso GitHub perde quella funzionalità e conserva tutto il resto: il
software identificato da nmap stesso viene comunque cercato, e il report indica
quale capacità mancava invece di lasciarti leggere un risultato vuoto come una
rete pulita.
| argomento | cosa fa |
|---|---|
| `vulners.catalog_url=<url>` | recupera da un mirror invece - per una rete air-gapped. Un nome host o un indirizzo IPv6 tra parentesi quadre, `http://[fd00::1]/catalog/` |
| `vulners.catalog=none` | non recuperare affatto; cerca solo ciò che nmap ha nominato |
## La scansione a tappeto, e quanto è rumorosa
Su una porta HTTP lo script richiede ogni percorso pubblicato dal catalogo - 939
percorsi - e confronta tutte le 721 regole con ogni risposta. I percorsi
provengono da WhatWeb, nuclei e FingerprintHub: luoghi in cui un prodotto viene
riconosciuto, piuttosto che ipotesi. Anche un percorso appartenente a software
che non stai eseguendo vale la richiesta, perché la risposta contiene comunque
`Server`, `X-Powered-By`, un cookie e un titolo, ed è lì che le regole trovano
lo stack che lo precede.
**La velocità dipende dal tuo `-T`**, non da un'impostazione nostra. La lista
non si riduce mai; il ritmo sì:
| | batch | attesa tra loro | misurato, una porta web |
|---|---|---|---|
| `-T0` paranoid | 188 x 5 | 2 s | 11 m 22 s |
| `-T1` sneaky | 94 x 10 | 1 s | 1 m 56 s |
| `-T2` polite | 38 x 25 | 0.5 s | 26.2 s |
| `-T3` normal | 10 x 100 | 0.1 s | 7.6 s |
| `-T4` aggressive | 4 x 250 | nessuna | 6.7 s |
| `-T5` insane | 1 | nessuna | 6.6 s |
Tutte e sei misurate in una singola esecuzione contro lo stesso server locale.
Solo `-sV` contro di esso richiede 6.1 s, quindi la scansione a tappeto costa un
secondo e mezzo con le impostazioni predefinite. Le due righe lente sono `-T0` e
`-T1` che fanno il loro lavoro: 188 e 94 batch, con un'attesa deliberata tra
ciascuno.
Le richieste vengono pipeline su 34-48 connessioni con al massimo quattro aperte
alla volta, che è `pipeline_go` di nselib - lo stesso meccanismo usato da
`http-enum` di nmap, che rispetta `Keep-Alive: max=` del server e
`--script-args http.max-pipeline=N`.
`--script-args vulners.paths=none` disattiva completamente la scansione a
tappeto.
## Come funziona```
nmap -sV
|
+-- service fingerprint --> port.version.cpe --------------+
| |
+-- vulners.nse |
reads nmap's banner for services -sV could not name |
on an HTTP port: requests the path list in one |
pipeline, matches 721 rules against the header, the |
title, the meta tags, the scripts and the body |
probes for a version when a product hid it |
publishes everything it recognised ------------------+
|
v
GET /api/v3/burp/software/ per identity
free, no key, CDN-cached
|
POST /api/v3/search/id/ per 100 findings
free, needs a key: enrichment
|
POST /api/v4/audit/smart only for a
service with no CPE: 1 credit
|
ranked, filtered, printed
```
Le risposte vengono memorizzate nella cache per l'intera scansione, con chiave per identità, quindi cento
server identici costano una sola ricerca. L'arricchimento viene memorizzato nella cache per id di rilevamento, quindi due
porte web che eseguono software sovrapposti recuperano ogni documento una sola volta.
## Output leggibile dalla macchina
Tutto ciò che viene stampato è anche strutturato, quindi `-oX` può essere analizzato senza toccare
il testo leggibile dall'uomo. L'id dello script, i due livelli di tabella e le cinque chiavi
originali degli elementi sono invariati rispetto alla 1.x, che è ciò che DefectDojo, Faraday,
nmap2csv e raven leggono:```xml
<script id="vulners">
<elem key="schema">2.0</elem>
<elem key="mode">keyed</elem>
<table key="cpe:/a:apache:http_server:2.4.7">
<table>
<elem key="id">CVE-2021-40438</elem>
<elem key="type">cve</elem>
<elem key="severity">CRITICAL</elem>
<elem key="cvss">9.0</elem>
<elem key="cvss_type">cvss3.1</elem>
<elem key="is_exploit">false</elem>
<elem key="exploit_known">true</elem>
<elem key="kev">true</elem>
<elem key="epss">0.99612</elem>
<elem key="exploitation">active</elem>
<elem key="title">Apache HTTP Server SSRF in mod_proxy</elem>
<elem key="href">https://vulners.com/cve/CVE-2021-40438</elem>
<elem key="source_href">https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2021-40438</elem>
</table>
</table>
</script>
```
Novità nella 2.0: `schema`, `mode`, `severity`, `exploit_known`, `kev`, `epss`,
`epss_percentile`, `exploitation`, `ai_score`, `title`, `published`, `href`,
`source_href` e `found_on`. Ognuno è presente o assente, mai vuoto.
Nulla è annidato più in profondità di prima, perché un terzo livello di tabella è
invisibile a ogni importatore esaminato.
`href` è sempre la pagina vulners.com per il risultato, in entrambe le modalità.
L'`href` dell'endpoint stesso è l'indirizzo **a monte** - nvd.nist.gov per una CVE,
github.com per un exploit recuperato - e viaggia separatamente, come
`source_href`, così il significato di nessuno dei due campi dipende dalla modalità
che li ha prodotti.
L'output strutturato include sempre ogni risultato che ha superato `mincvss`,
anche quelli che la scala di verbosità nasconde dal testo - quindi nessuna
automazione perde risultati non passando `-v`.
**Il testo renderizzato è una rottura.** I token `*EXPLOIT*` e `*HAS EXPLOIT*`
e il layout separato da tabulazioni sono spariti, sostituiti dalla tabella
allineata sopra. Il link vulners.com per riga è rimasto: è l'ultima colonna, ed è
l'unica cella che il layout non accorcia, perché mezza URL non è una URL. I
consumatori che fanno scraping del testo devono essere aggiornati; i consumatori
di `-oX` no.
## Scansione educata
Una scansione di una rete chiede all'API molto meno di quanto sembri:
* una richiesta per identità software, e le risposte sono memorizzate nella cache per l'intera scansione
* una ricerca già in corso viene attesa piuttosto che ripetuta
* la scoperta va a un endpoint **con cache CDN**, senza chiave anche quando una è
configurata, così resta sulla cache condivisa invece di colpire l'origine
* la scansione dei 939 percorsi gira su una manciata di **connessioni pipelined**
piuttosto che una per percorso, chiede
pagine compresse, e smette di cercare corrispondenze una volta esaurito il suo
budget di byte
* un limite di velocità o un'interruzione ferma quella parte della scansione
invece di riprovare per host, e una chiave rifiutata scende al percorso gratuito
invece di silenziare la scansione
* i crediti sono spesi solo dove il percorso gratuito non può rispondere affatto
## Sviluppo
I test, il gate di igiene e `CONTRIBUTING.md` sono solo nel repository git;
l'archivio di rilascio include gli script e i loro dati. Otto gate, tutti
offline tranne dove indicato, e la CI esegue esattamente questi:```sh
nmap -sn -Pn --script ./tests/run.nse --script-args testdir=tests,root=. 127.0.0.1
python3 tests/e2e/run_e2e.py
python3 tools/check.py
python3 tools/catalog.py --check
python3 tools/xml_contract.py --selftest
python3 tools/fingerprints/selftest.py
python3 tools/catalog_diff.py --selftest
python3 tools/nmap_style.py
```
270 casi di unit test vengono eseguiti all'interno di nmap contro le vere librerie NSE; 64 casi end-to-end
guidano il vero binario di nmap contro un server web locale e un'API Vulners simulata che impone ciò che impone quella reale; il gate di igiene tiene segreti, output di scansione e disordine dell'editor fuori dall'albero e rifiuta una lettura globale che NSE trasformerebbe in un risultato perso; e gli ultimi quattro contengono i dati e gli strumenti che li pubblicano - la forma del catalogo, il contratto XML che ogni importatore legge, il traduttore di pattern e il gate che decide che una ricostruzione è sicura da pubblicare. L'ultimo tiene l'intero repository agli
[Standard di Codice di Nmap](https://secwiki.org/w/Nmap/Code_Standards), che
`HACKING` nomina come autorità per uno script che vuole vivere nell'albero di nmap:
niente tab, niente spazi bianchi finali, righe sotto 80 colonne, niente punti e virgola,
apertura NSEdoc privata con `--;`, PEP 8 per il Python.
`python3 tests/e2e/run_e2e.py --live` aggiunge controlli contro il servizio reale.
Vedi [CONTRIBUTING.md](https://github.com/vulnerscom/nmap-vulners/blob/master/CONTRIBUTING.md).
## FAQ
**Sfrutta qualcosa?** No. Legge banner e pagine e interroga un database -
non invia payload e non prova credenziali. È categorizzato
`discovery, intrusive, vuln, external` piuttosto che `safe`, per una sola ragione: la
scansione dei percorsi richiede 939 percorsi di una porta web, e la definizione di `safe` di nmap
esclude script che usano grandi quantità di larghezza di banda. Il `http-enum` di nmap stesso
richiede 2 204 e porta la stessa etichetta. Il tuo `-T` imposta quanto velocemente escono
e mai quanti, e `--script-args vulners.paths=none` disattiva del tutto la scansione.
**Funziona senza una chiave API?** Sì, completamente. Senza una usa l'endpoint
gratuito, che restituisce le stesse vulnerabilità per un CPE di quello a pagamento. Una
chiave aggiunge dettagli per ogni risultato e può nominare software che il percorso gratuito non può.
**Perché `-sC` ha smesso di trovare software web?** Perché `vulners` non è più nella
categoria `default` di nmap, e nemmeno la scansione delle impronte che viveva
in `http-vulners-regex.nse`. Inviare l'identità del software di un target a
una terza parte dovrebbe essere qualcosa che hai richiesto: esegui `--script vulners`.
**Perché una vulnerabilità mostra `cvss2.0` mentre un'altra mostra `cvss3.1`?** L'
etichetta nomina la scala su cui si trova il punteggio. Vulners restituisce quella che la fonte ha pubblicato; un punteggio v2 di 9.3 non è un punteggio v3 di 9.3.
**Perché viene mostrata una voce con punteggio basso quando imposto `mincvss`?** Perché ha un
exploit noto, o perché la fonte non l'ha mai valutata. Entrambi sono intenzionali.
**Il report dice che il catalogo non ha potuto essere scaricato.** Allora il fingerprinting web
non è stato eseguito e tutto il resto sì: il software nominato da nmap stesso è stato
comunque cercato. È detto ad alta voce per quella ragione - una capacità che non è stata
eseguita si legge come una capacità che non ha trovato nulla. Le due cause hanno
una formulazione separata: "non ha potuto essere scaricato" è la rete, e "ha risposto, ma
uno dei suoi dizionari non ha potuto essere letto" è il mirror a cui l'hai puntato.
**Non ha trovato nulla su un host che so essere vulnerabile.** Esegui con `-d2`: registra
ogni identità su cui ha chiesto. Di solito nmap nominava il servizio ma non la sua
versione, e non c'è una versione da cercare.
## Licenza
Gli script sono concessi in licenza come Nmap stesso - vedi [LICENSE](https://github.com/vulnerscom/nmap-vulners/blob/master/LICENSE) per la
Nmap Public Source License, e
[nmap.org/npsl](https://nmap.org/npsl/) per cosa significa.
I dati sulle vulnerabilità provengono da [Vulners](https://vulners.com) e sono soggetti ai
loro termini.
## Correlati
* [vulners.com](https://vulners.com) - il database dietro questi script
* [vulnersCom/api](https://github.com/vulnersCom/api) - il client Python
* [vulnersCom/burp-vulners-scanner](https://github.com/vulnersCom/burp-vulners-scanner) - gli stessi dati dentro Burp Suite
* [nmap.org/book/nse.html](https://nmap.org/book/nse.html) - come funzionano gli script NSE
---
<div align="center">
Mantenuto dal Team Vulners <[email protected]>
`#nmap` `#nse` `#vulnerability-scanner` `#cve` `#cvss` `#cpe` `#vulners`
`#security-tools` `#pentest` `#infosec` `#network-scanner` `#exploit-database`
`#lua` `#vulnerability-detection` `#security-automation`
</div>