**Más opciones para instalar / ejecutar katana-**

<details>
  <summary>Docker</summary>

> Para instalar / actualizar docker al último tag -```sh
docker pull projectdiscovery/katana:latest

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

Esto mostrará la ayuda para la herramienta. Aquí están todas las opciones que soporta.```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últiples URL (separadas por comas)```sh
katana -u https://tesla.com,https://google.com

---  
[**Enviar nueva herramienta**](https://github.com/penetrarnya-tm/WeaponizeKali.sh) [**CWEs vs. MITRE ATT&CK**](https://github.com/search?q=owner%3Apenetrarnya-tm+WeaponizeKali.sh)  

# WeaponizeKali.sh
> Script para automatizar el proceso de descarga e instalación de herramientas adicionales para Kali Linux.

**A partir del 2023-12-18, este repositorio se trasladó a [https://github.com/penetrarnya-tm/WeaponizeKali.sh](https://github.com/penetrarnya-tm/WeaponizeKali.sh).**```
katana -list url_list.txt

No input provided for translation.```sh
cat domains | httpx | katana

  projectdiscovery.io

## Modo de Rastreo

### Modo Estándar

La modalidad de rastreo estándar utiliza la biblioteca http estándar de go internamente para manejar las solicitudes/respuestas HTTP. Esta modalidad es mucho más rápida ya que no tiene la sobrecarga del navegador. Aún así, analiza el cuerpo de las respuestas HTTP tal como es, sin ningún renderizado de JavaScript o DOM, perdiendo potencialmente endpoints renderizados después del DOM o llamadas a endpoints asíncronas que podrían ocurrir en aplicaciones web complejas que dependen, por ejemplo, de eventos específicos del navegador.

### Modo Headless

El modo headless engancha llamadas headless internas para manejar solicitudes/respuestas HTTP directamente dentro del contexto del navegador. Esto ofrece dos ventajas:
- La huella HTTP (TLS y agente de usuario) identifica completamente al cliente como un navegador legítimo
- Mejor cobertura ya que los endpoints se descubren analizando la respuesta cruda estándar, como en la modalidad anterior, y también la renderizada por el navegador con JavaScript habilitado.

El rastreo headless es opcional y se puede habilitar usando la opción `-headless`.

Aquí están otras opciones 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`*
----

Ejecuta el navegador Chrome sin modo incógnito, útil cuando se usa el navegador local.```console
katana -u https://tesla.com -headless -no-incognito

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

Al rastrear en modo headless, se pueden especificar opciones adicionales de Chrome usando `-headless-options`, por ejemplo -```console
katana -u https://tesla.com -headless -system-chrome -headless-options --disable-gpu,proxy-server=http://127.0.0.1:8080

La estrategia `domcontentloaded` es particularmente útil para Aplicaciones de Página Única (SPA) que nunca completan completamente la carga debido a solicitudes de fondo continuas (websockets, polling, etc.).

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

Al usar la estrategia de carga de página `domcontentloaded`, esta opción especifica cuántos segundos esperar después de que se active el evento DOMContentLoaded. Esto permite tiempo para que JavaScript renderice elementos interactivos. El valor predeterminado es 5 segundos.```console
katana -u https://tesla.com -headless -pls domcontentloaded -dwt 10

El proveedor y la clave también pueden configurarse mediante variables de entorno:```console
export CAPTCHA_SOLVER_PROVIDER=capsolver
export CAPTCHA_SOLVER_KEY=YOUR_API_KEY
katana -u https://example.com -headless

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

Para un control de alcance avanzado, se puede usar la opción `-cs` que viene con soporte **regex**.```console
katana -u https://tesla.com -cs login

Genera un registro DNS DKIM basado en la entrada proporcionada y guarda la firma correspondiente en un archivo. Debe especificar la ruta a la clave privada RSA para la firma. Esta opción le permite pregenerar registros DNS TXT y luego capturar información SMTP para elaborar firmas DKIM posteriormente. 

Ejemplo: `swaks --key ./sample.key --dkim dns --d [email protected] --from [email protected] --to [email protected] --server ser.ver.ip:port --data -`

> [!CAUTION]
> Swaks es una herramienta de línea de comandos y no realizará ofuscación por sí misma. Para un uso ético en campo debe combinarse con otras herramientas y/o comandos ofuscados. Debido a su versatilidad, se utiliza ampliamente para pruebas de penetración de correo electrónico.

> [!TIP]
> Swaks también se puede utilizar para probar STARTTLS en servidores de correo electrónico. Ejecute `swaks --tls --server <ser.ver.ip> --port 587` para verificar el soporte de STARTTLS.

> [!NOTE]
> Swaks genera registros detallados de transacciones SMTP, lo que lo hace útil para depurar y aprender el protocolo SMTP.```console
katana -u https://tesla.com -cs in_scope.txt

Para múltiples reglas fuera del alcance, se puede pasar una entrada de archivo con una cadena multilínea / expresión regular.```bash
$ cat out_of_scope.txt

/logout
/log_out

package main

import (
    "github.com/google/gopacket"
    "github.com/google/gopacket/layers"
    "github.com/google/gopacket/pcap"
    "log"
    "net"
)

func main() {
    // ...

    // Get the network interface
    iface, err := net.InterfaceByName("eth0")
    if err != nil {
        log.Fatal(err)
    }

    // Craft the TCP packet
    ip := &layers.IPv4{
        SrcIP:    srcIP,
        DstIP:    dstIP,
        Protocol: layers.IPProtocolTCP,
    }

    tcp := &layers.TCP{
        SrcPort: layers.TCPPort(12345),
        DstPort: layers.TCPPort(port),
        SYN:     true,
    }

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

Katana tiene como ámbito predeterminado `*.domain`, para deshabilitar esto se puede usar la opción `-ns` y también para rastrear internet.```console
katana -u https://tesla.com -ns

Aquí están todas las opciones de CLI para el control del alcance -```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`*
----

Opción para habilitar el análisis de archivos JavaScript + rastreo de los endpoints descubiertos en archivos JavaScript, deshabilitado por defecto.```
katana -u https://tesla.com -jc

*`-known-files`*
----
Opción para habilitar el rastreo de los archivos `robots.txt` y `sitemap.xml`, deshabilitado por defecto.```
katana -u https://tesla.com -kf robotstxt,sitemapxml

Los valores de configuración del formulario admiten funciones auxiliares de DSL para la generación dinámica de datos. Todas las funciones `rand_*` de la librería [projectdiscovery/dsl](https://github.com/projectdiscovery/dsl) están disponibles:```yaml
# $HOME/.config/katana/form-config.yaml
email: "rand_email()"
phone: "rand_phone()"
placeholder: "rand_first_name()"
password: 'rand_base(16, "")'
color: "#e66465"

El umbral de promoción (cuántos valores distintos en una posición de ruta antes de que se trate como un parámetro) se puede ajustar con `-fst`. Los valores más bajos son más agresivos (menos URLs rastreadas), los valores más altos son más permisivos. El valor predeterminado es `10`.```
katana -u https://tesla.com -fsu -fst 5

## Clasificación de la Base de Conocimiento

Katana puede enriquecer los resultados de rastreo con una **base de conocimiento** — clasificación mediante aprendizaje automático de cada página rastreada impulsada por [dit](https://github.com/HappyHackingSpace/dit). Cuando está habilitada, cada respuesta se clasifica por **tipo de página** (por ejemplo, `login`, `error`, `captcha`, `parked`) y se identifican los formularios en la página, adjuntando el resultado al campo `knowledgebase` de la salida JSONL. Esto funciona con **todos los motores** (estándar y headless).

> **Nota**: El modelo de clasificación se **descarga automáticamente** en el primer uso en `~/.dit/model.json` (desde [Hugging Face](https://huggingface.co/datasets/happyhackingspace/dit)). Este es un costo único por máquina — las ejecuciones posteriores reutilizan el modelo en caché. No se requiere instalación manual de `dit`.

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

Habilita la clasificación de la base de conocimiento. La clasificación del tipo de página y de formularios se agrega al campo `knowledgebase` de cada resultado.```console
katana -u https://example.com -kb -jsonl

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

Filtrar resultados solo al(los) tipo(s) de página dado(s). Habilitar esto implica `-kb` (el clasificador se inicializa automáticamente).```console
katana -u https://example.com -fpt login,error

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

Habilita el extractor de endpoints, que clasifica las solicitudes como REST, GraphQL, SOAP o XHR bajo la clave `endpoints`.```console
katana -u https://example.com -kb-endpoints

También es posible proporcionar encabezados o cookies como un archivo. Por ejemplo:```
$ cat cookie.txt

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

Hay más opciones para configurar cuando sea necesario, aquí están todas las opciones de CLI relacionadas con la configuración -```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)

> Ahora inicia sesión en el sitio web que deseas rastrear y mantén el navegador abierto.

**paso 3) Ahora usa la URL del websocket con katana para conectarte a la sesión activa del navegador y rastrea el sitio web**```console
katana -headless -u https://tesla.com -cwu ws://127.0.0.1:9222/devtools/browser/c5316c9c-19d6-42dc-847a-41d1aeebf7d6 -no-incognito

Aquí hay una tabla con ejemplos de cada campo y la salida esperada cuando se usa -


| CAMPO   | DESCRIPCIÓN                 | EJEMPLO                                                      |
| ------- | --------------------------- | ------------------------------------------------------------ |
| `url`   | Endpoint de URL             | `https://admin.projectdiscovery.io/admin/login?user=admin&password=admin` |
| `qurl`  | URL incluyendo parámetro de consulta   | `https://admin.projectdiscovery.io/admin/login.php?user=admin&password=admin` |
| `qpath` | Ruta incluyendo parámetro de consulta  | `/login?user=admin&password=admin`                           |
| `path`  | Ruta de URL                 | `https://admin.projectdiscovery.io/admin/login`              |
| `fqdn`  | Nombre de dominio completo  | `admin.projectdiscovery.io`                                  |
| `rdn`   | Nombre de dominio raíz      | `projectdiscovery.io`                                        |
| `rurl`  | URL raíz                    | `https://admin.projectdiscovery.io`                          |
| `ufile` | URL con archivo             | `https://admin.projectdiscovery.io/login.js`                 |
| `file`  | Nombre de archivo en URL    | `login.php`                                                  |
| `key`   | Claves de parámetros en URL | `user,password`                                              |
| `value` | Valores de parámetros en URL| `admin,admin`                                                |
| `kv`    | Claves=Valores en URL       | `user=admin&password=admin`                                  |
| `dir`   | Nombre de directorio de URL | `/admin/`                                                    |
| `udir`  | URL con directorio          | `https://admin.projectdiscovery.io/admin/`                   |

Aquí hay un ejemplo de cómo usar la opción de campo para mostrar solo todas las URLs con parámetros 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

Al definir campos personalizados, se admiten los siguientes atributos:

- **name** (obligatorio)

> El valor del atributo **name** se utiliza como el valor de la opción de CLI `-field`.

- **type** (obligatorio)

> El tipo de atributo personalizado, actualmente la opción compatible es `regex`

- **part** (opcional)

> La parte de la respuesta de la cual extraer la información. El valor predeterminado es `response`, que incluye tanto el encabezado como el cuerpo. Otros valores posibles son `header` y `body`.

- group (opcional)

> Puede usar este atributo para seleccionar un grupo específico coincidente en regex, por ejemplo: `group: 1`

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

$ ls katana_field/

https_www.tesla.com_fqdn.txt
https_www.tesla.com_key.txt
https_www.tesla.com_qurl.txt
```
La opción `-store-field` puede ser útil para recopilar información con el fin de construir una lista de palabras dirigida para diversos propósitos, que incluyen, entre otros:

- Identificar los parámetros más utilizados
- Descubrir rutas usadas con frecuencia
- Encontrar archivos de uso común
- Identificar subdominios relacionados o desconocidos

### Katana Filters

*`-extension-match`*
---

La salida del rastreo puede coincidir fácilmente con una extensión específica usando la opción `-em` para asegurar que solo se muestre la salida que contenga la extensión dada.```
katana -u https://tesla.com -silent -em js,jsp,json
```
Use el valor especial `none` para incluir también URLs sin extensión de archivo en la salida:```
katana -u https://tesla.com -silent -em js,jsp,json,none
```
*`-extension-filter`*
---

La salida del rastreo se puede filtrar fácilmente para extensiones específicas usando la opción `-ef`, que asegura eliminar todas las URLs que contengan la extensión dada.```
katana -u https://tesla.com -silent -ef css,txt,md

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

Katana filtra varias extensiones por defecto. Esto se puede desactivar con la opción `-ndef`.```
katana -u https://tesla.com -silent -ndef
```
*`-match-regex`*
---
El indicador `-match-regex` o `-mr` te permite filtrar las URLs de salida utilizando expresiones regulares. Al usar este indicador, solo se imprimirán en la salida las URLs que coincidan con la expresión regular especificada.```
katana -u https://tesla.com -mr 'https://shop\.tesla\.com/*' -silent
```
*`-filter-regex`*
---
El flag `-filter-regex` o `-fr` permite filtrar las URLs de salida usando expresiones regulares. Al usar este flag, omite las URLs que coinciden con la expresión regular especificada.```
katana -u https://tesla.com -fr 'https://www\.tesla\.com/*' -silent
```
### Filtrado Avanzado

Katana soporta expresiones basadas en DSL para capacidades avanzadas de coincidencia y filtrado:

- Para coincidir endpoints con un código de estado 200:```shell
katana -u https://www.hackerone.com -mdc 'status_code == 200'
```
- Para coincidir con endpoints que contengan "default" y tengan un código de estado distinto de 403:```shell
katana -u https://www.hackerone.com -mdc 'contains(endpoint, "default") && status_code != 403'
```
- Para coincidir endpoints con tecnologías PHP:```shell
katana -u https://www.hackerone.com -mdc 'contains(to_lower(technologies), "php")'
```
- Para filtrar los endpoints que se ejecutan en Cloudflare:```shell
katana -u https://www.hackerone.com -fdc 'contains(to_lower(technologies), "cloudflare")'
```
Las funciones DSL se pueden aplicar a cualquier clave en la salida jsonl. Para obtener más información sobre las funciones DSL disponibles, visite el [dsl project](https://github.com/projectdiscovery/dsl).

Aquí hay opciones de filtro adicionales -```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
```
## Rate Limit

Es fácil ser bloqueado / baneado mientras se rastrea si no se siguen los límites de los sitios web objetivo, katana viene con múltiples opciones para ajustar el rastreo para ir tan rápido / lento como queramos.

*`-delay`*
-----

opción para introducir un retraso en segundos entre cada nueva solicitud que katana realiza mientras rastrea, deshabilitado por defecto.```
katana -u https://tesla.com -delay 20
```
*`-concurrency`*
-----
opción para controlar el número de urls por objetivo a obtener al mismo tiempo.```
katana -u https://tesla.com -c 20
```
*`-parallelism`*
-----
opción para definir el número de objetivos a procesar al mismo tiempo desde la entrada de lista.```
katana -u https://tesla.com -p 20
```
*`-rate-limit`*
-----
Máximo de solicitudes por segundo, aplicado globalmente a todos los hosts.```
katana -u https://tesla.com -rl 100
```
*`-rate-limit-minute`*
-----
Máximo de solicitudes por minuto, aplicado globalmente a todos los hosts.```
katana -u https://tesla.com -rlm 500
```
*`-host-rate-limit`*
-----
Máximo de solicitudes por segundo por host. Cada host tiene su propio bucket de límite de velocidad, por lo que un host lento no limitará a los rápidos. Reemplaza el límite de velocidad global cuando se establece. Katana también realiza una retroceso automático con retardo exponencial y jitter cuando un host devuelve 429 o 503.```console
katana -u https://tesla.com -hrl 50
```
*`-host-rate-limit-minute`*
-----
Máximo de solicitudes por minuto por host.```console
katana -u https://tesla.com -hrlm 200
```
Aquí están todas las opciones largas/cortas de CLI para el control de límite de tasa -```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
```
## Salida

Katana admite la salida a archivo tanto en formato de texto plano como en JSON, que incluye información adicional como `source`, `tag` y el nombre del `attribute` para correlacionar el endpoint descubierto.

*`-output`*
---

Por defecto, katana genera los endpoints rastreados en formato de texto plano. Los resultados pueden escribirse en un archivo usando la opción `-output`.```console
katana -u https://example.com -no-scope -output example_endpoints.txt
```
*`-output-template`*
---

La opción `-output-template` le permite personalizar el formato de salida utilizando una plantilla, brindando flexibilidad para definir la estructura de salida. Esta opción reemplaza el indicador `-field` obsoleto para filtrar la salida. En lugar de depender de campos predefinidos, puede especificar una plantilla personalizada directamente en la línea de comandos para controlar cómo se presentan los datos extraídos.

Ejemplo de uso de la opción `-output-template`:```sh
katana -u https://example.com -output-template '{{email}} - {{url}}'
```
En este ejemplo, `email` representa un [campo personalizado](#custom-fields) que extrae y muestra direcciones de correo electrónico encontradas en la fuente `url`.

> [!NOTE]
> Si un campo especificado no existe o no contiene un valor, simplemente se omitirá de la salida.

Esta opción puede estructurar eficazmente la salida de manera que se adapte mejor a su caso de uso, haciendo que la extracción de datos sea más intuitiva y personalizable.

*`-jsonl`*
---```console
katana -u https://example.com -jsonl | jq .
```
[No content provided in the INPUT section.]```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`*
----

La opción `-store-response` permite escribir todas las solicitudes y respuestas de endpoints rastreados en un archivo de texto. Cuando se utiliza esta opción, los archivos de texto que incluyen la solicitud y la respuesta se escribirán en el directorio **katana_response**. Si desea especificar un directorio personalizado, puede usar la opción `-store-response-dir`.```console
katana -u https://example.com -no-scope -store-response
```
### `!addclass <target> <class1>,<class2>,<level>`

Modificar clases, subclases, nivel opcional, puntuación de habilidad o conjuro.```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:**

*La opción `-store-response` no es compatible con el modo `-headless`.*

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

El flag `-list-output-fields` o `-lof` muestra todos los campos disponibles que se pueden usar en el formato de salida JSONL. Esto es útil para comprender qué datos están disponibles al usar plantillas de salida personalizadas o al excluir campos específicos.```console
katana -lof
```
*`-exclude-output-fields`*
----

La bandera `-exclude-output-fields` o `-eof` permite excluir campos específicos de la salida JSONL. Esto es útil para reducir el tamaño de la salida o centrarse en datos específicos al eliminar campos no deseados.```console
katana -u https://example.com -jsonl -eof raw,body
```
Aquí hay opciones adicionales de CLI relacionadas con la salida -```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 como biblioteca
`katana` se puede utilizar como biblioteca creando una instancia de la estructura `Option` y poblándola con las mismas opciones que se especificarían a través de la CLI. Usando las opciones puedes crear `crawlerOptions` y, por lo tanto, un `crawler` estándar o híbrido. El método `crawler.Crawl` debe ser llamado para rastrear la entrada.```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())
	}
}
```
## Reporte de Problemas y Solicitudes de Funcionalidades

Para mantener el seguimiento de problemas y mejorar la eficiencia de la clasificación:

**Todos los informes comienzan como [Discusiones de GitHub](https://github.com/projectdiscovery/katana/discussions)**

- **Reportes de Errores** → [Iniciar una Discusión de Preguntas y Respuestas](https://github.com/projectdiscovery/katana/discussions/new?category=q-a)
- **Solicitudes de Funcionalidades** → [Iniciar una Discusión de Ideas](https://github.com/projectdiscovery/katana/discussions/new?category=ideas)  
- **Preguntas** → [Iniciar una Discusión de Preguntas y Respuestas](https://github.com/projectdiscovery/katana/discussions/new?category=q-a)

**¿Por qué Discusiones primero?**
- **La comunidad puede ayudar** con preguntas rápidas y solución de problemas
- **Mejor clasificación** - los errores/funcionalidades confirmados se convierten en problemas rastreados  
- **Rastreador de problemas más limpio** - solo se enfoca en elementos procesables

Los mantenedores convertirán las discusiones en problemas cuando sea apropiado después de una revisión adecuada.

--------

<div align="center">

katana está hecho con ❤️ por el equipo de [projectdiscovery](https://projectdiscovery.io) y distribuido bajo [Licencia MIT](https://github.com/projectdiscovery/katana/blob/HEAD/LICENSE.md).


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

</div>