mapchar

Générez des wordlists en utilisant la logique de motifs et des expressions

Installation    •    Documentation    •    Utilisation    •    Contribuer

[!NOTE] Ce projet a été renommé de fuse / fuse-generator à mapchar à partir de la version 7.0.2. Le paquet PyPI, la commande CLI et le nom du package Python ont tous été modifiés en conséquence. Si vous utilisiez l'ancien nom, veuillez mettre à jour vos installations et importations.

Installation

[!NOTE] Il est recommandé d'installer via pipx ou pip pour la version PyPI.

Documentation

Pour un guide complet, des explications des fonctionnalités et des exemples avancés, veuillez consulter la documentation.

Utilisation générale

Pour générer une wordlist à partir d'une expression simple :

mapchar '/l{2,4}'

Pour combiner des fichiers avec des générateurs :

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

Les sorties peuvent être manipulées, filtrées et sauvegardées.

Options générales :
  -h, --help            afficher ce message d'aide et quitter
  -v, --version         afficher les informations de version et quitter
  -S, --stats           afficher les statistiques du motif et quitter
  -q, --quiet           supprimer les sorties non essentielles
  -n, --non-interactive
                        ignorer l'invite de confirmation avant l'exécution

Options de génération :
  -d, --delimiter <string>
                        chaîne insérée entre les entrées générées
  -b, --write-buffer <size>
                        taille du tampon d'écriture
  -w, --workers <1-64>  nombre de processus workers (par défaut : 1)
  -k, --flush-threshold <size>
                        vider la sortie après avoir atteint ce seuil d'octets (par défaut : 512 Ko)

Options d'entrée :
  -f, --file <path>     charger les motifs depuis un fichier
  -s, --start <word>    commencer l'écriture de la sortie à partir de <mot>
  -e, --end <word>      arrêter l'écriture de la sortie à <mot>

Options de sortie :
  -o, --output <path>   écrire la sortie dans un fichier
  -z, --compress <format>
                        compresser la sortie (supporté : gzip, bzip2, lzma)
  -l, --compresslevel <level>
                        niveau de compression pour le format sélectionné

Bases des expressions

• Les caractères littéraux sont produits tels quels.
• Les classes intégrées et les classes entre crochets [...] produisent un élément par position.
• La concaténation combine les positions : chaque position choisit une valeur de son token et concatène.

Exemple :

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

Classes de caractères

Exemple : /l/l génère toutes les combinaisons de deux lettres (majuscules et minuscules).

Classes personnalisées et unions

• [abc] sélectionne un caractère parmi a, b ou c.
• Utilisez | pour séparer des alternatives de mots entiers à l'intérieur des classes :
  • [admin|root|123] insère admin OU root OU 123 à cet endroit.
• Utilisez || pour séparer des expressions de niveau supérieur :
  • mapchar 'admin/d||guest/d' enchaîne deux motifs indépendants.

Statistiques

Vous pouvez analyser un motif avant de le générer en utilisant le drapeau -S/--stats. Cela affiche le nombre de tokens, la taille estimée et les détails du filtrage par plage.

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

Quantificateurs

• {N} — répéter exactement N fois
• {min,max} — répéter entre min et max fois (inclus)
• ? — optionnel (0 ou 1 fois)

Exemples :

$ 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

Plages numériques

• #[1-10] → génère 1,2,3,4,5,6,7,8,9,10
• #[1-10:2] → génère 1,3,5,7,9
• #[2-10:2] → génère 2,4,6,8,10

Ces plages numériques peuvent être utilisées à n'importe quelle position d'une expression.

Fichiers et espaces réservés

Utilisez ^ dans une expression comme espace réservé pour le prochain argument de fichier. Chaque ^ consomme un fichier et itère sur ses lignes :

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

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

Préfixez un nom de fichier par // pour le traiter comme une expression en ligne au lieu d'un chemin de fichier.

Liaisons de valeurs

Utilisez <@name=expr> pour évaluer une expression une fois par ligne de sortie et la stocker, puis la réutiliser avec <@name>. Contrairement à la concaténation, cela introduit une dépendance, donc aucun produit cartésien n'est créé entre la définition et ses références.

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

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

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

Compression

Mapchar supporte la compression à la volée lors de l'écriture des fichiers de sortie.

# gzip (rapide, équilibré)
mapchar '/l{5}' -z gzip -o wordlist.txt.gz

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

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

Échapper les caractères spéciaux

Utilisez \ pour échapper les caractères spéciaux.

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

Contribuer

Nous accueillons les contributions à Mapchar ! Que ce soit pour ajouter de nouvelles fonctionnalités, améliorer la documentation ou corriger des bugs, votre aide est appréciée. N'hésitez pas à ouvrir une issue ou soumettre une pull request sur notre dépôt GitHub à pwnfo/mapchar.

Historique des étoiles

Licence

MIT © Ryan R. <[email protected]>