mapchar

Genera listas de palabras usando lógica de patrones y expresiones

Instalación    •    Documentación    •    Uso    •    Contribuir

[!NOTE] Este proyecto fue renombrado de fuse / fuse-generator a mapchar a partir de la versión 7.0.2. El paquete PyPI, el comando CLI y el nombre del paquete Python han cambiado en consecuencia. Si estabas usando el nombre anterior, actualiza tus instalaciones e importaciones.

Instalación

[!NOTE] Se recomienda instalar usando pipx o pip para la versión PyPI.

Documentación

Para una guía completa, explicaciones de funciones y ejemplos avanzados, visita la documentación.

Uso general

Para generar una lista de palabras a partir de una expresión simple:

mapchar '/l{2,4}'

Para combinar archivos con generadores:

mapchar '^:^' names.txt pass.txt

Las salidas se pueden manipular, filtrar y guardar.

General Options:
  -h, --help            show this help message and exit
  -v, --version         show version information and exit
  -S, --stats           show pattern statistics and exit
  -q, --quiet           suppress non-essential output
  -n, --non-interactive
                        skip the confirmation prompt before execution

Generation Options:
  -d, --delimiter <string>
                        string inserted between generated entries
  -b, --write-buffer <size>
                        output buffer size
  -w, --workers <1-64>  number of worker processes (default: 1)
  -k, --flush-threshold <size>
                        flush output after reaching this byte threshold (default: 512KB)

Input Options:
  -f, --file <path>     load patterns from file
  -s, --start <word>    start writing output from <word>
  -e, --end <word>      stop writing output at <word>

Output Options:
  -o, --output <path>   write output to a file
  -z, --compress <format>
                        compress output (supported: gzip, bzip2, lzma)
  -l, --compresslevel <level>
                        compression level for the selected format

Conceptos básicos de expresiones

• Los caracteres literales se representan a sí mismos.
• Las clases incorporadas y las clases entre corchetes [...] producen un elemento por posición.
• La concatenación combina posiciones: cada posición selecciona un valor de su token y los concatena.

Ejemplo:

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

Clases de caracteres

Ejemplo: /l/l genera todas las combinaciones de dos letras (mayúsculas y minúsculas).

Clases personalizadas y uniones

• [abc] selecciona un carácter de a, b o c.
• Usa | para separar alternativas de palabras completas dentro de las clases:
  • [admin|root|123] inserta admin O root O 123 en ese punto.
• Usa || para separar expresiones de nivel superior:
  • mapchar 'admin/d||guest/d' encadena dos patrones independientes.

Estadísticas

Puedes analizar un patrón antes de generarlo usando la bandera -S/--stats. Esto muestra el conteo de tokens, el tamaño estimado y los detalles de filtrado por rango.

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

Cuantificadores

• {N} — repetir exactamente N veces
• {min,max} — repetir entre min y max veces (inclusive)
• ? — opcional (0 o 1 vez)

Ejemplos:

$ 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

Rangos numéricos

• #[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

Estos rangos numéricos se pueden usar en cualquier posición de una expresión.

Archivos y marcadores de posición

Usa ^ en una expresión como marcador de posición para el siguiente argumento de archivo. Cada ^ consume un archivo e itera sobre sus líneas:

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

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

Prefija un nombre de archivo con // para tratarlo como una expresión en línea en lugar de una ruta de archivo.

Enlaces de valores

Usa <@name=expr> para evaluar una expresión una vez por línea de salida y almacenarla, luego reutilizarla con <@name>. A diferencia de la concatenación, esto introduce una dependencia, por lo que no se crea un producto cartesiano entre la definición y sus referencias.

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

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

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

Compresión

Mapchar admite compresión sobre la marcha al escribir archivos de salida.

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

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

# bzip2 (middle ground)
mapchar '/l{5}' -z bzip2 -o wordlist.txt.bz2

Escapando caracteres especiales

Usa \ para escapar caracteres especiales.

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

Contribuir

¡Agradecemos las contribuciones a Mapchar! Ya sea agregando nuevas funciones, mejorando la documentación o corrigiendo errores, tu ayuda es bienvenida. No dudes en abrir un issue o enviar un pull request en nuestro repositorio de GitHub en pwnfo/mapchar.

Historial de Estrellas

Licencia

MIT © Ryan R. <[email protected]>