Ceci affichera l'aide pour l'outil. Voici tous les commutateurs qu'il supporte.```yaml
Usage:
  naabu [flags]

Flags:
INPUT:
   -host string[]              hosts to scan ports for (comma-separated)
   -list, -l string            list of hosts to scan ports (file)
   -exclude-hosts, -eh string  hosts to exclude from the scan (comma-separated)
   -exclude-file, -ef string   list of hosts to exclude from scan (file)

PORT:
   -port, -p string            ports to scan (80,443, 100-200)
   -top-ports, -tp string      top ports to scan (default 100) [full,100,1000]
   -exclude-ports, -ep string  ports to exclude from scan (comma-separated)
   -ports-file, -pf string     list of ports to scan (file)
   -port-threshold, -pts int   port threshold to skip port scan for the host
   -exclude-cdn, -ec           skip full port scans for CDN/WAF (only scan for port 80,443)
   -display-cdn, -cdn          display cdn in use

RATE-LIMIT:
   -c int     general internal worker threads (default 25)
   -rate int  packets to send per second (default 1000)

UPDATE:
   -up, -update                 update naabu to latest version
   -duc, -disable-update-check  disable automatic naabu update check

OUTPUT:
   -o, -output string  file to write output to (optional)
   -j, -json           write output in JSON lines format
   -csv                write output in csv format

SERVICES-DISCOVERY:
   -sD, -service-discovery           identify services by port number
   -sV, -service-version             detect service versions using nmap-service-probes
   -sV-fast                          only probe port-hinted services (faster, skips fallback)
   -sV-timeout duration              timeout for service version probes (default 5s)
   -sV-workers int                   number of concurrent service version workers (default 25)
   -sV-probes string                 custom nmap-service-probes file path (auto-detected from local nmap install if empty)
   -uP, -udp-probes                  send protocol-specific payloads on UDP scans using nmap-service-probes

CONFIGURATION:
   -config string                   path to the naabu configuration file (default $HOME/.config/naabu/config.yaml)
   -scan-all-ips, -sa               scan all the IP's associated with DNS record
   -ip-version, -iv string[]        ip version to scan of hostname (4,6) - (default 4,6) (default ["4","6"])
   -scan-type, -s string            type of port scan (SYN/CONNECT) (default "c")
   -source-ip string                source ip and port (x.x.x.x:yyy - might not work on OSX) 
   -cp, -connect-payload string    payload to send in CONNECT scans (optional)
   -interface-list, -il             list available interfaces and public ip
   -interface, -i string            network Interface to use for port scan
   -nmap                            invoke nmap scan on targets (nmap must be installed) - Deprecated
   -nmap-cli string                 nmap command to run on found results (example: -nmap-cli 'nmap -sV')
   -r string                        list of custom resolver dns resolution (comma separated or from file)
   -proxy string                    socks5 proxy (ip[:port] / fqdn[:port]
   -proxy-auth string               socks5 proxy authentication (username:password)
   -dns-order string                dns resolution order (p/l/lp/pl) (default "l")
   -sr, -system-resolver            use system DNS as fallback resolver
   -resume                          resume scan using resume.cfg
   -stream                          stream mode (disables resume, nmap, verify, retries, shuffling, etc)
   -passive                         display passive open ports using shodan internetdb api (automatically enables stream mode)
   -irt, -input-read-timeout value  timeout on input read (default 3m0s)
   -no-stdin                        Disable Stdin processing

HOST-DISCOVERY:
   -sn, -host-discovery           Perform Only Host Discovery
   -show-dead                     show hosts that did not respond to host discovery (requires host discovery)
   -Pn, -skip-host-discovery      Skip Host discovery (Deprecated: use -wn/-with-host-discovery instead)
   -wn, -with-host-discovery      Enable Host discovery
   -ps, -probe-tcp-syn string[]   TCP SYN Ping (host discovery needs to be enabled)
   -pa, -probe-tcp-ack string[]   TCP ACK Ping (host discovery needs to be enabled)
   -pe, -probe-icmp-echo          ICMP echo request Ping (host discovery needs to be enabled)
   -pp, -probe-icmp-timestamp     ICMP timestamp request Ping (host discovery needs to be enabled)
   -pm, -probe-icmp-address-mask  ICMP address mask request Ping (host discovery needs to be enabled)
   -arp, -arp-ping                ARP ping (host discovery needs to be enabled)
   -nd, -nd-ping                  IPv6 Neighbor Discovery (host discovery needs to be enabled)
   -rev-ptr                       Reverse PTR lookup for input ips

OPTIMIZATION:
   -retries int                    number of retries for the port scan (default 3)
   -timeout int                    millisecond to wait before timing out (default 1000)
   -warm-up-time int               time in seconds between scan phases (default 2)
   -ping                           ping probes for verification of host
   -verify                         validate the ports again with TCP verification
   -ss, -smart-scan                predictive port scanning using port correlation model (not compatible with stream mode)
   -pt, -prediction-threshold int  minimum confidence for port predictions (0-100%) (default 20)

DEBUG:
   -health-check, -hc        run diagnostic check up
   -debug                    display debugging information
   -verbose, -v              display verbose output
   -no-color, -nc            disable colors in CLI output
   -silent                   display only results in output
   -version                  display version of naabu
   -stats                    display stats of the running scan (deprecated)
   -si, -stats-interval int  number of seconds to wait between showing a statistics update (deprecated) (default 5)
   -mp, -metrics-port int    port to expose naabu metrics on (default 63636)

CLOUD:
   -auth                           configure projectdiscovery cloud (pdcp) api key (default true)
   -ac, -auth-config string        configure projectdiscovery cloud (pdcp) api key credential file
   -pd, -dashboard                 upload / view output in projectdiscovery cloud (pdcp) UI dashboard
   -tid, -team-id string           upload asset results to given team id (optional)
   -aid, -asset-id string          upload new assets to existing asset id (optional)
   -aname, -asset-name string      assets group name to set (optional)
   -pdu, -dashboard-upload string  upload naabu output file (jsonl) in projectdiscovery cloud (pdcp) UI dashboard

# Exécution de Naabu

Pour exécuter l'outil sur une cible, utilisez simplement la commande suivante.```sh
naabu -host hackerone.com

              __

projectdiscovery.io

Les ports à scanner sur l'hôte peuvent être spécifiés via le paramètre `-p` (les ports udp doivent être exprimés sous la forme `u:port`). Il prend des ports au format nmap et exécute une énumération sur ceux-ci.```sh
naabu -p 80,443,21-23,u:53 -host hackerone.com

Par défaut, Naabu vérifie les ports `Top 100` de nmap. Il prend en charge les listes de ports intégrées suivantes -

| Drapeau           | Description                          |
|-------------------|--------------------------------------|
| `-top-ports 100`  | Analyse des **100** premiers ports nmap |
| `-top-ports 1000` | Analyse des **1000** premiers ports nmap|
| `-p - `           | Analyse de tous les ports de **1 à 65535** |

Vous pouvez également spécifier des ports particuliers que vous souhaitez exclure de l'analyse.```sh
naabu -p - -exclude-ports 80,443

Pour exécuter naabu sur un ASN, l'entrée AS peut être utilisée. Il prend l'adresse IP disponible pour l'ASN donné et exécute l'enumeration sur celles-ci.```console
echo AS14421 | naabu -p 80,443

216.101.17.249:80
216.101.17.249:443
216.101.17.248:443
216.101.17.252:443
216.101.17.251:80
216.101.17.251:443
216.101.17.250:443
216.101.17.250:80

Les ports découverts peuvent également être redirigés vers d'autres outils. Par exemple, vous pouvez rediriger les ports découverts par naabu vers httpx qui trouvera alors les serveurs HTTP en cours d'exécution sur l'hôte.```console
echo hackerone.com | naabu -silent | httpx -silent

http://hackerone.com:8443
http://hackerone.com:443
http://hackerone.com:8080
http://hackerone.com:80

L'option `-ip-version 6` fait en sorte que l'outil utilise uniquement les adresses IPv6 lors de la résolution des noms de domaine.```console
echo hackerone.com | ./naabu -p 80 -ip-version 6

                  __
  ___  ___  ___ _/ /  __ __
 / _ \/ _ \/ _ \/ _ \/ // /
/_//_/\_,_/\_,_/_.__/\_,_/ v2.0.8

      projectdiscovery.io

Use with caution. You are responsible for your actions
Developers assume no liability and are not responsible for any misuse or damage.
[INF] Running CONNECT scan with non root privileges
[INF] Found 1 ports on host hackerone.com (2606:4700::6810:6334)
hackerone.com:80

# Découverte d'hôtes

Naabu prend en charge optionnellement plusieurs options pour effectuer la découverte d'hôtes. La découverte d'hôtes est optionnelle et peut être activée avec le drapeau `-wn`. Le drapeau `-sn` demande à l'outil d'effectuer uniquement la découverte d'hôtes.

Options disponibles pour effectuer la découverte d'hôtes :

- **ARP** ping (`-arp`)
- TCP **SYN** ping (`-ps 80`)
- TCP **ACK** ping (`-pa 443`)
- ICMP **echo** ping (`-pe`)
- ICMP **timestamp** ping (`-pp`)
- ICMP **address mask** ping (`-pm`)
- IPv6 **neighbor discovery** (`-nd`)

# Fichier de configuration

Naabu prend en charge un fichier de configuration par défaut situé à `$HOME/.config/naabu/config.yaml`. Il vous permet de définir n'importe quel drapeau dans le fichier de configuration et de définir des valeurs par défaut à inclure pour tous les scans.

# Intégration Nmap

Nous avons intégré le support de nmap pour la découverte de services ou tout scan supplémentaire pris en charge par nmap sur les résultats trouvés par Naabu. Assurez-vous d'avoir `nmap` installé pour utiliser cette fonctionnalité.

Pour l'utiliser,`nmap-cli` drapeau peut être utilisé suivi de la commande nmap, par exemple :-```console
echo hackerone.com | naabu -nmap-cli 'nmap -sV -oX nmap-output'
                  __       
  ___  ___  ___ _/ /  __ __
 / _ \/ _ \/ _ \/ _ \/ // /
/_//_/\_,_/\_,_/_.__/\_,_/ v2.0.0        

    projectdiscovery.io

[WRN] Use with caution. You are responsible for your actions
[WRN] Developers assume no liability and are not responsible for any misuse or damage.
[INF] Running TCP/ICMP/SYN scan with root privileges
[INF] Found 4 ports on host hackerone.com (104.16.99.52)

hackerone.com:443
hackerone.com:80
hackerone.com:8443
hackerone.com:8080

[INF] Running nmap command: nmap -sV -p 80,8443,8080,443 104.16.99.52

Starting Nmap 7.01 ( https://nmap.org ) at 2020-09-23 05:02 UTC
Nmap scan report for 104.16.99.52
Host is up (0.0021s latency).
PORT     STATE SERVICE       VERSION
80/tcp   open  http          cloudflare
443/tcp  open  ssl/https     cloudflare
8080/tcp open  http-proxy    cloudflare
8443/tcp open  ssl/https-alt cloudflare

### Installation

En utilisant pip :
`pip install django-keycloak-auth`

OU

Pour contribuer et/ou configurer un environnement de développement, forkez ce dépôt et exécutez :
`pip install -e ".[dev]"`

Après l'installation, ajoutez l'application `django_keycloak_auth` à votre `INSTALLED_APPS` dans votre `settings.py` de django :

#### Exemple

```python
INSTALLED_APPS = [
   ...
   'django_keycloak_auth',
]

# Keycloak OIDC configurations
KEYCLOAK_SERVER_URL = os.getenv('KEYCLOAK_SERVER_URL')
KEYCLOAK_REALM = os.getenv('KEYCLOAK_REALM')
KEYCLOAK_CLIENT_ID = os.getenv('KEYCLOAK_CLIENT_ID')
KEYCLOAK_CLIENT_SECRET = os.getenv('KEYCLOAK_CLIENT_SECRET')
KEYCLOAK_CLIENT_SCOPE = os.getenv('KEYCLOAK_CLIENT_SCOPE', 'openid profile email')
KEYCLOAK_REDIRECT_URI = os.getenv('KEYCLOAK_REDIRECT_URI')
KEYCLOAK_LOGOUT_REDIRECT_URI = os.getenv('KEYCLOAK_LOGOUT_REDIRECT_URI')

AUTHENTICATION_BACKENDS = [
   'django_keycloak_auth.backends.KeycloakAuthBackend',
   ...
]

Drapeaux disponibles :

| Drapeau | Description |
|---------|-------------|
| `-sV` | Activer la détection de version de service |
| `-sV-fast` | Ne sonder que les services suggérés par le port (plus rapide, ignore les sondes de repli) |
| `-sV-timeout duration` | Délai d'attente pour les sondes de version de service (par défaut 5s) |
| `-sV-workers int` | Nombre de travailleurs simultanés pour la version de service (par défaut 25) |
| `-sV-probes string` | Chemin personnalisé du fichier nmap-service-probes (détecté automatiquement à partir de l'installation locale de nmap si vide) |
| `-sD` | Découverte de service (associer le numéro de port au nom du service, sans sondage actif) |

Le drapeau `-sV` nécessite le fichier de base de données `nmap-service-probes`. naabu ne livre pas cette base de données elle-même (elle est sous licence copyleft Nmap Public Source License, incompatible avec la licence MIT de naabu), donc il lit le fichier à partir d'une installation locale de nmap, en cherchant automatiquement dans les chemins d'installation standard de nmap. Pour utiliser un fichier personnalisé, spécifiez le chemin avec `-sV-probes`.

# Sondes de services UDP

Les services UDP restent généralement silencieux lorsqu'ils reçoivent un datagramme vide, donc un scan de ports UDP aveugle en manque la plupart. Avec `-uP` (`-udp-probes`), naabu choisit une charge utile spécifique au protocole dans la base de données `nmap-service-probes` pour chaque port UDP scanné (requête DNS pour le 53, requête NTP pour le 123, GetRequest SNMPv1 pour le 161, etc.), de sorte que les vrais services aient quelque chose à quoi répondre et naabu puisse les signaler comme ouverts.```sh
naabu -host scanme.sh -p u:53,u:123,u:161 -uP

"context"
"github.com/projectdiscovery/goflags"
"github.com/projectdiscovery/naabu/v2/pkg/result"
"github.com/projectdiscovery/naabu/v2/pkg/runner"

naabuRunner, err := runner.NewRunner(&options)
if err != nil {
	log.Fatal(err)
}
defer naabuRunner.Close()

naabuRunner.RunEnumeration(context.Background())

> **`OnResult`** est appelée une fois après la fin de l'analyse avec les résultats agrégés. Pour traiter les résultats **en temps réel** au fur et à mesure que les ports sont découverts, utilisez **`OnReceive`** à la place. L'option `Stream` contrôle uniquement le chargement asynchrone des cibles — elle n'affecte pas le moment où les callbacks sont déclenchés.

# Remarques

- Naabu permet l'exécution binaire arbitraire en tant que fonctionnalité pour prendre en charge [l'intégration nmap](https://github.com/projectdiscovery/naabu#nmap-integration).
- Naabu est conçu pour scanner les ports sur plusieurs hôtes / scan de ports de masse.
- Par défaut, naabu est configuré avec l'hypothèse que vous l'exécutez depuis un VPS.
- Nous suggérons d'ajuster les indicateurs / le débit si vous exécutez naabu depuis un système local.
- Pour de meilleurs résultats, exécutez naabu en tant qu'utilisateur **root**.

-----

Naabu est fait avec 🖤 par l'équipe [projectdiscovery](https://projectdiscovery.io). Les contributions de la communauté ont fait du projet ce qu'il est.

Voir le fichier **[Thanks.md](https://github.com/projectdiscovery/naabu/blob/master/THANKS.md)** pour plus de détails.