Un framework di crawling e spidering di nuova generazione

Funzionalità • Installazione • Utilizzo • Ambito • Configurazione • Filtri • Unisciti a Discord

Funzionalità

Crawling web veloce e completamente configurabile
Modalità Standard e Headless
Analisi/crawling JavaScript
Compilazione automatica dei moduli personalizzabile
Controllo dell'ambito - Campo preconfigurato / Regex
Knowledge base - Classificazione ML di tipo pagina/modulo (modello scaricato automaticamente)
Output personalizzabile - Campi preconfigurati
INPUT - STDIN, URL e LIST
OUTPUT - STDOUT, FILE e JSON

Installazione

katana richiede Go 1.26+ per essere installato correttamente. Se incontri problemi di installazione, ti consigliamo di provare con l'ultima versione disponibile di Go, poiché la versione minima richiesta potrebbe essere cambiata. Esegui il comando qui sotto o scarica un binario precompilato dalla pagina dei rilasci.```console CGO_ENABLED=1 go install github.com/projectdiscovery/katana/cmd/katana@latest

**Altre opzioni per installare / eseguire katana-**

<details>
  <summary>Docker</summary>

> Per installare / aggiornare docker all'ultima versione -```sh
docker pull projectdiscovery/katana:latest

Per eseguire katana in modalità standard usando docker -```sh docker run projectdiscovery/katana:latest -u https://tesla.com

> Per eseguire katana in modalità headless usando docker -```sh
docker run projectdiscovery/katana:latest -u https://tesla.com -system-chrome -headless

Ubuntu

Si consiglia di installare i seguenti prerequisiti -```sh sudo apt update sudo apt install zip curl wget git snapd sudo snap refresh sudo snap install golang --classic

sudo install -d -m 0755 /etc/apt/keyrings curl -fsSL https://dl.google.com/linux/linux_signing_key.pub
| sudo gpg --dearmor -o /etc/apt/keyrings/google-chrome.gpg

echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/google-chrome.gpg]
http://dl.google.com/linux/chrome/deb/ stable main"
| sudo tee /etc/apt/sources.list.d/google-chrome.list > /dev/null

sudo apt update sudo apt install google-chrome-stable

> install katana -```sh
go install github.com/projectdiscovery/katana/cmd/katana@latest

Utilizzo```console

katana -h

Questo mostrerà l'aiuto per lo strumento. Ecco tutti gli switch che supporta.```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

Esecuzione di Katana

Input per katana

katana richiede un url o endpoint da scansionare e accetta input singoli o multipli.

L'URL di input può essere fornito usando l'opzione -u, e valori multipli possono essere forniti usando input separati da virgola; analogamente, l'input file è supportato usando l'opzione -list e inoltre è supportato l'input tramite pipe (stdin).

Input URL```sh

katana -u https://tesla.com

#### Input di URL multipli (separati da virgola)```sh
katana -u https://tesla.com,https://google.com

Input elenco```bash

$ cat url_list.txt

https://tesla.com https://google.com

It appears no content was provided after "INPUT:". Please provide the markdown content to translate.```
katana -list url_list.txt

STDIN (Input tramite pipe)```sh

echo https://tesla.com | katana

## Installazione

### Nativo
  
<details>
    <summary>
        Pacchetti prerequisiti
    </summary>

```sh
sudo apt update
sudo apt upgrade
sudo apt install git build-essential curl wget --no-install-recommends

# Clone the repository
git clone https://github.com/oppsec/pinkerton.git

# Enter in the Pinkerton folder
cd pinkerton

# Install Pinkerton dependencies
pip install -r requirements.txt

Docker

Se vuoi usare pinkerton in un container Docker, segui questi comandi:

# Clone the repository
git clone https://github.com/oppsec/pinkerton.git

# Enter in the Pinkerton folder
cd pinkerton

# Install Pinkerton dependencies
sudo docker build -t pinkerton:latest .
``````sh
cat domains | httpx | katana

Esempio di esecuzione di katana -```console katana -u https://youtube.com

/ /_____ / /___ ____ ___ _ / '/ _ / __/ _ / _ / _ / //_\,/_/_,////_,_/ v0.0.1

  projectdiscovery.io

## Modalità di Crawling

### Modalità Standard

La modalità di crawling standard utilizza internamente la libreria standard go http per gestire le richieste/risposte HTTP. Questa modalità è molto più veloce poiché non ha l'overhead del browser. Tuttavia, analizza il corpo delle risposte HTTP così com'è, senza alcun rendering javascript o DOM, perdendo potenzialmente endpoint dopo il rendering del DOM o chiamate asincrone agli endpoint che potrebbero avvenire in applicazioni web complesse che dipendono, ad esempio, da eventi specifici del browser.

### Modalità Headless

La modalità headless aggancia le chiamate headless interne per gestire le richieste/risposte HTTP direttamente nel contesto del browser. Questo offre due vantaggi:
- L'impronta HTTP (TLS e user agent) identifica completamente il client come un browser legittimo
- Una migliore copertura poiché gli endpoint vengono scoperti analizzando la risposta grezza standard, come nella modalità precedente, e anche quella renderizzata dal browser con javascript abilitato.

Il crawling headless è opzionale e può essere abilitato usando l'opzione `-headless`.

Ecco altre opzioni CLI 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-sandbox`

Esegue il browser headless Chrome con l'opzione no-sandbox, utile quando si esegue come utente root.```console katana -u https://tesla.com -headless -no-sandbox

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

Esegue il browser Chrome headless senza modalità incognito, utile quando si utilizza il browser locale.```console
katana -u https://tesla.com -headless -no-incognito

Per preservare i cookie e altri dati di sessione del browser tra le esecuzioni, combina -no-incognito con -chrome-data-dir in modo che Katana riutilizzi la directory del profilo Chrome scelta invece di una temporanea isolata.```console katana -u https://tesla.com -headless -no-incognito -chrome-data-dir /tmp/katana-profile

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

Durante la scansione in modalità headless, è possibile specificare opzioni aggiuntive di Chrome utilizzando `-headless-options`, ad esempio -```console
katana -u https://tesla.com -headless -system-chrome -headless-options --disable-gpu,proxy-server=http://127.0.0.1:8080

`-page-load-strategy`

Controlla come katana attende il caricamento delle pagine in modalità headless. Strategie diverse sono utili per diversi tipi di applicazioni web:

La strategia `domcontentloaded` è particolarmente utile per le applicazioni a pagina singola (SPA) che non completano mai del tutto il caricamento a causa di richieste di fondo continue (websocket, polling, ecc.).

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

Quando si utilizza la strategia di caricamento pagina `domcontentloaded`, questa opzione specifica quanti secondi attendere dopo il verificarsi dell'evento DOMContentLoaded. Questo dà tempo al JavaScript per renderizzare gli elementi interattivi. Il valore predefinito è 5 secondi.```console
katana -u https://tesla.com -headless -pls domcontentloaded -dwt 10

Risoluzione Captcha

Katana supporta il rilevamento e la risoluzione automatica dei captcha durante il crawling headless. Quando viene incontrata una pagina captcha, katana identifica il provider del captcha, lo risolve tramite un servizio esterno e continua il crawling.

Tipi di captcha supportati: reCAPTCHA v2, reCAPTCHA v3, reCAPTCHA Enterprise, Cloudflare Turnstile, hCaptcha

`-captcha-solver-provider`

Opzione per specificare il provider del risolutore di captcha. Attualmente supportato: capsolver.

`-captcha-solver-key`

Chiave API per il provider del risolutore di captcha.```console katana -u https://example.com -headless -csp capsolver -csk YOUR_API_KEY

Il provider e la chiave possono anche essere impostati tramite variabili d'ambiente:```console
export CAPTCHA_SOLVER_PROVIDER=capsolver
export CAPTCHA_SOLVER_KEY=YOUR_API_KEY
katana -u https://example.com -headless

Scope Control

La scansione può essere infinita se non limitata, pertanto katana offre diversi supporti per definire l'ambito di scansione.

`-field-scope`

Opzione più utile per definire l'ambito con un nome di campo predefinito, rdn è l'opzione predefinita per l'ambito del campo.

rdn - scansione limitata al nome di dominio radice e a tutti i sottodomini (es. *example.com) (predefinito)
fqdn - scansione limitata al sottodominio specificato (es. www.example.com o api.example.com)
dn - scansione limitata alla parola chiave del nome di dominio (es. example)```console katana -u https://tesla.com -fs dn

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

Per un controllo avanzato dell'ambito, è possibile utilizzare l'opzione `-cs` che include il supporto per le **regex**.```console
katana -u https://tesla.com -cs login

Per più regole in scope, è possibile passare input di file con stringa multilinea / regex.```bash $ cat in_scope.txt

[data-tip]:hover:after {
            content: attr(data-tip);
            position: absolute;
            font-size: 14px;
            background-color: #000;
            color: #fff;
            padding: 5px 10px;
            border-radius: 4px;
            white-space: nowrap;
            z-index: 1000;
            bottom: 125%;
            left: 50%;
            transform: translateX(-50%);
          }
        </style>
      </div>
    </div>
  </div>```console
katana -u https://tesla.com -cs in_scope.txt

`-crawl-out-scope`

Per definire cosa non scansionare, è possibile utilizzare l'opzione -cos che supporta anche input regex.```console katana -u https://tesla.com -cos logout

Per più regole fuori dall'ambito, è possibile passare file input con stringa multilinea / regex.```bash
$ cat out_of_scope.txt

/logout
/log_out

Please provide the chunk of content you want me to translate. (I need the actual Markdown text to proceed with the translation.)```console katana -u https://tesla.com -cos out_of_scope.txt

*`-no-scope`*
----

Katana è impostato per l'ambito `*.domain` di default, per disabilitare questa opzione si può usare `-ns` e anche per eseguire la scansione di internet.```console
katana -u https://tesla.com -ns

`-display-out-scope`

Per impostazione predefinita, quando viene utilizzata l'opzione scope, si applica anche ai link da visualizzare come output, pertanto gli URL esterni sono esclusi per impostazione predefinita e per sovrascrivere questo comportamento, l'opzione -do può essere utilizzata per visualizzare tutti gli URL esterni presenti nell'URL / Endpoint con ambito del target.``` katana -u https://tesla.com -do

Ecco tutte le opzioni CLI per il controllo dello scope -```console
katana -h scope

Flags:
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) (default "rdn")
   -ns, -no-scope                   disables host based default scope
   -do, -display-out-scope          display external endpoint from scoped crawling

Configurazione del Crawler

Katana offre molteplici opzioni per configurare e controllare la scansione come vogliamo.

`-depth`

Opzione per definire la profondità di follow degli URL durante la scansione: maggiore è la profondità, maggiore è il numero di endpoint scansionati e il tempo di scansione.``` katana -u https://tesla.com -d 5

*`-js-crawl`*
----

Opzione per abilitare il parsing dei file JavaScript + il crawling degli endpoint scoperti nei file JavaScript, disabilitata per impostazione predefinita.```
katana -u https://tesla.com -jc

`-crawl-duration`

Opzione per predefinire la durata del crawl, disabilitata per impostazione predefinita.``` katana -u https://tesla.com -ct 2

*`-known-files`*
----
Opzione per abilitare la scansione dei file `robots.txt` e `sitemap.xml`, disabilitata per impostazione predefinita.```
katana -u https://tesla.com -kf robotstxt,sitemapxml

`-automatic-form-fill`

Opzione per abilitare il riempimento automatico dei moduli per campi noti / sconosciuti, i valori dei campi noti possono essere personalizzati secondo necessità aggiornando il file di configurazione del modulo in $HOME/.config/katana/form-config.yaml.

Il riempimento automatico dei moduli è una funzionalità sperimentale.``` katana -u https://tesla.com -aff

I valori di configurazione del modulo supportano funzioni helper DSL per la generazione dinamica dei dati. Tutte le funzioni `rand_*` della libreria [projectdiscovery/dsl](https://github.com/projectdiscovery/dsl) sono disponibili:```yaml
# $HOME/.config/katana/form-config.yaml
email: "rand_email()"
phone: "rand_phone()"
placeholder: "rand_first_name()"
password: 'rand_base(16, "")'
color: "#e66465"

`-filter-similar`

Opzione per filtrare la scansione di URL simili normalizzando i segmenti di percorso variabili. Questo rileva ID, UUID, hash, date e altri valori dinamici, e apprende anche pattern ripetuti in fase di esecuzione. Ad esempio, /users/123 e /users/456 vengono trattati come lo stesso endpoint.``` katana -u https://tesla.com -fsu

La soglia di promozione (quanti valori distinti in una posizione del percorso prima che venga trattata come parametro) può essere regolata con `-fst`. Valori più bassi sono più aggressivi (meno URL scansionati), valori più alti sono più permissivi. Il valore predefinito è `10`.```
katana -u https://tesla.com -fsu -fst 5

`-max-domain-pages`

Opzione per limitare il numero di pagine indicizzate per dominio. Impedisce a un singolo dominio di consumare l'intero budget di scansione, utile per siti di grandi dimensioni o protezione da trappole per crawler.``` katana -u https://tesla.com -mdp 100

## Classificazione della Knowledge Base

Katana può arricchire i risultati della scansione con una **knowledge base** — classificazione basata su machine learning di ogni pagina scansionata, alimentata da [dit](https://github.com/HappyHackingSpace/dit). Quando attivata, ogni risposta viene classificata per **tipo di pagina** (ad es. `login`, `error`, `captcha`, `parked`) e vengono identificati eventuali moduli nella pagina, con il risultato allegato al campo `knowledgebase` dell'output JSONL. Questa funzionalità funziona su **tutti i motori** (standard e headless).

> **Nota**: Il modello di classificazione viene **scaricato automaticamente** al primo utilizzo in `~/.dit/model.json` (da [Hugging Face](https://huggingface.co/datasets/happyhackingspace/dit)). Si tratta di un costo una tantum per macchina — le esecuzioni successive riutilizzano il modello memorizzato nella cache. Non è richiesta l'installazione manuale di `dit`.

*`-knowledge-base`*
----

Abilita la classificazione della knowledge base. La classificazione del tipo di pagina e dei moduli viene aggiunta al campo `knowledgebase` di ogni risultato.```console
katana -u https://example.com -kb -jsonl

[*] ===== Calling Metasploit SSH Login Check for target: localhost port: 2222 =====
[*] ===== metasploit_fullname: auxiliary/scanner/ssh/ssh_login =====

[+] 127.0.0.1:2222 - Success: 'root:123456' 'uid=0(root) gid=0(root) groups=0(root) Linux parrot 5.9.0-1parrot1-amd64 #1 SMP Parrot 5.9.1-1parrot1 (2020-10-18) x86_64 GNU/Linux '
[...]

[*] ===== Saving metasploit output to: /home/kali/server.log =====
[*] ===== Calling Metasploit Enum Configs for target: localhost port: 2222 =====
[*] ===== metasploit_fullname: auxiliary/scanner/ssh/ssh_login =====

[+] 127.0.0.1:2222 - Success: 'root:123456' 'uid=0(root) gid=0(root) groups=0(root) Linux parrot 5.9.0-1parrot1-amd64 #1 SMP Parrot 5.9.1-1parrot1 (2020-10-18) x86_64 GNU/Linux '
[...]

[*] Command shell session 1 opened (127.0.0.1:4444 -> 127.0.0.1:33678) at 2024-04-12 11:27:13 -0400
[-] Unknown command: id.
[-] Unknown command: whoami.
[*] ===== Saving metasploit output to: /home/kali/enum_configs.log =====
``````json
{
  "timestamp": "...",
  "request": { "...": "..." },
  "response": {
    "...": "...",
    "knowledgebase": {
      "PageType": "login",
      "Forms": [{ "type": "login", "fields": { "username": "username or email", "password": "password" } }]
    }
  }
}

`-filter-page-type`

Filtra i risultati solo ai tipi di pagina specificati. Abilitando ciò si implica -kb (il classificatore viene inizializzato automaticamente).```console katana -u https://example.com -fpt login,error

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

Abilita l'estrattore di segreti nella knowledge base, esponendo i segreti rilevati (chiavi API, token, ecc.) sotto la chiave `secrets`. Aggiungi `-kb-validate-secrets` per convalidare i segreti rilevati rispetto al loro provider — nota che questo **invia chiamate API in tempo reale**.```console
katana -u https://example.com -kb-secrets

`-kb-endpoints`

Abilita l'estrattore di endpoint, che classifica le richieste come REST, GraphQL, SOAP o XHR sotto la chiave endpoints.```console katana -u https://example.com -kb-endpoints

## Crawling Autenticato

Il crawling autenticato implica l'inclusione di header personalizzati o cookie nelle richieste HTTP per accedere a risorse protette. Questi header forniscono informazioni di autenticazione o autorizzazione, permettendoti di scansionare contenuti o endpoint autenticati. Puoi specificare gli header direttamente nella riga di comando o fornirli come file con katana per eseguire il crawling autenticato.

> **Nota**: L'utente deve eseguire manualmente l'autenticazione ed esportare il cookie di sessione / header in un file da utilizzare con katana.

*`-headers`*
----

Opzione per aggiungere un header o cookie personalizzato alla richiesta. 
> Sintassi degli [header](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2) nella specifica HTTP

Ecco un esempio di aggiunta di un cookie alla richiesta:```
katana -u https://tesla.com -H 'Cookie: usrsess=AmljNrESo'

È anche possibile fornire header o cookie come file. Per esempio:``` $ cat cookie.txt

Cookie: PHPSESSIONID=XXXXXXXXX X-API-KEY: XXXXX TOKEN=XX

1. **Scegli un paese di destinazione** per il desktop remoto. Questo è il paese il cui IP verrà utilizzato dal desktop remoto.
2. **Scegli un provider cloud**. Questo è il provider di infrastruttura che ospiterà il desktop remoto.
3. **Seleziona una configurazione del desktop remoto**. Scegli il sistema operativo e altri dettagli hardware.

- Google Cloud Platform, Azure (Beta) e AWS sono attualmente supportati.

- Per aggiungere un provider, invia una segnalazione (issue) o, meglio ancora, una PR. Aggiungere un provider è semplice. Vedi `infra/providers`.

Il desktop remoto è un [Windows Server 2016 Datacenter](https://azure.microsoft.com/en-us/updates/generally-available-windows-server-2016-datacenter-edition/) o [Ubuntu 20.04](https://releases.ubuntu.com/focal/) con:

> Un IP pubblico

> Tutte le porte aperte. (Questo è pericoloso in generale, ma l'istanza vive per un tempo molto breve, quindi uno scanner di porte è meno preoccupante. Inoltre, tutte le porte in ingresso sono aperte, ma per impostazione predefinita nessuna porta è in ascolto oltre a RDP o SSH.)

> Chiave SSH, non una password.

Il desktop remoto è completamente isolato dalla macchina locale dell'utente e tutti i log della macchina remota vengono distrutti quando la macchina remota viene distrutta.

### Località supportate

Ho scelto l'insieme di località in base a dove ho riscontrato una latenza accettabile del provider cloud 🐩.

Località attualmente supportate:

<table>
<tr>
<td valign="top">

Stati Uniti, Canada, Regno Unito, Germania, Paesi Bassi, Spagna, Singapore, Australia, Svizzera, India, Giappone, Corea, Brasile, Francia, Italia, Giacarta, Norvegia, Finlandia, Svezia, Taiwan, Hong Kong, Varsavia, Sudafrica

</td>
<td valign="top">```
katana -u https://tesla.com -H cookie.txt

Ci sono più opzioni da configurare quando necessario, ecco tutte le opzioni CLI relative alla configurazione -```console katana -h config

Flags: 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 -ct, -crawl-duration int maximum duration to crawl the target for -kf, -known-files string enable crawling of known files (all,robotstxt,sitemapxml) -mrs, -max-response-size int maximum response size to read (default 9223372036854775807) -timeout int time to wait for request in seconds (default 10) -aff, -automatic-form-fill enable automatic form filling (experimental) -fx, -form-extraction enable extraction of form, input, textarea & select elements -retry int number of times to retry the request (default 1) -proxy string http/socks5 proxy to use -H, -headers string[] custom header/cookie to include in request -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) -mdp, -max-domain-pages int maximum number of pages to crawl per domain (default unlimited)

### Connessione a una Sessione del Browser Attiva

Katana può anche connettersi a una sessione del browser attiva dove l'utente ha già effettuato l'accesso ed è autenticato, e utilizzarla per il crawling. L'unico requisito è avviare il browser con il debug remoto abilitato.

Ecco un esempio di avvio del browser Chrome con debug remoto abilitato e del suo utilizzo con Katana -

**passo 1) Per prima cosa, individua il percorso dell'eseguibile di Chrome**

| Sistema Operativo | Posizione Eseguibile Chromium | Posizione Eseguibile 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` |

**passo 2) Avvia Chrome con debug remoto abilitato e restituirà un URL websocket. Ad esempio, su macOS, puoi avviare Chrome con debug remoto abilitato usando il seguente comando** -```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

Ora accedi al sito web che vuoi scansionare e tieni il browser aperto.

step 3) Ora usa l'URL del websocket con katana per connetterti alla sessione attiva del browser e scansionare il sito web```console katana -headless -u https://tesla.com -cwu ws://127.0.0.1:9222/devtools/browser/c5316c9c-19d6-42dc-847a-41d1aeebf7d6 -no-incognito

> **Nota**: è possibile utilizzare l'opzione `-cdd` per specificare una directory dati personalizzata di Chrome per memorizzare dati del browser e cookie, ma ciò non salva i dati della sessione se il cookie è impostato solo su `Session` o scade dopo un certo tempo.

## Filtri

*`-field`*
----

> [!WARNING]
> Deprecato: utilizzare [**`-output-template`**](#-output-template) invece. Il flag field è ancora supportato per compatibilità all'indietro.

Katana è dotato di campi integrati che possono essere utilizzati per filtrare l'output per le informazioni desiderate. L'opzione `-f` può essere utilizzata per specificare uno qualsiasi dei campi disponibili.```
   -f, -field string  field to display in output (url,path,fqdn,rdn,rurl,qurl,qpath,file,key,value,kv,dir,udir)

Ecco una tabella con esempi di ogni campo e output previsto quando utilizzato:

Ecco un esempio di utilizzo dell'opzione field per visualizzare solo tutti gli URL con parametro di query al loro interno -``` katana -u https://tesla.com -f qurl -silent

https://shop.tesla.com/en_au?redirect=no https://shop.tesla.com/en_nz?redirect=no https://shop.tesla.com/product/men_s-raven-lightweight-zip-up-bomber-jacket?sku=1740250-00-A https://shop.tesla.com/product/tesla-shop-gift-card?sku=1767247-00-A https://shop.tesla.com/product/men_s-chill-crew-neck-sweatshirt?sku=1740176-00-A https://www.tesla.com/about?redirect=no https://www.tesla.com/about/legal?redirect=no https://www.tesla.com/findus/list?redirect=no

### Campi personalizzati

Puoi creare campi personalizzati per estrarre e memorizzare informazioni specifiche dalle risposte delle pagine utilizzando regole regex. Questi campi personalizzati vengono definiti tramite un file di configurazione YAML e caricati dalla posizione predefinita `$HOME/.config/katana/field-config.yaml`. In alternativa, puoi usare l'opzione `-flc` per caricare un file di configurazione dei campi personalizzati da una posizione diversa.
Ecco un esempio di campo personalizzato.```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}'

Quando si definiscono campi personalizzati, sono supportati i seguenti attributi:

name (required)

Il valore dell'attributo name viene utilizzato come valore dell'opzione cli -field.

type (required)

Il tipo di attributo personalizzato, attualmente opzione supportata - regex

part (optional)

La parte della risposta da cui estrarre le informazioni. Il valore predefinito è response, che include sia l'intestazione che il corpo. Altri possibili valori sono header e body.

group (optional)

Puoi usare questo attributo per selezionare un gruppo specifico corrispondente nella regex, ad esempio: group: 1

Esecuzione di katana utilizzando campi personalizzati:```console

katana -u https://tesla.com -f email,phone

*`-store-field`*
---

Per completare l'opzione `field`, utile per filtrare l'output in fase di esecuzione, esiste l'opzione `-sf, -store-fields` che funziona esattamente come l'opzione field, tranne che invece di filtrare, memorizza tutte le informazioni su disco nella directory `katana_field` ordinate per URL target. Usa `-sfd` o `-store-field-dir` per archiviare i dati in una posizione diversa.```
katana -u https://tesla.com -sf key,fqdn,qurl -silent

Please provide the Markdown content to translate.```bash $ ls katana_field/

https_www.tesla.com_fqdn.txt https_www.tesla.com_key.txt https_www.tesla.com_qurl.txt

L'opzione `-store-field` può essere utile per raccogliere informazioni utili a costruire una wordlist mirata per vari scopi, tra cui:

- Identificare i parametri più comunemente utilizzati
- Scoprire i percorsi utilizzati più di frequente
- Trovare i file più comuni
- Identificare sottodomini correlati o sconosciuti

### Filtri Katana

*`-extension-match`*
---

L'output della scansione può essere facilmente filtrato per una specifica estensione usando l'opzione `-em` per visualizzare solo l'output contenente l'estensione data.```
katana -u https://tesla.com -silent -em js,jsp,json

Usa il valore speciale none per includere anche gli URL senza estensione di file nell'output:``` katana -u https://tesla.com -silent -em js,jsp,json,none

*`-extension-filter`*
---

L'output della scansione può essere facilmente filtrato per una specifica estensione utilizzando l'opzione `-ef` che garantisce di rimuovere tutti gli URL contenenti l'estensione data.```
katana -u https://tesla.com -silent -ef css,txt,md

`-no-default-ext-filter`

Katana filtra diverse estensioni per impostazione predefinita. Questo può essere disabilitato con l'opzione -ndef.``` katana -u https://tesla.com -silent -ndef

*`-match-regex`*
---
The `-match-regex` or `-mr` flag ti consente di filtrare gli URL di output utilizzando espressioni regolari. Quando si utilizza questo flag, solo gli URL che corrispondono all'espressione regolare specificata verranno stampati nell'output.```
katana -u https://tesla.com -mr 'https://shop\.tesla\.com/*' -silent

`-filter-regex`

Il flag -filter-regex o -fr ti permette di filtrare gli URL di output utilizzando espressioni regolari. Quando usi questo flag, verranno saltati gli URL che corrispondono all'espressione regolare specificata.``` katana -u https://tesla.com -fr 'https://www\.tesla\.com/*' -silent

### Filtraggio Avanzato

Katana supporta espressioni basate su DSL per funzionalità avanzate di matching e filtraggio:

- Per cercare corrispondenze di endpoint con codice di stato 200:```shell
katana -u https://www.hackerone.com -mdc 'status_code == 200'

Per abbinare gli endpoint che contengono "default" e hanno un codice di stato diverso da 403:```shell katana -u https://www.hackerone.com -mdc 'contains(endpoint, "default") && status_code != 403'

- Per abbinare gli endpoint con le tecnologie PHP:```shell
katana -u https://www.hackerone.com -mdc 'contains(to_lower(technologies), "php")'

Per filtrare gli endpoint in esecuzione su Cloudflare:```shell katana -u https://www.hackerone.com -fdc 'contains(to_lower(technologies), "cloudflare")'

Le funzioni DSL possono essere applicate a qualsiasi chiave nell'output jsonl. Per maggiori informazioni sulle funzioni DSL disponibili, visita il [progetto dsl](https://github.com/projectdiscovery/dsl).

Ecco ulteriori opzioni di filtro -```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

Limite di Velocità

È facile essere bloccati/bannati durante il crawling se non si seguono i limiti dei siti web target, katana offre molteplici opzioni per regolare il crawling per andare veloci o lenti quanto desideriamo.

`-delay`

opzione per introdurre un ritardo in secondi tra ogni nuova richiesta che katana effettua durante il crawling, disabilitato per impostazione predefinita.``` katana -u https://tesla.com -delay 20

*`-concurrency`*
-----
opzione per controllare il numero di URL per target da recuperare contemporaneamente.```
katana -u https://tesla.com -c 20

`-parallelism`

opzione per definire il numero di target da elaborare contemporaneamente dall'input della lista.``` katana -u https://tesla.com -p 20

*`-rate-limit`*
-----
Massimo di richieste al secondo, applicato globalmente su tutti gli host.```
katana -u https://tesla.com -rl 100

`-rate-limit-minute`

Massimo di richieste al minuto, applicato globalmente su tutti gli host.``` katana -u https://tesla.com -rlm 500

*`-host-rate-limit`*
-----
Massimo numero di richieste al secondo per host. Ogni host ha il proprio bucket di limitazione della velocità, quindi un host lento non rallenterà quelli veloci. Sostituisce il limite di velocità globale quando impostato. Katana effettua anche un backoff automatico con ritardo esponenziale e jitter quando un host restituisce 429 o 503.```console
katana -u https://tesla.com -hrl 50

`-host-rate-limit-minute`

Massimo di richieste al minuto per host.```console katana -u https://tesla.com -hrlm 200

Ecco tutte le opzioni CLI lunghe/corte per il controllo del limite di frequenza -```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

Katana supporta sia l'output su file in formato testo semplice che in JSON, il quale include informazioni aggiuntive come il nome di source, tag e attribute per correlare l'endpoint scoperto.

`-output`

Per impostazione predefinita, katana produce gli endpoint scansionati in formato testo semplice. I risultati possono essere scritti in un file utilizzando l'opzione -output.```console katana -u https://example.com -no-scope -output example_endpoints.txt

*`-output-template`*
---

L'opzione `-output-template` ti permette di personalizzare il formato di output utilizzando un template, offrendo flessibilità nella definizione della struttura dell'output. Questa opzione sostituisce il flag `-field` (deprecato) per filtrare l'output. Invece di basarsi su campi predefiniti, puoi specificare un template personalizzato direttamente nella riga di comando per controllare come vengono presentati i dati estratti.

Esempio di utilizzo dell'opzione `-output-template`:

``````sh
katana -u https://example.com -output-template '{{email}} - {{url}}'

In questo esempio, email rappresenta un campo personalizzato che estrae e mostra gli indirizzi email trovati nella fonte url.

[!NOTE] Se un campo specificato non esiste o non contiene un valore, sarà semplicemente omesso dall'output.

Questa opzione può strutturare efficacemente l'output in modo da adattarsi al meglio al tuo caso d'uso, rendendo l'estrazione dei dati più intuitiva e personalizzabile.

-jsonl ---```console katana -u https://example.com -jsonl | jq .

.-```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"
  }
}

`-store-response`

L'opzione -store-response consente di scrivere tutte le richieste e risposte degli endpoint scansionati in un file di testo. Quando questa opzione viene utilizzata, i file di testo contenenti la richiesta e la risposta verranno scritti nella directory katana_response. Se si desidera specificare una directory personalizzata, è possibile utilizzare l'opzione -store-response-dir.```console katana -u https://example.com -no-scope -store-response

Please provide the Markdown content to translate.```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)

Nota:

L'opzione -store-response non è supportata in modalità -headless.

`-list-output-fields`

Il flag -list-output-fields o -lof mostra tutti i campi disponibili che possono essere utilizzati nel formato di output JSONL. Ciò è utile per capire quali dati sono disponibili quando si utilizzano template di output personalizzati o quando si escludono campi specifici.```console katana -lof

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

Il flag `-exclude-output-fields` o `-eof` consente di escludere campi specifici dall'output JSONL. Ciò è utile per ridurre le dimensioni dell'output o concentrarsi su dati specifici rimuovendo campi indesiderati.```console
katana -u https://example.com -jsonl -eof raw,body

Ecco ulteriori opzioni CLI relative all'output -```console katana -h output

OUTPUT: -o, -output string file to write output to -sr, -store-response store http requests/responses -srd, -store-response-dir string store http requests/responses to custom directory -lof, -list-output-fields list available fields for jsonl output format -eof, -exclude-output-fields exclude fields from jsonl output -j, -json write output in JSON Lines format -nc, -no-color disable output content coloring (ANSI escape codes) -silent display output only -v, -verbose display verbose output -version display project version

## Katana come libreria
`katana` può essere usato come libreria creando un'istanza della struct `Option` e popolandola con le stesse opzioni che verrebbero specificate tramite CLI. Usando le opzioni puoi creare `crawlerOptions` e quindi un `crawler` standard o ibrido.
Il metodo `crawler.Crawl` dovrebbe essere chiamato per eseguire la scansione dell'input.```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())
	}
}

Segnalazione di problemi e richieste di funzionalità

Per mantenere il tracciamento dei problemi e migliorare l'efficienza della triage:

Tutte le segnalazioni iniziano come Discussioni GitHub

Segnalazioni di bug → Avvia una discussione Q&A
Richieste di funzionalità → Avvia una discussione Idee
Domande → Avvia una discussione Q&A

Perché iniziare con le Discussioni?

La comunità può aiutare con domande rapide e risoluzione dei problemi
Migliore triage - bug/funzionalità confermati diventano problemi tracciati
Tracker dei problemi più pulito - focus solo su elementi attuabili

I manutentori convertiranno le discussioni in problemi quando appropriato dopo una corretta revisione.

katana è realizzato con ❤️ dal team projectdiscovery e distribuito sotto Licenza MIT.

`heuristic`	(predefinito) Attesa intelligente che si adatta al comportamento della pagina - attende l'evento di caricamento, l'inattività della rete e la stabilità del DOM
`load`	Attende solo l'evento di caricamento del browser
`domcontentloaded`	Attende l'evento DOMContentLoaded più un tempo aggiuntivo (configurabile tramite `-dwt`) per il rendering JavaScript
`networkidle`	Attende che l'attività di rete si fermi
`none`	Nessuna attesa - ritorna immediatamente dopo l'inizio della navigazione
katana -u https://tesla.com -headless -pls domcontentloaded

`url`	URL Endpoint	`https://admin.projectdiscovery.io/admin/login?user=admin&password=admin`
`qurl`	URL inclusa query param	`https://admin.projectdiscovery.io/admin/login.php?user=admin&password=admin`
`qpath`	Percorso inclusa query param	`/login?user=admin&password=admin`
`path`	Percorso URL	`https://admin.projectdiscovery.io/admin/login`
`fqdn`	Nome di dominio completo	`admin.projectdiscovery.io`
`rdn`	Nome di dominio radice	`projectdiscovery.io`
`rurl`	URL radice	`https://admin.projectdiscovery.io`
`ufile`	URL con file	`https://admin.projectdiscovery.io/login.js`
`file`	Nome file nell'URL	`login.php`
`key`	Chiavi dei parametri nell'URL	`user,password`
`value`	Valori dei parametri nell'URL	`admin,admin`
`kv`	Chiavi=Valori nell'URL	`user=admin&password=admin`
`dir`	Nome directory URL	`/admin/`
`udir`	URL con directory	`https://admin.projectdiscovery.io/admin/`

katana

Più Popolari

Un framework di crawling e spidering di nuova generazione

Funzionalità

Installazione

Utilizzo```console

Esecuzione di Katana

Input per katana

Input URL```sh

Input elenco```bash

STDIN (Input tramite pipe)```sh

Docker

-no-sandbox

-page-load-strategy

Risoluzione Captcha

-captcha-solver-provider

-captcha-solver-key

Scope Control

-field-scope

-crawl-out-scope

-display-out-scope

Configurazione del Crawler

-depth

-crawl-duration

-automatic-form-fill

-filter-similar

-max-domain-pages

-filter-page-type

-kb-endpoints