**Mais opções para instalar / executar o katana-**

<details>
  <summary>Docker</summary>

> Para instalar / atualizar o docker para a tag latest -```sh
docker pull projectdiscovery/katana:latest

> Para executar katana em modo headless usando docker -```sh
docker run projectdiscovery/katana:latest -u https://tesla.com -system-chrome -headless

Isso exibirá ajuda para a ferramenta. Aqui estão todas as opções que ela suporta.```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

#### Entrada de múltiplas URLs (separadas por vírgula)```sh
katana -u https://tesla.com,https://google.com

Extrair um arquivo .bin do GENEActiv sem precisar do software GENEActiv PC ou de uma conexão USB (via conversão de arquivo)

Ações Disponíveis:

- Extrair dados de arquivos .bin do GENEActiv, incluindo:
  - Recuperar campos de metadados (ex., Versão do Firmware do Dispositivo, Data de Extração, Dados de Calibração)
  - Analisar e gerar dados no formato **Pandas DataFrame**
  - Gerar valores de contagem **ActiGraph count** usando o pacote **GGIR** comumente utilizado
  - Relatar erros de dados, destacando anomalias (ex., temperaturas excessivas, tempo de não uso)
  - Saída autodocumentada via resumo em markdown (saída opcional)"```
katana -list url_list.txt

O **conceito central** é que você pode rapidamente```sh
cat domains | httpx | katana

  projectdiscovery.io

## Modo de Rastreamento

### Modo Padrão

A modalidade de rastreamento padrão utiliza a biblioteca http padrão do Go nos bastidores para lidar com requisições/respostas HTTP. Esta modalidade é muito mais rápida, pois não tem a sobrecarga do navegador. Ainda assim, analisa o corpo das respostas HTTP como ele é, sem qualquer renderização de JavaScript ou DOM, potencialmente perdendo endpoints renderizados pós-DOM ou chamadas assíncronas de endpoints que podem ocorrer em aplicações web complexas dependendo, por exemplo, de eventos específicos do navegador.

### Modo Headless

O modo headless conecta chamadas headless internas para lidar com requisições/respostas HTTP diretamente no contexto do navegador. Isso oferece duas vantagens:
- A impressão digital HTTP (TLS e user agent) identifica totalmente o cliente como um navegador legítimo
- Melhor cobertura, pois os endpoints são descobertos analisando a resposta bruta padrão, como na modalidade anterior, e também a renderizada pelo navegador com JavaScript ativado.

O rastreamento headless é opcional e pode ser ativado usando a opção `-headless`.

Aqui estão outras opções de 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-incognito`*
----

Executa o navegador Chrome em modo headless sem o modo anônimo, útil ao utilizar o navegador local.```console
katana -u https://tesla.com -headless -no-incognito

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

Quando estiver realizando crawling em modo headless, opções adicionais do Chrome podem ser especificadas usando `-headless-options`, por exemplo -```console
katana -u https://tesla.com -headless -system-chrome -headless-options --disable-gpu,proxy-server=http://127.0.0.1:8080

A estratégia `domcontentloaded` é particularmente útil para Single Page Applications (SPAs) que nunca completam o carregamento totalmente devido a pedidos contínuos em segundo plano (websockets, polling, etc.).

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

Quando se utiliza a estratégia de carregamento de página `domcontentloaded`, esta opção especifica quantos segundos esperar após o evento DOMContentLoaded ser acionado. Isso dá tempo para o JavaScript renderizar elementos interativos. O padrão é 5 segundos.```console
katana -u https://tesla.com -headless -pls domcontentloaded -dwt 10

O provedor e a chave também podem ser definidos via variáveis de ambiente:```console
export CAPTCHA_SOLVER_PROVIDER=capsolver
export CAPTCHA_SOLVER_KEY=YOUR_API_KEY
katana -u https://example.com -headless

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

Para controle avançado de escopo, a opção `-cs` pode ser usada que vem com suporte a **regex**.```console
katana -u https://tesla.com -cs login

### Instantâneos Extraídos

![ext](https://raw.githubusercontent.com/projectdiscovery/katana/dev/assets/image/ext.png)  
Os instantâneos extraídos estarão no diretório "VOL-[volume-id]-[datetime]" numerados cronologicamente.  
Formato de data e hora: yyyyMMddHHmm  
Para analisar com precisão os atributos de tempo, exporte no seu fuso horário local.

### Relatórios

![rpt](https://raw.githubusercontent.com/projectdiscovery/katana/dev/assets/image/rpt.png)  
Algumas informações do volume geradas automaticamente.

### Automação de Análise

Ferramentas WinMD: [WinMDCollect](https://github.com/projectdiscovery/katana/blob/dev/tools/WinMDCollect)  
Ferramentas de análise de saída WinMD (scripts Bash): [OutputAnalysis](https://github.com/projectdiscovery/katana/blob/dev/tools/OutputAnalysis)```console
katana -u https://tesla.com -cs in_scope.txt

Para múltiplas regras fora do escopo, entrada de arquivo com string multilinha / regex pode ser passada.```bash
$ cat out_of_scope.txt

/logout
/log_out

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

Katana tem como escopo padrão `*.domain`; para desabilitar isso, a opção `-ns` pode ser usada e também para rastrear a internet.```console
katana -u https://tesla.com -ns

Aqui estão todas as opções de CLI para o controle de escopo -```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

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

Opção para ativar a análise de arquivos JavaScript + rastreamento dos endpoints descobertos em arquivos JavaScript, desabilitada por padrão.```
katana -u https://tesla.com -jc

*`-known-files`*
----
Opção para ativar a varredura dos arquivos `robots.txt` e `sitemap.xml`, desativada por padrão.```
katana -u https://tesla.com -kf robotstxt,sitemapxml

Os valores de configuração de formulário suportam funções auxiliares DSL para geração dinâmica de dados. Todas as funções `rand_*` da biblioteca [projectdiscovery/dsl](https://github.com/projectdiscovery/dsl) estão disponíveis:```yaml
# $HOME/.config/katana/form-config.yaml
email: "rand_email()"
phone: "rand_phone()"
placeholder: "rand_first_name()"
password: 'rand_base(16, "")'
color: "#e66465"

O limite de promoção (quantos valores distintos em uma posição de caminho antes de ser tratado como parâmetro) pode ser ajustado com `-fst`. Valores mais baixos são mais agressivos (menos URLs rastreados), valores mais altos são mais permissivos. O padrão é `10`.```
katana -u https://tesla.com -fsu -fst 5

## Classificação da Base de Conhecimento

Katana pode enriquecer resultados de rastreamento com uma **base de conhecimento** — classificação por aprendizado de máquina de cada página rastreada, alimentada por [dit](https://github.com/HappyHackingSpace/dit). Quando ativada, cada resposta é classificada por **tipo de página** (ex.: `login`, `error`, `captcha`, `parked`) e quaisquer formulários na página são identificados, com o resultado anexado ao campo `knowledgebase` da saída JSONL. Isso funciona em **todos os mecanismos** (padrão e headless).

> **Nota**: O modelo de classificação é **baixado automaticamente** na primeira utilização para `~/.dit/model.json` (do [Hugging Face](https://huggingface.co/datasets/happyhackingspace/dit)). Isso é um custo único, por máquina — execuções subsequentes reutilizam o modelo em cache. Nenhuma instalação manual de `dit` é necessária.

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

Ativa a classificação da base de conhecimento. A classificação de tipo de página e de formulários é adicionada ao campo `knowledgebase` de cada resultado.```console
katana -u https://example.com -kb -jsonl

*`-filter-page-type`*
----

Filtrar resultados apenas para o(s) tipo(s) de página fornecido(s). Ativar isso implica `-kb` (o classificador é inicializado automaticamente).```console
katana -u https://example.com -fpt login,error

*`-kb-endpoints`*
----

Habilita o extrator de endpoints, que classifica requisições como REST, GraphQL, SOAP ou XHR sob a chave `endpoints`.```console
katana -u https://example.com -kb-endpoints

Também é possível fornecer cabeçalhos ou cookies como um arquivo. Por exemplo:```
$ cat cookie.txt

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

Existem mais opções para configurar quando necessário, aqui estão todas as opções de CLI relacionadas à configuração -```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)

> Agora faça login no site que deseja rastrear e mantenha o navegador aberto.

**passo 3) Agora use a URL do websocket com o katana para se conectar à sessão ativa do navegador e rastrear o site**```console
katana -headless -u https://tesla.com -cwu ws://127.0.0.1:9222/devtools/browser/c5316c9c-19d6-42dc-847a-41d1aeebf7d6 -no-incognito

Aqui está uma tabela com exemplos de cada campo e saída esperada quando usado - 

| FIELD   | DESCRIPTION                 | EXAMPLE                                                      |
| ------- | --------------------------- | ------------------------------------------------------------ |
| `url`   | Endpoint URL                | `https://admin.projectdiscovery.io/admin/login?user=admin&password=admin` |
| `qurl`  | URL incluindo parâmetro de consulta | `https://admin.projectdiscovery.io/admin/login.php?user=admin&password=admin` |
| `qpath` | Caminho incluindo parâmetro de consulta | `/login?user=admin&password=admin`                           |
| `path`  | Caminho da URL              | `https://admin.projectdiscovery.io/admin/login`              |
| `fqdn`  | Nome de domínio totalmente qualificado | `admin.projectdiscovery.io`                                  |
| `rdn`   | Nome do domínio raiz        | `projectdiscovery.io`                                        |
| `rurl`  | URL raiz                    | `https://admin.projectdiscovery.io`                          |
| `ufile` | URL com arquivo             | `https://admin.projectdiscovery.io/login.js`                 |
| `file`  | Nome do arquivo na URL      | `login.php`                                                  |
| `key`   | Chaves de parâmetro na URL  | `user,password`                                              |
| `value` | Valores de parâmetro na URL | `admin,admin`                                                |
| `kv`    | Chaves=Valores na URL       | `user=admin&password=admin`                                  |
| `dir`   | Nome do diretório da URL    | `/admin/`                                                    |
| `udir`  | URL com diretório           | `https://admin.projectdiscovery.io/admin/`                   |

Aqui está um exemplo de uso da opção field para exibir apenas todas as URLs com parâmetro de consulta -```
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

Ao definir campos personalizados, os seguintes atributos são suportados:

- **name** (obrigatório)

> O valor do atributo **name** é usado como o valor da opção `-field` na CLI.

- **type** (obrigatório)

> O tipo de atributo personalizado, opção atualmente suportada - `regex` 

- **part** (opcional)

> A parte da resposta da qual extrair as informações. O valor padrão é `response`, que inclui tanto o cabeçalho quanto o corpo. Outros valores possíveis são `header` e `body`.

- group (opcional)

> Você pode usar este atributo para selecionar um grupo específico correspondente na regex, por exemplo: `group: 1`

#### Executando katana usando campo personalizado:```console
katana -u https://tesla.com -f email,phone

``````bash
$ ls katana_field/

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

Use o valor especial `none` para também incluir URLs sem uma extensão de arquivo na saída:```
katana -u https://tesla.com -silent -em js,jsp,json,none

*`-no-default-ext-filter`*
---

Katana filtra várias extensões por padrão. Isso pode ser desabilitado com a opção `-ndef`.```
katana -u https://tesla.com -silent -ndef

*`-filter-regex`*
---
A flag `-filter-regex` ou `-fr` permite filtrar URLs de saída utilizando expressões regulares. Ao utilizar esta flag, serão ignoradas as URLs que correspondam à expressão regular especificada.```
katana -u https://tesla.com -fr 'https://www\.tesla\.com/*' -silent

- Para corresponder endpoints que contenham "default" e tenham um código de status diferente de 403:```shell
katana -u https://www.hackerone.com -mdc 'contains(endpoint, "default") && status_code != 403'

- Para filtrar endpoints que estão rodando no Cloudflare:```shell
katana -u https://www.hackerone.com -fdc 'contains(to_lower(technologies), "cloudflare")'

## Limite de Taxa

É fácil ser bloqueado/banido durante o crawling se não seguir os limites dos sites alvo, o katana vem com múltiplas opções para ajustar o crawl para ir tão rápido/lento quanto quisermos.

*`-delay`*
-----```
katana -u https://tesla.com -delay 20

*`-parallelism`*
-----
opção para definir o número de alvos a processar ao mesmo tempo a partir da lista de entrada.```
katana -u https://tesla.com -p 20

*`-rate-limit-minute`*
-----
Máximo de requisições por minuto, aplicado globalmente em todos os hosts.```
katana -u https://tesla.com -rlm 500

*`-host-rate-limit-minute`*
-----
Máximo de requisições por minuto por host.```console
katana -u https://tesla.com -hrlm 200

## Saída

Katana suporta saída em arquivo tanto em formato de texto simples quanto JSON, que inclui informações adicionais como nome de `source`, `tag` e `attribute` para correlacionar o endpoint descoberto.

*`-output`*
---

Por padrão, katana gera os endpoints rastreados em formato de texto simples. Os resultados podem ser escritos em um arquivo usando a opção -output.```console
katana -u https://example.com -no-scope -output example_endpoints.txt

Neste exemplo, `email` representa um [campo personalizado](#custom-fields) que extrai e exibe endereços de e-mail encontrados na origem `url`.

> [!NOTE]
> Se um campo especificado não existir ou não contiver um valor, ele será simplesmente omitido da saída.

Esta opção pode estruturar efetivamente a saída da maneira que melhor se adequa ao seu caso de uso, tornando a extração de dados mais intuitiva e personalizável.

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

*`-store-response`*
----

A opção `-store-response` permite escrever todas as requisições e respostas de endpoints rastreados em um arquivo de texto. Quando esta opção é usada, arquivos de texto contendo a requisição e resposta serão escritos no diretório **katana_response**. Se você desejar especificar um diretório personalizado, pode usar a opção `-store-response-dir`.```console
katana -u https://example.com -no-scope -store-response

**Nota:**

*A opção `-store-response` não é suportada no modo `-headless`.*

*`-list-output-fields`*
----

A flag `-list-output-fields` ou `-lof` exibe todos os campos disponíveis que podem ser usados no formato de saída JSONL. Isso é útil para entender quais dados estão disponíveis ao usar modelos de saída personalizados ou ao excluir campos específicos.```console
katana -lof

Aqui estão opções adicionais de CLI relacionadas à saída -```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

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

## Relatar Problemas & Solicitações de Funcionalidades

Para manter o rastreamento de problemas e melhorar a eficiência da triagem:

**Todos os relatórios começam como [Discussões no GitHub](https://github.com/projectdiscovery/katana/discussions)**

- **Relatórios de Bugs** → [Iniciar uma Discussão de Perguntas e Respostas](https://github.com/projectdiscovery/katana/discussions/new?category=q-a)
- **Solicitações de Funcionalidades** → [Iniciar uma Discussão de Ideias](https://github.com/projectdiscovery/katana/discussions/new?category=ideas)  
- **Perguntas** → [Iniciar uma Discussão de Perguntas e Respostas](https://github.com/projectdiscovery/katana/discussions/new?category=q-a)

**Por que Discussões Primeiro?**
- **A comunidade pode ajudar** com perguntas rápidas e solução de problemas
- **Melhor triagem** - bugs/funcionalidades confirmados se tornam problemas rastreados  
- **Rastreador de problemas mais limpo** - foco apenas em itens acionáveis

Os mantenedores converterão discussões em problemas quando apropriado, após revisão adequada.

--------

<div align="center">

katana é feito com ❤️ pela equipe [projectdiscovery](https://projectdiscovery.io) e distribuído sob [Licença MIT](https://github.com/projectdiscovery/katana/blob/dev/LICENSE.md).


<a href="https://discord.gg/projectdiscovery"><img src="https://assets.kitploit.com/production/public/readmes/5826/d0624f94cb9ea6401be5a089bb694bc963c47fa82aa3b758c893e3b0bbfdf663.png" width="300" alt="Join Discord"></a>

</div>