**Plus d'options pour installer / exécuter katana-**

<details>
  <summary>Docker</summary>

> Pour installer / mettre à jour docker vers le dernier tag -```sh
docker pull projectdiscovery/katana:latest

> Pour exécuter katana en mode headless avec docker -```sh
docker run projectdiscovery/katana:latest -u https://tesla.com -system-chrome -headless

Ceci affichera l'aide pour l'outil. Voici toutes les options qu'il prend en charge.```console
Katana is a fast crawler focused on execution in automation
pipelines offering both headless and non-headless crawling.

Usage:
  ./katana [flags]

Flags:
INPUT:
   -u, -list string[]     target url / list to crawl
   -resume string         resume scan using resume.cfg
   -e, -exclude string[]  exclude host matching specified filter ('cdn', 'private-ips', cidr, ip, regex)

CONFIGURATION:
   -r, -resolvers string[]       list of custom resolver (file or comma separated)
   -d, -depth int                maximum depth to crawl (default 3)
   -jc, -js-crawl                enable endpoint parsing / crawling in javascript file
   -jsl, -jsluice                enable jsluice parsing in javascript file (memory intensive)
   -ct, -crawl-duration value    maximum duration to crawl the target for (s, m, h, d) (default s)
   -kf, -known-files string      enable crawling of known files (all,robotstxt,sitemapxml), a minimum depth of 3 is required to ensure all known files are properly crawled.
   -mrs, -max-response-size int  maximum response size to read (default 4194304)
   -timeout int                  time to wait for request in seconds (default 10)
   -aff, -automatic-form-fill    enable automatic form filling (experimental)
   -fx, -form-extraction         extract form, input, textarea & select elements in jsonl output
   -retry int                    number of times to retry the request (default 1)
   -proxy string                 http/socks5 proxy to use
   -td, -tech-detect             enable technology detection
   -H, -headers string[]         custom header/cookie to include in all http request in header:value format (file)
   -config string                path to the katana configuration file
   -fc, -form-config string      path to custom form configuration file
   -flc, -field-config string    path to custom field configuration file
   -s, -strategy string          Visit strategy (depth-first, breadth-first) (default "depth-first")
   -iqp, -ignore-query-params    Ignore crawling same path with different query-param values
   -fsu, -filter-similar         filter crawling of similar looking URLs (e.g., /users/123 and /users/456)
   -fst, -filter-similar-threshold int  number of distinct values before a path position is treated as parameter (default 10)
   -tlsi, -tls-impersonate       enable experimental client hello (ja3) tls randomization
   -dr, -disable-redirects       disable following redirects (default false)
   -kb, -knowledge-base          enable knowledge base classification
   -kb-secrets                   enable secrets extractor in the knowledge base
   -kb-validate-secrets          validate detected secrets against their provider (sends live API calls)
   -kb-endpoints                 enable endpoints extractor (classifies REST/GraphQL/SOAP/XHR requests)
   -mdp, -max-domain-pages int   maximum number of pages to crawl per domain (default unlimited)

DEBUG:
   -health-check, -hc        run diagnostic check up
   -elog, -error-log string  file to write sent requests error log
   -pprof-server             enable pprof server

HEADLESS:
   -hl, -headless                    enable headless hybrid crawling (experimental)
   -sc, -system-chrome               use local installed chrome browser instead of katana installed
   -sb, -show-browser                show the browser on the screen with headless mode
   -ho, -headless-options string[]   start headless chrome with additional options
   -nos, -no-sandbox                 start headless chrome in --no-sandbox mode
   -cdd, -chrome-data-dir string     path to store chrome browser data
   -scp, -system-chrome-path string  use specified chrome browser for headless crawling
   -noi, -no-incognito               start headless chrome without incognito mode
   -cwu, -chrome-ws-url string       use chrome browser instance launched elsewhere with the debugger listening at this URL
   -xhr, -xhr-extraction             extract xhr request url,method in jsonl output
   -pls, -page-load-strategy string  page load strategy (heuristic, load, domcontentloaded, networkidle, none) (default "heuristic")
   -dwt, -dom-wait-time int          time in seconds to wait after page load when using domcontentloaded strategy (default 5)
   -csp, -captcha-solver-provider string  captcha solver provider (e.g. capsolver)
   -csk, -captcha-solver-key string       captcha solver provider api key

SCOPE:
   -cs, -crawl-scope string[]       in scope url regex to be followed by crawler
   -cos, -crawl-out-scope string[]  out of scope url regex to be excluded by crawler
   -fs, -field-scope string         pre-defined scope field (dn,rdn,fqdn) or custom regex (e.g., '(company-staging.io|company.com)') (default "rdn")
   -ns, -no-scope                   disables host based default scope
   -do, -display-out-scope          display external endpoint from scoped crawling

FILTER:
   -mr, -match-regex string[]             regex or list of regex to match on output url (cli, file)
   -fr, -filter-regex string[]            regex or list of regex to filter on output url (cli, file)
   -f, -field string                      field to display in output (url,path,fqdn,rdn,rurl,qurl,qpath,file,ufile,key,value,kv,dir,udir) (Deprecated: use -output-template instead)
   -sf, -store-field string               field to store in per-host output (url,path,fqdn,rdn,rurl,qurl,qpath,file,ufile,key,value,kv,dir,udir)
   -em, -extension-match string[]         match output for given extension (eg, -em php,html,js,none)
   -ef, -extension-filter string[]        filter output for given extension (eg, -ef png,css)
   -ndef, -no-default-ext-filter bool     remove default extensions from the filter list
   -mdc, -match-condition string          match response with dsl based condition
   -fdc, -filter-condition string         filter response with dsl based condition
   -duf, -disable-unique-filter           disable duplicate content filtering
   -filter-page-type string[]      filter response with page type (e.g. error,captcha,parked)

RATE-LIMIT:
   -c, -concurrency int          number of concurrent fetchers to use (default 10)
   -p, -parallelism int          number of concurrent inputs to process (default 10)
   -rd, -delay int               request delay between each request in seconds
   -rl, -rate-limit int          maximum requests to send per second (default 150)
   -rlm, -rate-limit-minute int  maximum number of requests to send per minute
   -hrl, -host-rate-limit int    maximum requests to send per second per host
   -hrlm, -host-rate-limit-minute int  maximum number of requests to send per minute per host

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

OUTPUT:
   -o, -output string                file to write output to
   -output-template string      custom output template
   -sr, -store-response              store http requests/responses
   -srd, -store-response-dir string  store http requests/responses to custom directory
   -ncb, -no-clobber                 do not overwrite output file
   -sfd, -store-field-dir string     store per-host field to custom directory
   -or, -omit-raw                    omit raw requests/responses from jsonl output
   -ob, -omit-body                   omit response body from jsonl output
   -lof, -list-output-fields         list available fields for jsonl output format
   -eof, -exclude-output-fields      exclude fields from jsonl output
   -j, -jsonl                        write output in jsonl format
   -nc, -no-color                    disable output content coloring (ANSI escape codes)
   -silent                           display output only
   -v, -verbose                      display verbose output
   -debug                            display debug output
   -version                          display project version

#### Saisie d'URL multiples (séparées par des virgules)```sh
katana -u https://tesla.com,https://google.com

- [user](https://github.com/user) - 
- [User](https://github.com/User) - 
- [User](https://github.com/User) -```
katana -list url_list.txt

<details>
<summary><strong>PLUS DE DÉMOS</strong></summary>

Extraction d'identifiants via LSASS
===
> Si vous avez besoin de la démo complète, consultez le [dépôt original](https://github.com/fortra/nanodump).

</details>```sh
cat domains | httpx | katana

  projectdiscovery.io

## Mode de Crawling

### Mode Standard

Le mode de crawling standard utilise la bibliothèque http standard de Go sous le capot pour gérer les requêtes/réponses HTTP. Cette modalité est beaucoup plus rapide car elle ne nécessite pas la surcharge d'un navigateur. Néanmoins, elle analyse le corps des réponses HTTP tel quel, sans aucun rendu JavaScript ou DOM, ce qui peut potentiellement manquer des points d'accès découverts après le rendu DOM ou des appels asynchrones qui pourraient se produire dans des applications web complexes dépendant, par exemple, d'événements spécifiques au navigateur.

### Mode Headless

Le mode Headless connecte les appels headless internes pour gérer les requêtes/réponses HTTP directement dans le contexte du navigateur. Cela offre deux avantages :
- L'empreinte HTTP (TLS et user-agent) identifie complètement le client comme un navigateur légitime
- Une meilleure couverture puisque les points d'accès sont découverts en analysant la réponse brute standard, comme dans la modalité précédente, et également celle rendue par le navigateur avec JavaScript activé.

Le crawling headless est optionnel et peut être activé en utilisant l'option `-headless`.

Voici d'autres options CLI pour le mode headless -```console
katana -h headless

Flags:
HEADLESS:
   -hl, -headless                    enable headless hybrid crawling (experimental)
   -sc, -system-chrome               use local installed chrome browser instead of katana installed
   -sb, -show-browser                show the browser on the screen with headless mode
   -ho, -headless-options string[]   start headless chrome with additional options
   -nos, -no-sandbox                 start headless chrome in --no-sandbox mode
   -cdd, -chrome-data-dir string     path to store chrome browser data
   -scp, -system-chrome-path string  use specified chrome browser for headless crawling
   -noi, -no-incognito               start headless chrome without incognito mode
   -cwu, -chrome-ws-url string       use chrome browser instance launched elsewhere with the debugger listening at this URL
   -xhr, -xhr-extraction             extract xhr requests
   -pls, -page-load-strategy string  page load strategy (heuristic, load, domcontentloaded, networkidle, none) (default "heuristic")
   -dwt, -dom-wait-time int          time in seconds to wait after page load when using domcontentloaded strategy (default 5)
   -csp, -captcha-solver-provider string  captcha solver provider (e.g. capsolver)
   -csk, -captcha-solver-key string       captcha solver provider api key

*`-no-incognito`*
----

Exécute le navigateur Chrome sans tête sans le mode incognito, utile lors de l'utilisation du navigateur local.```console
katana -u https://tesla.com -headless -no-incognito

*`-headless-options`*
----

Lors du crawl en mode headless, des options Chrome supplémentaires peuvent être spécifiées en utilisant `-headless-options`, par exemple -```console
katana -u https://tesla.com -headless -system-chrome -headless-options --disable-gpu,proxy-server=http://127.0.0.1:8080

La stratégie `domcontentloaded` est particulièrement utile pour les applications monopages (SPA) qui ne terminent jamais complètement leur chargement en raison de requêtes d’arrière‑plan continues (websockets, sondages, etc.).

*`-dom-wait-time`*
----

Lorsque l’on utilise la stratégie de chargement de page `domcontentloaded`, cette option spécifie le nombre de secondes à attendre après le déclenchement de l’événement DOMContentLoaded. Cela laisse le temps au JavaScript de rendre les éléments interactifs. La valeur par défaut est de 5 secondes.```console
katana -u https://tesla.com -headless -pls domcontentloaded -dwt 10

Le fournisseur et la clé peuvent également être définis via des variables d'environnement :```console
export CAPTCHA_SOLVER_PROVIDER=capsolver
export CAPTCHA_SOLVER_KEY=YOUR_API_KEY
katana -u https://example.com -headless

*`-crawl-scope`*
------

Pour un contrôle avancé de la portée, l'option `-cs` peut être utilisée avec le support des **expressions régulières**.```console
katana -u https://tesla.com -cs login

# # # I n t é g r a t i o n   a v e c   S O A R   p l a t e f o r m e s```console
katana -u https://tesla.com -cs in_scope.txt

Pour plusieurs règles hors de portée, une entrée de fichier avec une chaîne multiligne / regex peut être transmise.```bash
$ cat out_of_scope.txt

/logout
/log_out

pulsar scan -v ...

pulsar container scan <image_name>

pulsar container scan node:latest
``````console
katana -u https://tesla.com -cos out_of_scope.txt

*`-display-out-scope`*
----

Par défaut, lorsque l'option scope est utilisée, elle s'applique également aux liens à afficher en sortie, de sorte que **les URL externes sont exclues par défaut** et pour modifier ce comportement, l'option `-do` peut être utilisée pour afficher toutes les URL externes qui existent dans les URL / points de terminaison couverts par le scope des cibles.```
katana -u https://tesla.com -do

## Configuration du Crawler

Katana propose plusieurs options pour configurer et contrôler le crawl selon nos besoins.

*`-depth`*
----

Option pour définir la `depth` (profondeur) de suivi des URLs lors du crawl. Plus la profondeur est grande, plus le nombre d'endpoints crawlés est élevé, et plus le temps de crawl est long.```
katana -u https://tesla.com -d 5

*`-crawl-duration`*
----

Option pour prédéfinir la durée de crawl, désactivée par défaut.```
katana -u https://tesla.com -ct 2

*`-automatic-form-fill`*
----

Option pour activer le remplissage automatique de formulaires pour les champs connus / inconnus. Les valeurs de champs connus peuvent être personnalisées selon les besoins en mettant à jour le fichier de configuration du formulaire situé à `$HOME/.config/katana/form-config.yaml`.

Le remplissage automatique de formulaires est une fonctionnalité expérimentale.```
katana -u https://tesla.com -aff

*`-filter-similar`*
----

Option pour filtrer le crawling des URL d'apparence similaire en normalisant les segments de chemin variables. Cela détecte les IDs, UUIDs, hachages, dates et autres valeurs dynamiques, et apprend également des motifs répétitifs à l'exécution. Par exemple, `/users/123` et `/users/456` sont traités comme le même point de terminaison.```
katana -u https://tesla.com -fsu

*`-max-domain-pages`*
----

Option pour limiter le nombre de pages explorées par domaine. Empêche qu'un seul domaine ne consomme l'intégralité du budget d'exploration, utile pour les grands sites ou la protection contre les pièges d'exploration.```
katana -u https://tesla.com -mdp 100

[No content provided to translate.]```json
{
  "timestamp": "...",
  "request": { "...": "..." },
  "response": {
    "...": "...",
    "knowledgebase": {
      "PageType": "login",
      "Forms": [{ "type": "login", "fields": { "username": "username or email", "password": "password" } }]
    }
  }
}

*`-kb-secrets`*
----

Activer l'extracteur de secrets dans la base de connaissances, en révélant les secrets détectés (clés API, jetons, etc.) sous la clé `secrets`. Ajoutez `-kb-validate-secrets` pour valider les secrets détectés auprès de leur fournisseur — notez que cela **envoie des appels API en direct**.```console
katana -u https://example.com -kb-secrets

## Crawling Authentifié

Le crawling authentifié consiste à inclure des en-têtes ou cookies personnalisés dans les requêtes HTTP afin d'accéder à des ressources protégées. Ces en-têtes fournissent des informations d'authentification ou d'autorisation, vous permettant de crawler du contenu ou des points d'accès authentifiés. Vous pouvez spécifier les en-têtes directement en ligne de commande ou les fournir via un fichier avec katana pour effectuer du crawling authentifié.

> **Note** : L'utilisateur doit effectuer manuellement l'authentification et exporter le cookie/en-tête de session vers un fichier pour l'utiliser avec katana.

*`-headers`*
----

Option pour ajouter un en-tête ou cookie personnalisé à la requête.
> Syntaxe des [en-têtes](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2) dans la spécification HTTP

Voici un exemple d'ajout d'un cookie à la requête :```
katana -u https://tesla.com -H 'Cookie: usrsess=AmljNrESo'

- Détection de vulnérabilités (SQL Injection, XSS, LFI, etc.)
- Attaques par force brute (SSH, FTP, SMTP, etc.)
- Découverte de sous-domaines (vhosts)
- Scan de ports
- Sniffing réseau
- Fuzzing de fichiers ciblés```
katana -u https://tesla.com -H cookie.txt

### Connexion à une session de navigateur active

Katana peut également se connecter à une session de navigateur active où l'utilisateur est déjà connecté et authentifié, et l'utiliser pour le crawling. La seule condition pour cela est de démarrer le navigateur avec le débogage à distance activé.

Voici un exemple de démarrage du navigateur Chrome avec le débogage à distance activé et son utilisation avec Katana -

**étape 1) Localisez d'abord le chemin de l'exécutable Chrome**

| Système d'exploitation | Emplacement de l'exécutable Chromium | Emplacement de l'exécutable Google Chrome |
|------------------|------------------------------|-----------------------------------|
| Windows (64-bit) | `C:\Program Files (x86)\Google\Chromium\Application\chrome.exe` | `C:\Program Files (x86)\Google\Chrome\Application\chrome.exe` |
| Windows (32-bit) | `C:\Program Files\Google\Chromium\Application\chrome.exe` | `C:\Program Files\Google\Chrome\Application\chrome.exe` |
| macOS | `/Applications/Chromium.app/Contents/MacOS/Chromium` | `/Applications/Google Chrome.app/Contents/MacOS/Google Chrome` |
| Linux | `/usr/bin/chromium` | `/usr/bin/google-chrome` |

**étape 2) Démarrez Chrome avec le débogage à distance activé ; il renverra une URL websocker. Par exemple, sur MacOS, vous pouvez démarrer Chrome avec le débogage à distance activé en utilisant la commande suivante** -```console
$ /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --remote-debugging-port=9222


DevTools listening on ws://127.0.0.1:9222/devtools/browser/c5316c9c-19d6-42dc-847a-41d1aeebf7d6

> **Note** : vous pouvez utiliser l'option `-cdd` pour spécifier un répertoire de données Chrome personnalisé afin de stocker les données du navigateur et les cookies, mais cela ne sauvegarde pas les données de session si le cookie est défini sur `Session` uniquement ou expire après un certain temps.

## Filtres

*`-field`*
----

> [!WARNING]
> Obsolète : utilisez [**`-output-template`**](#-output-template) à la place. Le drapeau `-field` est toujours pris en charge pour la rétrocompatibilité.

Katana est livré avec des champs intégrés qui peuvent être utilisés pour filtrer la sortie afin d'obtenir les informations souhaitées. L'option `-f` peut être utilisée pour spécifier l'un des champs disponibles.```
   -f, -field string  field to display in output (url,path,fqdn,rdn,rurl,qurl,qpath,file,key,value,kv,dir,udir)

### Champs personnalisés

Vous pouvez créer des champs personnalisés pour extraire et stocker des informations spécifiques des réponses de pages à l'aide de règles regex. Ces champs personnalisés sont définis à l'aide d'un fichier de configuration YAML et sont chargés depuis l'emplacement par défaut `$HOME/.config/katana/field-config.yaml`. Alternativement, vous pouvez utiliser l'option `-flc` pour charger un fichier de configuration de champs personnalisés depuis un emplacement différent.
Voici un exemple de champ personnalisé.```yaml
- name: email
  type: regex
  regex:
  - '([a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+\.[a-zA-Z0-9_-]+)'
  - '([a-zA-Z0-9+._-]+@[a-zA-Z0-9._-]+\.[a-zA-Z0-9_-]+)'

- name: phone
  type: regex
  regex:
  - '\d{3}-\d{8}|\d{4}-\d{7}'

`*`-store-field`*
---

Pour compléter l'option `field` qui est utile pour filtrer la sortie au moment de l'exécution, il y a l'option `-sf, -store-fields` qui fonctionne exactement comme l'option `field` sauf qu'au lieu de filtrer, elle stocke toutes les informations sur le disque dans le répertoire `katana_field` triées par URL cible. Utilisez `-sfd` ou `-store-field-dir` pour stocker les données dans un emplacement différent.```
katana -u https://tesla.com -sf key,fqdn,qurl -silent

L'option `-store-field` peut être utile pour collecter des informations afin de construire une wordlist ciblée à diverses fins, notamment mais sans s'y limiter :

- Identifier les paramètres les plus couramment utilisés
- Découvrir les chemins fréquemment utilisés
- Trouver les fichiers couramment utilisés
- Identifier les sous-domaines connexes ou inconnus

### Filtres Katana

*`-extension-match`*
---

La sortie du crawl peut être facilement filtrée pour une extension spécifique en utilisant l'option `-em` afin de n'afficher que les résultats contenant l'extension donnée.```
katana -u https://tesla.com -silent -em js,jsp,json

*`-extension-filter`*
---

La sortie du crawl peut être facilement filtrée pour une extension spécifique en utilisant l'option `-ef` qui permet de supprimer toutes les URLs contenant l'extension donnée.```
katana -u https://tesla.com -silent -ef css,txt,md

*`-match-regex`*
---
Le drapeau `-match-regex` ou `-mr` vous permet de filtrer les URL de sortie à l'aide d'expressions régulières. Lorsque vous utilisez ce drapeau, seules les URL qui correspondent à l'expression régulière spécifiée seront affichées dans la sortie.```
katana -u https://tesla.com -mr 'https://shop\.tesla\.com/*' -silent

### Filtrage avancé

Katana prend en charge les expressions basées sur DSL pour des capacités de filtrage et de correspondance avancées :

- Pour faire correspondre les points de terminaison avec un code d'état 200 :```shell
katana -u https://www.hackerone.com -mdc 'status_code == 200'

- Faire correspondre les endpoints avec les technologies PHP :```shell
katana -u https://www.hackerone.com -mdc 'contains(to_lower(technologies), "php")'

Les fonctions DSL peuvent être appliquées à toutes les clés de la sortie jsonl. Pour plus d'informations sur les fonctions DSL disponibles, veuillez visiter le [projet dsl](https://github.com/projectdiscovery/dsl).

Voici des options de filtre supplémentaires -```console
katana -h filter

Flags:
FILTER:
   -mr, -match-regex string[]             regex or list of regex to match on output url (cli, file)
   -fr, -filter-regex string[]            regex or list of regex to filter on output url (cli, file)
   -f, -field string                      field to display in output (url,path,fqdn,rdn,rurl,qurl,qpath,file,ufile,key,value,kv,dir,udir)
   -sf, -store-field string               field to store in per-host output (url,path,fqdn,rdn,rurl,qurl,qpath,file,ufile,key,value,kv,dir,udir)
   -em, -extension-match string[]         match output for given extension (eg, -em php,html,js,none)
   -ef, -extension-filter string[]        filter output for given extension (eg, -ef png,css)
   -ndef, -no-default-ext-filter bool     remove default extensions from the filter list
   -mdc, -match-condition string          match response with dsl based condition
   -fdc, -filter-condition string         filter response with dsl based condition
   -duf, -disable-unique-filter           disable duplicate content filtering

*`-concurrency`*
-----
option pour contrôler le nombre d'urls par cible à récupérer en même temps.```
katana -u https://tesla.com -c 20

*`-rate-limit`*
-----
Nombre maximal de requêtes par seconde, appliqué globalement à tous les hôtes.```
katana -u https://tesla.com -rl 100

*`-host-rate-limit`*
-----
Nombre maximal de requêtes par seconde par hôte. Chaque hôte possède son propre compartiment de limite de débit, de sorte qu'un hôte lent ne limitera pas les plus rapides. Remplace la limite de débit globale lorsqu'elle est définie. Katana réduit également automatiquement le rythme avec un délai exponentiel et une gigue lorsqu'un hôte renvoie 429 ou 503.```console
katana -u https://tesla.com -hrl 50

Voici toutes les options CLI longues / courtes pour le contrôle de la limite de débit -```console
katana -h rate-limit

Flags:
RATE-LIMIT:
   -c, -concurrency int          number of concurrent fetchers to use (default 10)
   -p, -parallelism int          number of concurrent inputs to process (default 10)
   -rd, -delay int               request delay between each request in seconds
   -rl, -rate-limit int          maximum requests to send per second (default 150)
   -rlm, -rate-limit-minute int  maximum number of requests to send per minute
   -hrl, -host-rate-limit int    maximum requests to send per second per host
   -hrlm, -host-rate-limit-minute int  maximum number of requests to send per minute per host

*`-output-template`*
---

L'option `-output-template` permet de personnaliser le format de sortie à l'aide d'un modèle, offrant une flexibilité dans la définition de la structure de la sortie. Cette option remplace l'ancien indicateur `-field` pour filtrer la sortie. Au lieu de s'appuyer sur des champs prédéfinis, vous pouvez spécifier un modèle personnalisé directement dans la ligne de commande pour contrôler la manière dont les données extraites sont présentées.

Exemple d'utilisation de l'option `-output-template` :```sh
katana -u https://example.com -output-template '{{email}} - {{url}}'

Please provide the Markdown content to translate.```json
{
  "timestamp": "2023-03-20T16:23:58.027559+05:30",
  "request": {
    "method": "GET",
    "endpoint": "https://example.com",
    "raw": "GET / HTTP/1.1\r\nHost: example.com\r\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 11_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36\r\nAccept-Encoding: gzip\r\n\r\n"
  },
  "response": {
    "status_code": 200,
    "headers": {
      "accept_ranges": "bytes",
      "expires": "Mon, 27 Mar 2023 10:53:58 GMT",
      "last_modified": "Thu, 17 Oct 2019 07:18:26 GMT",
      "content_type": "text/html; charset=UTF-8",
      "server": "ECS (dcb/7EA3)",
      "vary": "Accept-Encoding",
      "etag": "\"3147526947\"",
      "cache_control": "max-age=604800",
      "x_cache": "HIT",
      "date": "Mon, 20 Mar 2023 10:53:58 GMT",
      "age": "331239"
    },
    "body": "<!doctype html>\n<html>\n<head>\n    <title>Example Domain</title>\n\n    <meta charset=\"utf-8\" />\n    <meta http-equiv=\"Content-type\" content=\"text/html; charset=utf-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n    <style type=\"text/css\">\n    body {\n        background-color: #f0f0f2;\n        margin: 0;\n        padding: 0;\n        font-family: -apple-system, system-ui, BlinkMacSystemFont, \"Segoe UI\", \"Open Sans\", \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n        \n    }\n    div {\n        width: 600px;\n        margin: 5em auto;\n        padding: 2em;\n        background-color: #fdfdff;\n        border-radius: 0.5em;\n        box-shadow: 2px 3px 7px 2px rgba(0,0,0,0.02);\n    }\n    a:link, a:visited {\n        color: #38488f;\n        text-decoration: none;\n    }\n    @media (max-width: 700px) {\n        div {\n            margin: 0 auto;\n            width: auto;\n        }\n    }\n    </style>    \n</head>\n\n<body>\n<div>\n    <h1>Example Domain</h1>\n    <p>This domain is for use in illustrative examples in documents. You may use this\n    domain in literature without prior coordination or asking for permission.</p>\n    <p><a href=\"https://www.iana.org/domains/example\">More information...</a></p>\n</div>\n</body>\n</html>\n",
    "technologies": [
      "Azure",
      "Amazon ECS",
      "Amazon Web Services",
      "Docker",
      "Azure CDN"
    ],
    "raw": "HTTP/1.1 200 OK\r\nContent-Length: 1256\r\nAccept-Ranges: bytes\r\nAge: 331239\r\nCache-Control: max-age=604800\r\nContent-Type: text/html; charset=UTF-8\r\nDate: Mon, 20 Mar 2023 10:53:58 GMT\r\nEtag: \"3147526947\"\r\nExpires: Mon, 27 Mar 2023 10:53:58 GMT\r\nLast-Modified: Thu, 17 Oct 2019 07:18:26 GMT\r\nServer: ECS (dcb/7EA3)\r\nVary: Accept-Encoding\r\nX-Cache: HIT\r\n\r\n<!doctype html>\n<html>\n<head>\n    <title>Example Domain</title>\n\n    <meta charset=\"utf-8\" />\n    <meta http-equiv=\"Content-type\" content=\"text/html; charset=utf-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n    <style type=\"text/css\">\n    body {\n        background-color: #f0f0f2;\n        margin: 0;\n        padding: 0;\n        font-family: -apple-system, system-ui, BlinkMacSystemFont, \"Segoe UI\", \"Open Sans\", \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n        \n    }\n    div {\n        width: 600px;\n        margin: 5em auto;\n        padding: 2em;\n        background-color: #fdfdff;\n        border-radius: 0.5em;\n        box-shadow: 2px 3px 7px 2px rgba(0,0,0,0.02);\n    }\n    a:link, a:visited {\n        color: #38488f;\n        text-decoration: none;\n    }\n    @media (max-width: 700px) {\n        div {\n            margin: 0 auto;\n            width: auto;\n        }\n    }\n    </style>    \n</head>\n\n<body>\n<div>\n    <h1>Example Domain</h1>\n    <p>This domain is for use in illustrative examples in documents. You may use this\n    domain in literature without prior coordination or asking for permission.</p>\n    <p><a href=\"https://www.iana.org/domains/example\">More information...</a></p>\n</div>\n</body>\n</html>\n"
  }
}

[No content provided in the INPUT section.]```bash
$ cat katana_response/index.txt

katana_response/example.com/327c3fda87ce286848a574982ddd0b7c7487f816.txt https://example.com (200 OK)
katana_response/www.iana.org/bfc096e6dd93b993ca8918bf4c08fdc707a70723.txt http://www.iana.org/domains/reserved (200 OK)

*`-exclude-output-fields`*
----

L'option `-exclude-output-fields` ou `-eof` vous permet d'exclure des champs spécifiques de la sortie JSONL. Ceci est utile pour réduire la taille de la sortie ou se concentrer sur des données spécifiques en supprimant les champs indésirables.```console
katana -u https://example.com -jsonl -eof raw,body

## Katana en tant que bibliothèque
`katana` peut être utilisé comme bibliothèque en créant une instance de la structure `Option` et en la remplissant avec les mêmes options que celles spécifiées via la CLI. En utilisant les options, vous pouvez créer des `crawlerOptions` et donc un `crawler` standard ou hybride. La méthode `crawler.Crawl` doit être appelée pour crawler l'entrée.```go
package main

import (
	"math"

	"github.com/projectdiscovery/gologger"
	"github.com/projectdiscovery/katana/pkg/engine/standard"
	"github.com/projectdiscovery/katana/pkg/output"
	"github.com/projectdiscovery/katana/pkg/types"
)

func main() {
	options := &types.Options{
		MaxDepth:     3,             // Maximum depth to crawl
		FieldScope:   "rdn",         // Crawling Scope Field
		BodyReadSize: math.MaxInt,   // Maximum response size to read
		Timeout:      10,            // Timeout is the time to wait for request in seconds
		Concurrency:  10,            // Concurrency is the number of concurrent crawling goroutines
		Parallelism:  10,            // Parallelism is the number of urls processing goroutines
		Delay:        0,             // Delay is the delay between each crawl requests in seconds
		RateLimit:    150,           // Maximum requests to send per second
		Strategy:     "depth-first", // Visit strategy (depth-first, breadth-first)
		OnResult: func(result output.Result) { // Callback function to execute for result
			gologger.Info().Msg(result.Request.URL)
		},
	}
	crawlerOptions, err := types.NewCrawlerOptions(options)
	if err != nil {
		gologger.Fatal().Msg(err.Error())
	}
	defer crawlerOptions.Close()
	crawler, err := standard.New(crawlerOptions)
	if err != nil {
		gologger.Fatal().Msg(err.Error())
	}
	defer crawler.Close()
	var input = "https://www.hackerone.com"
	err = crawler.Crawl(input)
	if err != nil {
		gologger.Warning().Msgf("Could not crawl %s: %s", input, err.Error())
	}
}