Le répertoire contenant `nse_main.lua` est celui que ce nmap utilise.

</details>

## Arguments du script

| Argument | Défaut | Signification |
|---|---|---|
| `vulners.mincvss` | `0` | Masque les résultats dont le score est inférieur à celui-ci. Les bulletins sans score et tout ce qui a un exploit connu sont affichés quel que soit le seuil |
| `vulners.paths` | les 939 chemins publiés | Chemins pour le balayage web : une liste Lua, une chaîne nommant un fichier avec un chemin par ligne, ou `none` pour désactiver le balayage. Un fichier que vous nommez et qui ne peut pas être lu arrête le balayage et le signale, plutôt que de revenir à la liste publiée |
| `vulners.width` | `80` | Largeur du terminal pour laquelle le tableau est mis en forme |
| `vulners.max_items` | `32` | Plafond des éléments facturés pour l'ensemble du scan |
| `vulners.api_key` | - | Jeton API. Fuit : nmap copie sa propre ligne de commande dans `-oX` |
| `vulners.api_key_file` | - | Chemin absolu vers un fichier dont la première ligne est le jeton |
| `vulners.api_host` | `vulners.com` | Nom d'hôte de l'API |
| `vulners.api_port` | `443` | Port sur `api_host` |

Un nom seul fonctionne aussi, donc `--script-args mincvss=7` suffit.

Les préfixes d'arguments de la version 1.x - `vulners_enterprise.*` et
`http-vulners-regex.paths` - sont acceptés pendant une version et affichent un
avis de dépréciation.

## Où conserver la clé API

Par ordre de préférence :

1. `~/.nmap/vulners.key`, une ligne, mode 600 - l'installateur propose de l'écrire
2. `VULNERS_API_KEY` dans l'environnement
3. `--script-args vulners.api_key_file=/chemin/absolu`
4. `--script-args vulners.api_key=<jeton>`

La dernière option est pratique et fuit : nmap copie sa propre ligne de commande dans chaque
rapport, donc le jeton se retrouve dans l'attribut `args` de la sortie `-oX` et dans votre
historique de shell. Le script lui-même n'écrit jamais le jeton nulle part, y compris dans sa
sortie de débogage - il existe un test de régression qui le confirme.

Un fichier de clé que vous nommez explicitement et qui ne peut pas être lu arrête l'exécution
plutôt que de revenir silencieusement en arrière - un opérateur qui nomme un fichier veut dire ce fichier - et
le rapport indique de quel fichier il s'agissait. Un chemin mal saisi ne peut pas ressembler à un
scan propre.

## D'où viennent les empreintes

Le script ne les transporte pas. Il télécharge trois dictionnaires une fois par scan,
avant que le premier hôte ne soit touché :```
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

Les réponses sont mises en cache pour l'ensemble du scan, indexées par identité, donc une centaine
de serveurs identiques ne coûtent qu'une seule recherche. L'enrichissement est mis en cache par identifiant de résultat, donc deux
ports web exécutant des logiciels qui se chevauchent ne récupèrent chaque document qu'une seule fois.

## Sortie lisible par machine

Tout ce qui est imprimé est également structuré, donc `-oX` peut être analysé sans toucher au
texte lisible par l'humain. L'identifiant du script, les deux niveaux de tableau et les cinq clés
d'élément d'origine sont inchangés depuis la version 1.x, ce qui est ce que DefectDojo, Faraday,
nmap2csv et raven lisent :```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>

270 cas unitaires sont exécutés dans nmap contre les vraies bibliothèques NSE ; 64 cas de bout en bout pilotent le vrai binaire nmap contre un serveur web local et une API Vulners de substitution qui applique ce que la vraie applique ; la porte d'hygiène garde les secrets, la sortie de scan et le désordre d'éditeur hors de l'arborescence et refuse une lecture globale que NSE transformerait en résultat perdu ; et les quatre derniers contiennent les données et les outils qui les publient - la forme du catalogue, le contrat XML que chaque importateur lit, le traducteur de motifs, et la porte qui décide qu'une reconstruction peut être publiée sans risque. Le dernier contient l'intégralité du dépôt aux [propres normes de code de Nmap](https://secwiki.org/w/Nmap/Code_Standards), que `HACKING` désigne comme l'autorité pour un script qui veut vivre dans l'arborescence de nmap : pas de tabulations, pas d'espaces de fin de ligne, des lignes de moins de 80 colonnes, pas de points-virgules, une documentation NSEdoc privée commençant par `--;`, PEP 8 pour le Python.
`python3 tests/e2e/run_e2e.py --live` ajoute des vérifications contre le vrai service.
Voir [CONTRIBUTING.md](https://github.com/vulnerscom/nmap-vulners/blob/master/CONTRIBUTING.md).

## FAQ

**Est-ce que ça exploite quelque chose ?** Non. Ça lit des bannières et des pages et interroge une base de données - ça n'envoie aucune charge utile et n'essaie aucun identifiant. C'est catégorisé `discovery, intrusive, vuln, external` plutôt que `safe`, pour une seule raison : le balayage de chemins demande 939 chemins d'un port web, et la définition de `safe` par nmap exclut les scripts qui utilisent de grandes quantités de bande passante. Le propre `http-enum` de nmap demande 2 204 et porte la même étiquette. Votre `-T` définit la vitesse à laquelle ils partent et jamais combien, et `--script-args vulners.paths=none` désactive complètement le balayage.

**Est-ce que ça fonctionne sans clé API ?** Oui, entièrement. Sans clé, il utilise le point de terminaison gratuit, qui renvoie les mêmes vulnérabilités pour un CPE que celui payant. Une clé ajoute des détails par résultat et peut nommer des logiciels que le chemin gratuit ne peut pas.

**Pourquoi `-sC` a-t-il cessé de trouver des logiciels web ?** Parce que `vulners` n'est plus dans la catégorie `default` de nmap, et le balayage d'empreintes qui vivait dans `http-vulners-regex.nse` non plus. Envoyer l'identité du logiciel d'une cible à un tiers devrait être quelque chose que vous avez demandé : exécutez `--script vulners`.

**Pourquoi une vulnérabilité affiche-t-elle `cvss2.0` alors qu'une autre affiche `cvss3.1` ?** L'étiquette nomme l'échelle sur laquelle se trouve le score. Vulners renvoie celui que la source a publié ; un score v2 de 9,3 n'est pas un score v3 de 9,3.

**Pourquoi une entrée à faible score est-elle affichée quand je définis `mincvss` ?** Parce qu'elle a un exploit connu, ou parce que la source ne l'a jamais notée. Les deux sont délibérés.

**Le rapport dit que le catalogue n'a pas pu être téléchargé.** Alors l'empreinte web n'a pas été exécutée et tout le reste l'a été : le logiciel nommé par nmap lui-même a quand même été recherché. C'est dit à voix haute pour cette raison - une capacité qui ne s'est pas exécutée se lit comme une capacité qui n'a rien trouvé. Les deux causes ont une formulation distincte : « n'a pas pu être téléchargé » concerne le réseau, et « a répondu, mais l'un de ses dictionnaires n'a pas pu être lu » concerne le miroir vers lequel vous l'avez pointé.

**Ça n'a rien trouvé sur un hôte que je sais vulnérable.** Exécutez avec `-d2` : il journalise chaque identité demandée. En général, nmap a nommé le service mais pas sa version, et il n'y a pas de version à rechercher.

## Licence

Les scripts sont sous la même licence que Nmap lui-même - voir [LICENSE](https://github.com/vulnerscom/nmap-vulners/blob/master/LICENSE) pour la Nmap Public Source License, et
[nmap.org/npsl](https://nmap.org/npsl/) pour ce que cela signifie.

Les données de vulnérabilité proviennent de [Vulners](https://vulners.com) et sont soumises à leurs conditions.

## Liens connexes

* [vulners.com](https://vulners.com) - la base de données derrière ces scripts
* [vulnersCom/api](https://github.com/vulnersCom/api) - le client Python
* [vulnersCom/burp-vulners-scanner](https://github.com/vulnersCom/burp-vulners-scanner) - les mêmes données dans Burp Suite
* [nmap.org/book/nse.html](https://nmap.org/book/nse.html) - comment fonctionnent les scripts NSE

---

<div align="center">

Maintenu par l'équipe Vulners &lt;[email protected]&gt;

`#nmap` `#nse` `#vulnerability-scanner` `#cve` `#cvss` `#cpe` `#vulners`
`#security-tools` `#pentest` `#infosec` `#network-scanner` `#exploit-database`
`#lua` `#vulnerability-detection` `#security-automation`

</div>