AlterX

Funktionen • Installation • Verwendung • AlterX ausführen • Discord beitreten


   Schneller und anpassbarer Subdomain-Wortlistengenerator mit DSL.

Funktionen

Schnell und anpassbar
Automatische Worterweiterung
Vordefinierte Variablen
Konfigurierbare Muster
Muster-Mining – Automatisches Erkennen von Subdomain-Mustern (Go-Port von Regulator)
STDIN-/Listeneingabe
Mehrere Betriebsmodi (Standard, Entdecken, Beides)

Installation

Um alterx zu installieren, muss Golang 1.19 auf deinem System installiert sein. Du kannst Golang von hier herunterladen. Nach der Installation von Golang kannst du den folgenden Befehl verwenden, um alterx zu installieren:

go install github.com/projectdiscovery/alterx/cmd/alterx@latest

Aus dem Quellcode erstellen

# Repository klonen
git clone https://github.com/projectdiscovery/alterx.git
cd alterx

# Mit dem Makefile erstellen
make build

# Oder manuell erstellen
go build ./cmd/alterx

Verfügbare Makefile-Ziele:

make help          # Alle verfügbaren Ziele anzeigen
make build         # Die Binärdatei erstellen
make test          # Tests ausführen
make test-coverage # Tests mit Abdeckung ausführen
make lint          # Linter ausführen
make fmt           # Code formatieren
make clean         # Build-Artefakte bereinigen
make install       # In $GOPATH/bin installieren

Hilfemenü

Du kannst den folgenden Befehl verwenden, um die verfügbaren Flags und Optionen zu sehen:

Fast and customizable subdomain wordlist generator using DSL.

Usage:
  ./alterx [flags]

Flags:
INPUT:
   -l, -list string[]     subdomains to use when creating permutations (stdin, comma-separated, file)
   -p, -pattern string[]  custom permutation patterns input to generate (comma-seperated, file)
   -pp, -payload value    custom payload pattern input to replace/use in key=value format (-pp 'word=words.txt')

OUTPUT:
   -es, -estimate      estimate permutation count without generating payloads
   -o, -output string  output file to write altered subdomain list
   -ms, -max-size int  Max export data size (kb, mb, gb, tb) (default mb)
   -v, -verbose        display verbose output
   -silent             display results only
   -version            display alterx version

CONFIG:
   -config string  alterx cli config file (default '$HOME/.config/alterx/config.yaml')
   -en, -enrich    enrich wordlist by extracting words from input
   -ac string      alterx permutation config file (default '$HOME/.config/alterx/permutation_v0.0.1.yaml')
   -limit int      limit the number of results to return (default 0)

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

Warum `alterx` ??

Was alterx von anderen Subdomain-Permutationswerkzeugen wie goaltdns unterscheidet, ist seine Scripting-Funktion. alterx nimmt Muster als Eingabe und erzeugt basierend auf diesem Muster eine Subdomain-Permutations-Wortliste, ähnlich wie nuclei es mit fuzzing-templates macht.

Was die Aktive Subdomain-Enumeration schwierig macht, ist die Wahrscheinlichkeit, eine tatsächlich existierende Domain zu finden. Wenn man das Finden möglicher Subdomains auf einer Skala darstellt, sollte es ungefähr so aussehen:

   Using Wordlist < generate permutations with subdomains (goaltdns) < alterx

Fast alle gängigen Subdomain-Permutationswerkzeuge haben fest verdrahtete Muster. Wenn solche Werkzeuge ausgeführt werden, erzeugen sie Wortlisten mit Millionen von Subdomains, was die Durchführbarkeit von Brute-Force-Angriffen mit Werkzeugen wie dnsx verringert. Es gibt keine feste Konvention zur Benennung von Subdomains; sie hängt in der Regel von der Person ab, die die Subdomain registriert. Mit alterx ist es möglich, Muster auf der Grundlage von Ergebnissen der passiven Subdomain-Enumeration zu erstellen, was die Wahrscheinlichkeit erhöht, eine Subdomain zu finden, und die Durchführbarkeit von Brute-Force-Angriffen verbessert.

Variablen

alterx verwendet eine variablenähnliche Syntax ähnlich wie nuclei-Templates. Man kann mit diesen Variablen eigene Muster schreiben. Wenn Domains als Eingabe übergeben werden, wertet alterx die Eingabe aus und extrahiert Variablen daraus.

Basis- / Allgemeine Variablen

{{sub}}     :  subdomain prefix or left most part of a subdomain
{{suffix}}  :  everything except {{sub}} in subdomain name is suffix
{{tld}}     :  top level domain name (ex com,uk,in etc)
{{etld}}    :  also know as public suffix (ex co.uk , gov.in etc)

Erweiterte Variablen

{{sld}}  :   second-level domain  (ex for api.scanme.sh => {{sld}} is scanme)
{{root}}  :  also known as eTLD+1 i.e only root domain (ex for api.scanme.sh => {{root}} is scanme.sh)
{{subN}}  :  here N is an integer (ex {{sub1}} , {{sub2}} etc) .

// {{subN}} is advanced variable which exists depending on input
// lets say there is a multi level domain cloud.nuclei.scanme.sh
// in this case {{sub}} = cloud and {{sub1}} = nuclei`

Muster

Ein Muster kann vereinfacht als Vorlage betrachtet werden, die beschreibt, welche Art von Mustern alterx erzeugen soll.

// Below are some of example patterns which can be used to generate permutations
// assuming api.scanme.sh was given as input and variable {{word}} was given as input with only one value prod
// alterx generates subdomains for below patterns

"{{sub}}-{{word}}.{{suffix}}" // ex: api-prod.scanme.sh
"{{word}}-{{sub}}.{{suffix}}" // ex: prod-api.scanme.sh
"{{word}}.{{sub}}.{{suffix}}" // ex: prod.api.scanme.sh
"{{sub}}.{{word}}.{{suffix}}" // ex: api.prod.scanme.sh

Hier ist eine Beispiel-Musterkonfigurationsdatei – https://github.com/projectdiscovery/alterx/blob/main/permutations.yaml – die je nach Bedarf einfach angepasst werden kann.

Diese Konfigurationsdatei erzeugt Subdomain-Permutationen für Sicherheitsbewertungen oder Penetrationstests mithilfe anpassbarer Muster und dynamischer Payloads. Die Muster umfassen bindestrichbasierte, punktbasierte und andere Varianten. Benutzer können benutzerdefinierte Payload-Abschnitte wie Wörter, Regionskennungen oder Zahlen erstellen, um ihre spezifischen Anforderungen zu erfüllen.

Beispielsweise könnte ein Benutzer einen neuen Payload-Abschnitt env mit Werten wie prod und dev definieren und ihn dann in Mustern wie {{env}}-{{word}}.{{suffix}} verwenden, um Subdomains wie prod-app.example.com und dev-api.example.com zu erzeugen. Diese Flexibilität ermöglicht maßgeschneiderte Subdomain-Listen für einzigartige Testszenarien und Zielumgebungen.

Die standardmäßig für die Generierung verwendete Musterkonfigurationsdatei wird im Verzeichnis $HOME/.config/alterx/ gespeichert. Eine benutzerdefinierte Konfigurationsdatei kann ebenfalls über die Option -ac verwendet werden.

Beispiele

Ein Beispiel für die Ausführung von alterx mit einer vorhandenen Liste passiver Subdomains von tesla.com liefert uns 10 zusätzliche NEUE und gültige Subdomains, die mit dnsx aufgelöst wurden.

$ chaos -d tesla.com | alterx | dnsx



   ___   ____          _  __
  / _ | / / /____ ____| |/_/
 / __ |/ / __/ -_) __/>  <
/_/ |_/_/\__/\__/_/ /_/|_|

      projectdiscovery.io

[INF] Generated 8312 permutations in 0.0740s
auth-global-stage.tesla.com
auth-stage.tesla.com
digitalassets-stage.tesla.com
errlog-stage.tesla.com
kronos-dev.tesla.com
mfa-stage.tesla.com
paymentrecon-stage.tesla.com
sso-dev.tesla.com
shop-stage.tesla.com
www-uat-dev.tesla.com

Ebenso kann die Option -enrich verwendet werden, um bekannte Subdomains als Worteingabe einzubringen und zielgerichtete Permutationen zu erzeugen.

$ chaos -d tesla.com | alterx -enrich

   ___   ____          _  __
  / _ | / / /____ ____| |/_/
 / __ |/ / __/ -_) __/>  <
/_/ |_/_/\__/\__/_/ /_/|_|

      projectdiscovery.io

[INF] Generated 662010 permutations in 3.9989s

Du kannst die Standardmuster zur Laufzeit mit der CLI-Option -pattern ändern.

$ chaos -d tesla.com | alterx -enrich -p '{{word}}-{{suffix}}'

   ___   ____          _  __
  / _ | / / /____ ____| |/_/
 / __ |/ / __/ -_) __/>  <
/_/ |_/_/\__/\__/_/ /_/|_|

      projectdiscovery.io

[INF] Generated 21523 permutations in 0.7984s

Es ist auch möglich, vorhandene Variablenwerte mit der CLI-Option -payload zu überschreiben.

$ alterx -list tesla.txt -enrich -p '{{word}}-{{year}}.{{suffix}}' -pp word=keywords.txt -pp year=2023

   ___   ____          _  __
  / _ | / / /____ ____| |/_/
 / __ |/ / __/ -_) __/>  <
/_/ |_/_/\__/\__/_/ /_/|_|

      projectdiscovery.io

[INF] Generated 21419 permutations in 1.1699s

Weitere Informationen findest du im Release-Blog – https://blog.projectdiscovery.io/introducing-alterx-simplifying-active-subdomain-enumeration-with-patterns/

Schau dir auch die folgenden ähnlichen Open-Source-Projekte an, die in deinen Workflow passen könnten:

altdns, goaltdns, gotator, ripgen, dnsgen, dmut, permdns, str-replace, dnscewl, regulator

alterx wurde mit ❤️ vom projectdiscovery-Team entwickelt und unter der MIT-Lizenz veröffentlicht.

`{{sub}}`	`api`	`admin`	`cloud`
`{{suffix}}`	`scanme.sh`	`dev.scanme.sh`	`scanme.co.uk`
`{{tld}}`	`sh`	`sh`	`uk`
`{{etld}}`	`-`	`-`	`co.uk`

`{{sld}}`	`scanme`	`scanme`	`scanme`
`{{root}}`	`scanme.sh`	`scanme.sh`	`scanme.co.uk`
`{{sub1}}`	`-`	`dev`	`-`
`{{sub2}}`	`-`	`-`	`-`

alterx

Beliebteste