mapchar

Genera wordlist usando logica di pattern ed espressioni

Installazione    •    Documentazione    •    Utilizzo    •    Contributi

[!NOTE] Questo progetto è stato rinominato da fuse / fuse-generator a mapchar a partire dalla versione 7.0.2. Il pacchetto PyPI, il comando CLI e il nome del pacchetto Python sono tutti cambiati di conseguenza. Se stavi usando il vecchio nome, aggiorna le tue installazioni e importazioni.

Installazione

[!NOTE] Si raccomanda l'installazione tramite pipx o pip per la versione PyPI.

Documentazione

Per una guida completa, spiegazioni delle funzionalità ed esempi avanzati, visita la documentazione.

Utilizzo generale

Per generare una wordlist da una semplice espressione:

mapchar '/l{2,4}'

Per combinare file con generatori:

mapchar '^:^' nomi.txt password.txt

Gli output possono essere manipolati, filtrati e salvati.

Opzioni generali:
  -h, --help            mostra questo messaggio di aiuto ed esce
  -v, --version         mostra le informazioni di versione ed esce
  -S, --stats           mostra le statistiche del pattern ed esce
  -q, --quiet           sopprime l'output non essenziale
  -n, --non-interactive
                        salta il prompt di conferma prima dell'esecuzione

Opzioni di generazione:
  -d, --delimiter <stringa>
                        stringa inserita tra le voci generate
  -b, --write-buffer <dimensione>
                        dimensione del buffer di output
  -w, --workers <1-64>  numero di processi worker (default: 1)
  -k, --flush-threshold <dimensione>
                        svuota l'output dopo aver raggiunto questa soglia di byte (default: 512KB)

Opzioni di input:
  -f, --file <percorso> carica i pattern da file
  -s, --start <parola>  inizia a scrivere l'output da <parola>
  -e, --end <parola>    interrompi la scrittura dell'output a <parola>

Opzioni di output:
  -o, --output <percorso> scrive l'output su un file
  -z, --compress <formato>
                        comprime l'output (supportati: gzip, bzip2, lzma)
  -l, --compresslevel <livello>
                        livello di compressione per il formato selezionato

Base delle espressioni

• I caratteri letterali producono sé stessi.
• Le classi incorporate e le classi tra parentesi [...] producono un elemento per posizione.
• La concatenazione combina le posizioni: ogni posizione sceglie un valore dal suo token e lo concatena.

Esempio:

$ mapchar '/l{2,3}'
# output: aa, ab, ac, ..., ZY, ZZ

Classi di caratteri

Esempio: /l/l genera tutte le combinazioni di due lettere (maiuscole e minuscole).

Classi personalizzate e unioni

• [abc] seleziona un carattere tra a, b o c.
• Usa | per separare alternative di parole complete all'interno delle classi:
  • [admin|root|123] inserisce admin O root O 123 a quel punto.
• Usa || per separare espressioni di livello superiore:
  • mapchar 'admin/d||guest/d' combina due pattern indipendenti.

Statistiche

Puoi analizzare un pattern prima di generarlo usando il flag -S/--stats. Mostra il conteggio dei token, la dimensione stimata e i dettagli del filtro di intervallo.

mapchar -S '/l{3}||/d{3}'

Quantificatori

• {N} — ripeti esattamente N volte
• {min,max} — ripeti tra min e max volte (inclusi)
• ? — opzionale (0 o 1 volta)

Esempi:

$ mapchar '[XYZ]{3}'         # XXX, XXY, ..., ZZZ
$ mapchar '[XYZ]{2,5}'       # XY, XZ, ..., XYZXY
$ mapchar 'Ryan?/d'          # Rya0, Rya1, ..., Ryan9
$ mapchar '[XYZ]?Ryan'       # Ryan, XRyan, YRyan, ZRyan

Intervalli numerici

• #[1-10] → genera 1,2,3,4,5,6,7,8,9,10
• #[1-10:2] → genera 1,3,5,7,9
• #[2-10:2] → genera 2,4,6,8,10

Questi intervalli numerici possono essere usati in qualsiasi posizione di un'espressione.

File e placeholder

Usa ^ in un'espressione come segnaposto per il successivo argomento file. Ogni ^ consuma un file e itera sulle sue righe:

$ mapchar '^/d' nomi.txt
# output: Bob0, Bob1, ..., Ana0, Ana1, ...

$ mapchar '^-^' nomi.txt anni.txt
# output: Bob-1990, Ana-1991, Ryan-1992, ...

Prefissa un nome file con // per trattarlo come espressione inline invece che come percorso file.

Binding di valori

Usa <@nome=espressione> per valutare un'espressione una volta per riga di output e memorizzarla, poi riutilizzala con <@nome>. A differenza della concatenazione, questo introduce una dipendenza, quindi non viene creato alcun prodotto cartesiano tra la definizione e i suoi riferimenti.

$ mapchar '<@d=/d>-<@d>'
# output: 0-0, 1-1, ..., 9-9

$ mapchar '<@x=^>:<@x>' parole.txt
# output: foo:foo, bar:bar, ...

$ mapchar '<@n=/d{2}>_<@n>'
# output: 00_00, 01_01, ..., 99_99

Compressione

Mapchar supporta la compressione in tempo reale durante la scrittura dei file di output.

# gzip (veloce, bilanciato)
mapchar '/l{5}' -z gzip -o wordlist.txt.gz

# lzma (migliore compressione)
mapchar '/l{5}' -z lzma -o wordlist.txt.xz

# bzip2 (via di mezzo)
mapchar '/l{5}' -z bzip2 -o wordlist.txt.bz2

Escape dei caratteri speciali

Usa \ per escape dei caratteri speciali.

$ mapchar '\/d/d'
# output: /d/0, /d/1, ..., /d/9

Contributi

Accogliamo con favore i contributi a Mapchar! Che si tratti di aggiungere nuove funzionalità, migliorare la documentazione o correggere bug, il tuo aiuto è apprezzato. Sentiti libero di aprire una issue o inviare una pull request sul nostro repository GitHub all'indirizzo pwnfo/mapchar.

Cronologia stelle

Licenza

MIT © Ryan R. <[email protected]>