Dev.Yannou90

Fullbox, sous le capot : freebox révolution

Yannou90 — Sun, 02 Mar 2014 16:32:00 CET

Nous allons analyser en détail la génération de passphrases wpa pour la freebox révolution aussi appellée freeboxv6 ...

Fullbox permet la génération de passphrases pour la freebox révolution.

Comment fonctione-t-il et qu'elle sont ses limites?

Comme vous le savez, la freebox révolution utilise d'origine des passphrases sous la forme suivante :

[ un mot latin ] [ de 1 à 3 caractères ] [ un mot latin ] [ de 1 à 3 caractères ] [ un mot latin ] [ de 0 à 2 caractères ]

Au vu de certaine clées fourni par les possesseurs de freebox révolution désireux de connaitre la robustesse de tels passphrases, j'ai choisi de générer des clées suivant ce shèma :

un dictionnaire de mot de latin de 5 à 10 caractères
les séparateurs sont composés de 1 à 3 caractères parmis ceux ci: - ! ? # @
le dernier champs est composé de 0 à 2 caractères parmis : - ! ? # @ 0 1 2 3 4 5 6 7 8 9

Au vu des possibilités de passphrases quasi infini j'ai determiné une façon efficace et optimisé de créer ces clées :

Génération de clées par boucle sur boucle infinie :

3 tirages de 10 mots parmis 33220, donc 30 mots différents par boucle
155 "séparateurs" différents
240 en position final

Donc par boucle , fullbox génère:

1000x155x155x240=5766000000

Nous obtenons donc 5.766.000.000 passphrases différentes par boucles !! Et ce uniquement avec 30 mots.

Si nous devions générer tous les mots possibles :

le tirage est effectué parmis 33220 mots latin de 5 à 10 caractères
3 mots sont sélectionné au hasard

Ce qui nous donne :

33220x33219x33218=3,665723161×10¹³

Au total , en prenant en compte le nombre de combinaisons possibles, les séparateurs et le dernier champs :

33220x33219x33218!x155x155x240=2,113655975×10²⁰

Une éternitée ne suffirait pas à la créations de toutes les passphrases !!!

Et encore, ces calculs présument que le dictionnaire latin utilisé contient bien les bon mot et que le choix des séparateurs est juste!

Autant dire que la freebox révolution est inssensible au brute force malgrès des passphrases apparement simple !

Fullbox vous permettra peut-être de découvrir votre propre passphrase, et si c'était le cas, n'oubliez pas de faire un petit loto

Le script est disponible en téléchargement ici

Je vous rappel que l'utilisation de tels outils sur un réseau dont vous n'êtes pas le propriétaire est puni par la loi !!

Fullbox : un générateur de clées wpa pour Algérie Télécom, Alicebox, Dartybox, Freebox, FreeboxV6, Livebox, Neufbox ...

Yannou90 — Sun, 02 Mar 2014 01:48:00 CET

Je vous présente fullbox.sh, un tout nouveau générateur de passphrases de type wpa dédié au brute-force de vos box française!

Pour le moment, en version 0.1.2, il permet de reproduire des clées de type :

Algérie Télécom
Alicebox
Dartybox
Freebox
FreeboxV6
Livebox
Neufbox

Je rappelle qu'il est formellement interdit et punis par la lois de tester ce genre d'outils sur un réseau dont vous n'ëtes pas le propriétaire !

Voilà un bon moment que je n'avais posté un article!

Me revoici avec mon dernier bout de script : fullbox.sh

Il fonctionne sous linux et utilise le périphérique /dev/urandom pour l'entropie, et est couplé au mêmes techniques que j'utilise au coeur de permute.sh pour le booster.

Les régles de génération des passphrases sont assez simple mais efficaces.

Il est rapide, en moyenne 80000 clées seconde pour mon i3.

Je détaillerais un peut plus le fonctionnement de la bête dans un prochain article, mais voyons dès maintenant le manuel :

fullbox.sh permet la génération de pseudo clées wpa pour les box suivantes : algérie telecom, alice, bbox, darty, free, freeV6, livebox, neufbox

Utilisation :

fullbox.sh [alger:alice:bbox:darty:free:freev6:live:neuf]

Exemples :

#Générer des passphrases Alger Telecom :
fullbox.sh alger   ->    E7C4A0A6A6

#Générer des passphrases Alice :
fullbox.sh alice   ->   15E79E251E6761E330117718C9

#Générer des passphrases darty :
fullbox.sh darty   ->   NHAS5PFQU9ADU

#Générer des passphrases Free :
fullbox.sh free   ->   +pP2wFXq){}ORcn!.}9i2${x0(uod?@PskV5Ox,d;2k{cXuS{9w=.])

#Générer des passphrases FreeV6 :
fullbox.sh freev6   ->   forabis!-capis-latinum8

#Générer des passphrases Livebox :
fullbox.sh live   ->   164FEE1366F0A7340E2D454961

#Générer des passphrases Neuf :
fullbox.sh neuf   ->   cive5cosipqycnqqycnq

Développeur : Yannou90   |   Blog : http://dev.yannou90.free.fr

Télécharger le fichier puis le rendre éxécutable pour pouvoir l'utiliser

Le script est disponible en téléchargement ici

Gérer ses backups wii avec wiigame 0.5.4

Yannou90 — Sun, 07 Apr 2013 13:33:00 CEST

Bonjour

Je vous présente wiigame.sh 0.5.4 , une interface graphique pour wit créé avec yad permettant de gérer très simplement ses sauvegardes personnelles de jeux wii .

Ce simple script permet graphiquement de gérer sa collection de jeux wii .

Les principales fonctions :

- support de tout type de partition autre que wbfs

- support des formats wbfs,iso,ciso,wdf,wia

- importation

- exportation

- glissé/déposé

- édition du titre et de l'id du jeux

- affichage des miniatures

- téléchargement des jaquettes

J'ai créé ce script pour permettre une gestion simplifiée des sauvegardes personnelles de jeux wii sous linux .

Il ne nécessite pas les droits "root" pour fonctionner et utilise un systeme de cache pour un affichage ultra rapide .

L'interface principal est sobre , créé avec yad , et permet de piloter très simplement wit , un outil ultra puissant dédié à la gestion de sauvegardes de jeux wii .

En quelques "clics" vous pouvez :

- supprimer un ou plusieurs jeux de votre collection

- ajouter un ou toute une collection de jeux sous les formats wbfs,iso,ciso,wdf,wia

- exporter un ou toute votre collection de jeux vers un dossier différent ou un disque dur

- éditer les propriétés d'un jeux comme le titre et l'ID6

Vous pouvez définir de nombreuses options comme l'affichage des jaquettes au format cover,cover3d,disc .

Vous pouvez également choisir le serveur depuis lequel les jaquettes sont téléchargeés , le mode de téléchargement des jaquettes : à l'importation , à chaque refraichissement de l'interface principal , jamais ...

Ce programme possède ses propres jaquettes , créées spécifiquement pour wiigame .

L'interface de gestion des parametres :

À propos du logiciel :

Quelques vidéo de démonstration :

Ce logiciel , wiigame 0.5.4 , est disponible dans la partie public des téléchargements , ou directement ici : wiigame

[TUTO]Installation de pyrit + cpyrit-opencl + AMD Stream + OpenCl sous Ubuntu Precise Pangolin 12.04

Yannou90 — Tue, 26 Feb 2013 14:05:00 CET

L'installation de pyrit + cpyrit-opencl + AMD Stream + OpenCl sous Ubuntu Precise Pangolin 12.04 est un peut retord , heureusement ce tuto vous simplifie la tâche !

Ce tutoriel est réalisé sous Ubuntu Precise Pangolin 12.04 64 bits , les commandes sont à adaptées pour le 32 bits !

La première phase étant l'instalation des pilotes propiétaires de AMD , expliquée ici

Nous installons tout les paquets et dépendances :

sudo apt-get install pyrit opencl-headers build-essential cdbs fakeroot dh-make debhelper debconf libstdc++5 dkms linux-headers-$(uname -r) dh-modaliases execstack python python-dev python2.7-dev

Téléchargement et installation de AMD Stream :

Rendez vous sur la page de téléchargement du sdk :

Sélectionnez la version correspondant à votre architecture et acceptez la licence :

Vous obtenez une archive du type AMD-APP-SDK-v2.8-lnx64.tgz

Créez un dossier "COMPILATION" sur votre bureau et placez-y votre archive

Placez-vous en terminal dans ce dossier :

cd "/Le/chemin/vers/le/dossier/COMPILATION"

On extrait et install le sdk :

tar xzf AMD-APP-SDK-v2.8-lnx64.tgz
chmod 755 ./Install-AMD-APP.sh
sudo ./Install-AMD-APP.sh

On télécharge , extrait et install cpyrit-opencl-0.4.0 :

wget https://pyrit.googlecode.com/files/cpyrit-opencl-0.4.0.tar.gz
tar xzf cpyrit-opencl-0.4.0.tar.gz
cd cpyrit-opencl-0.4.0
 sed -i 's|/usr/local/cuda/include|/usr/include/CL/|' ./setup.py
 python setup.py build
 mkdir -p "$HOME/.local/local/lib/python2.7/dist-packages"
 mv "./build/lib.linux-x86_64-2.7/cpyrit/_cpyrit_opencl.so" "$HOME/.local/local/lib/python2.7/dist-packages/_cpyrit_opencl.so"

Vous remarquerez dans la commande précédente qu'il est nécessaire :

Modifier le fichier setup.py pour prendre en compte le chemin vers les "headers" open-cl
On install le module cpyrit dans le home , pyrit le trouvera de cette façon

On peut maintenant tester :

pyrit list_cores

Qui retourne :

Pyrit 0.4.0 (C) 2008-2011 Lukas Lueg http://pyrit.googlecode.com
This code is distributed under the GNU General Public License v3+

The following cores seem available...
#1:  'OpenCL-Device 'Turks''
#2:  'CPU-Core (SSE2)'
#3:  'CPU-Core (SSE2)'
#4:  'CPU-Core (SSE2)'

Et un petit benchmark :

pyrit benchmark

Qui retourne :

Pyrit 0.4.0 (C) 2008-2011 Lukas Lueg http://pyrit.googlecode.com
This code is distributed under the GNU General Public License v3+

Running benchmark (9566.2 PMKs/s)... / 

Computed 9566.24 PMKs/s total.
#1: 'OpenCL-Device 'Turks'': 9402.6 PMKs/s (RTT 2.8)
#2: 'CPU-Core (SSE2)': 359.7 PMKs/s (RTT 3.0)
#3: 'CPU-Core (SSE2)': 340.1 PMKs/s (RTT 3.2)
#4: 'CPU-Core (SSE2)': 344.1 PMKs/s (RTT 2.9)

Voilà , vous disposez maintenant d'une installation fonctionnelle et pouvez profiter de votre GPU pour pyrit !

[TUTO] Installation de catalyst 13.1 sous Ubuntu Precise 64 bits

Yannou90 — Mon, 25 Feb 2013 15:53:00 CET

Une mise à jours pour le pilote catalyst en version 13.1 est disponible !

Nous allons voir comment l'installer proprement .

Vous allez installer le dernier pilote catalyst dans sa version 13.1

Nous allons voir la procédure pour créer un paquet deb facilitant ainsi la mise à jours du kernel et la désinstallation du pilote .

On identifie la carte :

lspci | grep VGA

Dans mon cas :

00:02.0 VGA compatible controller: Intel Corporation 2nd Generation Core Processor Family Integrated Graphics Controller (rev 09)
01:00.0 VGA compatible controller: Advanced Micro Devices [AMD] nee ATI Thames XT/GL [Radeon HD 7600M Series]

J'ai en effet une carte hybride , le modèle est identifié :

Radeon HD 7600M Series

On confirme l'architecture du pc :

uname -p

Chez moi pour une installation 64 bits :

x86_64

Nous connaissons maintenant l'architecture et la carte . Il reste à télécharger le pilote .

Rendez vous chez AMD http://support.amd.com/fr/gpudownload/Pages/index.aspx

On télécharge le pilote correspondant à ses besoins , pour moi :

http://www2.ati.com/drivers/linux/amd-driver-installer-catalyst-13.1-linux-x86.x86_64.zip

Pour créer le paquet deb nous allons devoir compiler le driver , on installe donc tout le nécessaire :

sudo apt-get install build-essential lib32gcc1 libc6-i386 cdbs fakeroot dh-make debhelper debconf libstdc++5 dkms linux-headers-$(uname -r) dh-modaliases execstack

Et pour 64 bits en plus :

sudo apt-get install ia32-libs

Si une précédente version du pilote est installé il faut impérativement la désinstaller . Suivant la méthode d'installation , la commande peut être :

- pilote fourni par l'equipe ubuntu ou pilote propriétaire installé par paquet :

sudo apt-get autoremove fglrx fglrx-amdcccle fglrx-dev --purge

Lors de la désinstallation des pilotes propriétaires , ubuntu peut réinstaller les pilotes libres , il faut alors répéter la commande précédente :

sudo apt-get autoremove fglrx fglrx-amdcccle fglrx-dev --purge

- pilote installé par le script AMD :

sudo /chemin/vers/le/script/amd-driver-installer-catalyst-12.10-x86.x86_64.run --uninstall

Vous devez bien sur adapter la commande en fonction du précédent script utilisé pour l'installation du pilote actuel de votre carte .

La désinstallation étant effectuée , on se place dans le dossier contenant l'archive du pilote que l'on vient de télécharger , chez moi :

cd /media/Perso/Téléchargements

On extrait l'archive :

unzip ./amd-driver-installer-catalyst-13.1-linux-x86.x86_64.zip

On rend le script executable :

chmod 755 ./amd-driver-installer-catalyst-13.1-linux-x86.x86_64.run

Nous somme maintenant prêt à installer le pilote , sous Ubuntu/Precise :

sudo ./amd-driver-installer-catalyst-13.1-linux-x86.x86_64.run --buildpkg Ubuntu/precise

Nous avons créé les paquets il ne reste plus qu'à les installer :

sudo dpkg -i *.deb

Çà y est , tout est installé , il nous reste à reconfigurer Xorg :

sudo amdconfig  --initial

Voilà , un reboot et tout est bon !

La vidéo de mon installation :

Insérer un code valide xhtml 1.0 strict pour une vidéo youtube

Yannou90 — Sun, 24 Feb 2013 13:50:00 CET

Youtube permet d'insérer des vidéos dans des pages avec un simple code .

C'est gentil de la part de google , mais fournir un code valide w3c serait peut être mieux .

Passer la validation w3c est toujours gratifiant .

Nous allons voir comment insérer simplement une vidéo youtube dans le code d'une page html . Pour cela nous avons besoin de l'url d'une vidéo , par exemple celle-ci : http://www.youtube.com/watch?v=paYDxatNKk8

Seul l' ID nous interresse ici : paYDxatNKk8

Un code valide est de cette forme :

<object type="application/x-shockwave-flash" data="http://www.youtube.com/v/ID" height="340" width="549">
<param name="movie" value="http://www.youtube.com/v/ID" />
<param name="quality" value="autohigh" />
<param name="allowfullscreen" value="true" />
<param name="allowscriptAccess" value="always" />
<param name="flashvars" value="&amp;hd=1&amp;rel=0&amp;hl=fr&amp;fmt=22&amp;fs=1&amp;version=3" />
</object>

Il suffit de renseigner l' ID , on obtient :

<object type="application/x-shockwave-flash" data="http://www.youtube.com/v/paYDxatNKk8" height="340" width="549">
<param name="movie" value="http://www.youtube.com/v/paYDxatNKk8" />
<param name="quality" value="autohigh" />
<param name="allowfullscreen" value="true" />
<param name="allowscriptAccess" value="always" />
<param name="flashvars" value="&amp;hd=1&amp;rel=0&amp;hl=fr&amp;fmt=22&amp;fs=1&amp;version=3" />
</object>

Le rendu :

1 000 000 000 de clées "Livebox"

Yannou90 — Thu, 07 Feb 2013 11:31:00 CET

Bonjours à tous !

Je vous propose mon outil permute.sh , capable de générer en un temps record , des milliards de "passphrases" compressées plusieurs dizaine de milliers de fois !

Un exemple ?

La génération d'un dictionnaire de clées de type "Livebox" , 26 caractères (2x13 , hexadecimal) , aucune redondance , pas de répétition d'un même caractère , 1 000 000 000 de clées générées en 12 minutes et 31 secondes , soit 1 331 557 clées par secondes ; le poid du fichier devrait être de 36.32 Gio , avec permute.sh il passe à 907 Kio , soit un taux de compression de 41147

Impossible ? Suivez le guide !

La génèse

J'ai créé ce script pour démontrer l'inutilitée du brute force !

En effet , pour des clées de type "wpa" , beaucoup de tutoriaux vous présentent des outils comme aircrack-ng , pyrit ou autre , et vous montre qu'il est possible de cassé ces clées . Très impressionnant en vidéo , on se rend rapidement compte que tout est bidonné : l'attaquant à créé le point d'accès , la clée lui appartient , il est donc certain de la trouver !

On trouve également de nombreux "dictionnaires" de clées sur le net , spécialisés pour certains type de box . Mais là aussi : comment sont généré ces dictionnaires ? Avec des outils comme crunch par exemple , un fantastique générateur de mot de passe : malheureusement toutes les clées possibles et imaginables sont générées , même les improbables : 00000000 , aaaaaaaa , ...De plus une éternité serait nécessaire à la création de ces clées et l'espace de stockage de notre planete ne suffirait pas !

De plus , il arrive également que l'on soit obligé de trier le dictionnaire généré , supprimer les doublons , etc ,...

J'ai alors cherché un logiciel performant qui permettrait de générer de gros dictionnaire très spécialisés : rapide , peu gourmand en ressources , générant des "passphrases" complexes , pas de clées improbables , pas de doublons , pas de répétition d'un même caractère . Pourquoi ? Limiter et optimiser la qualitée des clées générées .

Il n'existe actuellement aucun logiciel de ce type , aucun ne rassemble toutes ces conditions . Je l'ai donc créé : permute.sh est né !

Le fonctionnement

J'utilise un vocabulaire précis correspondant au fonctionnement de permute.sh : le "dictionnaire" est un fichier contenant des "mots" , chaque "mot" est composé de "caractères" , un "mot" par ligne , pas d'espace dans "un mot" .

Par exemple on peut avoir un "dictionnaire" numérique , composé de chiffre , de 0 à 9 , un par ligne .

Un "dictionnaire" alpha-numérique composé des letrres de a à z en minuscule et majuscule , ainsi que des chiffres de 0 à 9 .

On peut également créer un "dictionnaire" de "mots" composé de mots les plus courant dans une langue precise .

Ce script répond exactement à ces critères :

- très rapide , des millions de phrases générées par secondes
- les "phrases" générées sont composées de "mots"
- chaque "mot" est associé aux autres
- toutes les permutations sont générées
- aucunes répétitions d'un même "mot" dans une même "phrases"
- aucunes répétition d'une même "phrase" dans un même "dictionnaire"
- le "dictionnaire" généré est de taille "humaine"

Ces critères limitent ainsi la génération de "phrases" , pas de "phrases" improbables , les "phrases" sont trés complexes , uniques .

En limitant ainsi la génération de "phrases" , on optimise la probabilitée d'avoir créé la "phrase" recherchée !

1 000 000 000 de clées Livebox

Vous trouverez ici une archive aux format 7z qui contient 1 000 000 000 de clées de type hexadécimal , de 26 caratères (13x2) correspondant aux clées wpa des Livebox .

Cette archive ne pèse que 907 Kio au lieu de 32 Gio , soit un taux de compression de 41 147 !

Il est inutile d'extraire cette archive , elle ne contient pas le fichier attendu .

Comment l'utiliser ? Avec permute.sh bien sur !

Par exemple avec aircrak-ng :

permute.sh -r 1360318271_DICO.7z | aircrack-ng -w - -e MON_ESSID MA_CAPTURE.cap

Vous trouverz un tutoriel détaillé sur l'utilisation de permute.sh ici .

Amusez-vous bien !

[TUTO] permute.sh 0.4.3

Yannou90 — Fri, 01 Feb 2013 17:50:00 CET

Bonjour

Ce programme permet la génération de "phrases" issues de la permutation de"mots" d'un "dictionnaire" composé par l'utilisateur .

Ce "dictionnaire" est composé de "mots" , un mot par lignes , pas d'espace.

On peut avoir un "dictionnaire" "numérique" ( ex : 0,1,2,3,4...ou : 00,01,02,...) , un "dictionnaire" de "mots" courant ( ex : arbre,chien,...) , un "dictionnaire" de "mots" alpha-numerique ( ex : [0-9],[a-z],[A-Z] ) , bref , un "dictionnaire" composé par l'utilisateur .

Cette spécificitée permet de créer des "phrases" précises , limitant la génération de celles ci aux besoins spécifiques de l'utilisateur .

Toutes les permutations sont possibles , si le temps et l'espace disque le permet . Aucune répétition d'un même "mot" par "phrases" . Aucunes répétition d'une même "phrases" par "dictionnaires"

Nous allons voir comment utiliser permute.sh 0.4.3 pour générer un grand nombre de "phrases" .

Le manuel de permute.sh :

permute.sh permet la génération de phrases à partir d'un dictionnaire , par permutations des mots .
    
    Ce projet à pour but de démontrer l'inutilité du force-brute .
    
    Utilisation :
    
    permute.sh -[!:L:w:i:p:d:r:P:s:] <ARGUMENT> -v -h -y -C
    
    permute.sh  -l <LONG_MIN> -L <LONG_MAX> -w <NBR_MOTS> -i <DICO> -d <DIR> -C -P <NBR_PHRASES> -s <SEPARATEUR>
    permute.sh -v -L <LONG_MAX> -w <NBR_MOTS> -i <DICO>
    permute.sh -i <DICO>  -P 10000
    permute.sh -r <ARCHIVE>
    permute.sh -h
        
    -l <LONG_MIN>
        Longueur minimal du mot du dictionnaire (LONG_MIN=1 par défaut) .
    -L <LONG_MAX>
        Longueur maximal du mot du dictionnaire (LONG_MAX=4 par défaut) .
    -w <NBR_MOTS>
        Nombre de mots composant la phrase (NBR_MOTS=3 par défaut) .
    -i <DICO>
        Chemin vers le dictionnaire
    -v
        Mode verbeux , plus lent , toutes les combinaisons de 2 à <NBR_MOTS> sont affichées , le mode compression n'est pas compatible .
    -d <DIR>
        Dossier de sortie , par défaut celui contenant le dictionnaire .
    -r <ARCHIVE>
        Permet de lire sur la sortie standard le contenu d'une archive au format 7z créé avec permute.sh
    -y
        Pas de confirmation , pas d'interraction avec l'utilisateur .
    -C
        Mode compression : les données sont directement compressée , le mode verbeux n'est pas compatible .
    -P <NBR_PHRASES>
        Limiter la création de  phrases à <NBR_PHRASES> ( par défaut limité à 1000000 )
    -s <SEPARATEUR>
        Utilise <SEPARATEUR> comme séparateur entre chaque mot (SEPARATEUR=  par défaut) .
    -h
        Affiche ce message        
        
    Exemple d'utilisation :
    
    # Créer 1000000 de phrases de 5 mots basé sur les mots de 2 à 8 caractères de dico.txt , utiliser ':'  comme séparateur , le fichier est compressé au format 7z :
    
    /media/Perso/Bureau/.PERMUTE/permute.sh -l 2 -L 8 -w 5 -i dico.txt -C -P 1000000 -s :
    
    # Créer des phrases de 3 mots basé sur les mots inférieur à 4 caractères de dico.txt , aucunes confirmation n'est nécessaire :
    
    /media/Perso/Bureau/.PERMUTE/permute.sh  -L 4 -w 3 -i dico.txt -y
    
    # Créer des phrases de 3 mots dans  123456789.txt basé sur les mots de 1 à 4 caractères de dico.txt , limité à 1000000 phrases , toutes les combinaisons sont affichées sur la sortie standars :
    
    /media/Perso/Bureau/.PERMUTE/permute.sh  -i dico.txt -v
    
    # Lire une archive créée avec permute.sh :
    
    /media/Perso/Bureau/.PERMUTE/permute.sh  -r 1234567890.7z

Les principales options :

-i <DICO>
Chemin vers le dictionnaire . Indispensable pour la génération de "phrases"

-w <NBR_MOTS>
Nombre de mots composant la phrase (NBR_MOTS=3 par défaut) .

-P <NBR_PHRASES>
Limiter la création de phrases à <NBR_PHRASES> ( par défaut limité à 1000000 ) . Le nombre de "phrases" à générer

-s <SEPARATEUR>
Utilise <SEPARATEUR> comme séparateur entre chaque mot (SEPARATEUR= par défaut) . Par défaut un espace est utilisé pour séparer les "mots" dans une "phrases" , changer cette option permet toute sorte de fantaisies

-C
Mode compression : les données sont directement compressée , le mode verbeux n'est pas compatible . Quand le mode compression est activé , on peut générer des dictionnaires beaucoup plus volumineux que l'espace disque ne le permet .

-r <ARCHIVE>
Permet de lire sur la sortie standard le contenu d'une archive au format 7z créé avec permute.sh . Cette option permet de lire une archive sur la sortie standard , ou de passer la sortie à un autre programme .

Le script :

#!/bin/bash

#Mainteneur : Yannou90
#
#Logiciel : permute.sh
#
#Version : 0.4.3
#
#Dépendances : 7z , bc
#
#Date : 06.02.2013
#
#Description : créer des passphrases de longueurs définis par l'utilisateur en fonction d'un dictionnaire
#
#Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes
#de la Licence Publique Générale GNU publiée par la Free Software Foundation
#(version 2 ou bien toute autre version ultérieure choisie par vous).
#
#Ce programme est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE,
#ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation
# dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus
#de détails.
#
#Vous devez avoir reçu une copie de la Licence Publique Générale GNU en même temps
#que ce programme ; si ce n'est pas le cas, écrivez à la Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, États-Unis.

######################
## On cree les variables de bases ##
######################

OPT_PASS=$1
SEQ="3"
LONGMIN="1"
LONGMAX="4"
NUM="1"
TEMPS="$(date +%s)"
NEW="${TEMPS}_PASSE_1.txt"
TMP="${TEMPS}_tmp.txt"
DICO="${TEMPS}_DICO.txt"
NBR="1"
FACT="1"
CONV=""
VITESSE="0"
FULL="1"
WDIR=""
REPONSE="n"
COMPRESSE="1"
PHRASES="n"
NBRM="1000000"
SEP=" "
VERIF="n"
EXIT="n"
ANS="31556952"
MOIS="2629746"
JOURS="86400"

#############
## Le menu d'aide ##
#############

function HELP()
{
	echo -e "\
	
	${0##*/} permet la génération de phrases à partir d'un dictionnaire , par permutations des mots .
	
	Ce projet à pour but de démontrer l'inutilité du force-brute .
	
	Utilisation :
	
	${0##*/} -[!:L:w:i:p:d:r:P:s:] <ARGUMENT> -v -h -y -C
	
	${0##*/}  -l <LONG_MIN> -L <LONG_MAX> -w <NBR_MOTS> -i <DICO> -d <DIR> -C -P <NBR_PHRASES> -s <SEPARATEUR>
	${0##*/} -v -L <LONG_MAX> -w <NBR_MOTS> -i <DICO>
	${0##*/} -i <DICO>  -P 10000
	${0##*/} -r <ARCHIVE>
	${0##*/} -h
		
	-l <LONG_MIN>
		Longueur minimal du mot du dictionnaire (LONG_MIN=1 par défaut) .
	-L <LONG_MAX>
		Longueur maximal du mot du dictionnaire (LONG_MAX=4 par défaut) .
	-w <NBR_MOTS>
		Nombre de mots composant la phrase (NBR_MOTS=3 par défaut) .
	-i <DICO>
		Chemin vers le dictionnaire 
	-v
		Mode verbeux , plus lent , toutes les combinaisons de 2 à <NBR_MOTS> sont affichées , le mode compression n'est pas compatible .
	-d <DIR>
		Dossier de sortie , par défaut celui contenant le dictionnaire .
	-r <ARCHIVE>
		Permet de lire sur la sortie standard le contenu d'une archive au format 7z créé avec ${0##*/}
	-y
		Pas de confirmation , pas d'interraction avec l'utilisateur .
	-C
		Mode compression : les données sont directement compressée , le mode verbeux n'est pas compatible .
	-P <NBR_PHRASES>
		Limiter la création de  phrases à <NBR_PHRASES> ( par défaut limité à 1000000 )
	-s <SEPARATEUR>
		Utilise <SEPARATEUR> comme séparateur entre chaque mot (SEPARATEUR=" " par défaut) .
	-h
		Affiche ce message		
		
	Exemple d'utilisation :
	
	# Créer 1000000 de phrases de 5 mots basé sur les mots de 2 à 8 caractères de dico.txt , utiliser ':'  comme séparateur , le fichier est compressé au format 7z :
	
	$0 -l 2 -L 8 -w 5 -i dico.txt -C -P 1000000 -s ":"
	
	# Créer des phrases de 3 mots basé sur les mots inférieur à 4 caractères de dico.txt , aucunes confirmation n'est nécessaire :
	
	$0  -L 4 -w 3 -i dico.txt -y
	
	# Créer des phrases de 3 mots dans  123456789.txt basé sur les mots de 1 à 4 caractères de dico.txt , limité à 1000000 phrases , toutes les combinaisons sont affichées sur la sortie standars :
	
	$0  -i dico.txt -v
	
	# Lire une archive créée avec ${0##*/} :
	
	$0  -r 1234567890.7z"
}

##################
## Pas de sortie standard ##
##################

function PERMQUICK()
{
	TMP="${TEMPS}_PASSE_${PASSE}.txt"
	while read WORD
	do
		if [[ "$NULL" = "sep" ]]
		then
			sed -u -e "/^$/d; /$WORD/d; $MXq; s/^/$WORD /g; s/ /$SEP/g" "$NEW"
		else
			sed -u -e "/^$/d; /$WORD/d;  $MXq; s/^/$WORD /g " "$NEW"
		fi
		PERAC="$(bc<<<"$PERAC+1")"
		ACT="$(bc -l<<<"(($PERAC/$PERC)*100)+(($NUM/$SEQ)*100)" | cut -d'.' -f1)"
		printf "\rProgression : $ACT/100" 1>&2
	done < "$DICO" | head -n "$MAX" > "$TMP"
}

##############
## Sortie standard ##
##############

function PERMTEE()
{
	TMP="${TEMPS}_PASSE_${PASSE}.txt"
	
	while read WORD
	do
		if [[ "$NULL" = "sep" ]]
		 then
			sed -u -e "/^$/d; /$WORD/d; $MXq; s/^/$WORD /g; s/ /$SEP/g" "$NEW"
		else
			sed -u -e "/^$/d; /$WORD/d; $MXq; s/^/$WORD /g " "$NEW"
		fi
	done < "$DICO" | head -n "$MAX" | tee -a "$TMP" | sed -e "s/ /$SEP/g"
}

############
## Compression ##
############

function PERMX()
{	
	TMP="${TEMPS}_PASSE_${PASSE}.7z"
	while read WORD
	do
		7z e  "$NEW" -so 2>/dev/null | sed -u -e "/^$/d; $MXq; /$WORD/d; s/^/$WORD /g "
		PERAC="$(bc<<<"$PERAC+1")"
		ACT="$(bc -l<<<"(($PERAC/$PERC)*100)+(($NUM/$SEQ)*100)" | cut -d'.' -f1)"
		printf "\rProgression : $ACT/100" 1>&2
	done < "$DICO" | head -n "$MAX" | 7z a "$TMP" -si &>/dev/null
}

############
## Permutation ##
############

function PERMUTE()
{
	if [[ "$1" = "2" ]]
	then
		ARCH="${TEMPS}_PASSE_1.7z"
		7z a "$ARCH" "$NEW"  &>/dev/null
		rm "$NEW"
		NEW="$ARCH"
		(( SEQ-- ))
	fi
	PERC="$(bc<<<"$LIGNE*$SEQ")"
	PERAC="0"
	while [[ ! "$NUM" = "$SEQ" ]]
	do
		PASSE="$(( NUM + 1 ))"
		if [[ "$PASSE" = "$SEQ" ]]
		then
			if [[ "$NULL" = "0" ]]
			then
				NULL="sep"
			fi
			if [[ ! "$COMPRESSE" = "0" ]]
			then
			MAX="$NBRM"
			fi
		fi
		case "$1" in
			0)
				PERMQUICK;;
			1)
				PERMTEE;;
			2)
				PERMX;;
		esac
		mv -f  "$TMP"  "$NEW"
		(( NUM++ ))
	done
	printf "\rProgression : 100/100\n" 1>&2
	if [[ "$1" = "2" ]]
	then
		7z a  "$NEW" "$DICO" &>/dev/null
		echo "SEP=\"$SEP\"" > "${TEMPS}_DICO.sep"
		7z a  "$NEW"  "${TEMPS}_DICO.sep" &>/dev/null
		rm "${TEMPS}_DICO.sep" "$DICO"
		DICO="${TEMPS}_DICO.7z"
	fi
	mv -f "$NEW" "$DICO"
}

###########
## Nettoyage ##
###########

function CLEAN()
{
	rm "$DICO"
	if [[ -d "$WDIR" ]]
	then
		rmdir "$WDIR"
	fi
}

###########################################
## Convertion octets -> Kio -> Mio -> Gio -> Tio -> Pio -> Eio -> Zio -> Yio ##
###########################################

function CONVERTION()
{
	COUNT="1024"
	
	if COMPARE "$COUNT" "$1" 
	then
		return 0
	fi
	
	echo "Soit :" 1>&2
	
	for i in K M G T P E Z Y
	do
	if COMPARE "$1" "$COUNT"
	then
		CONV="$(bc<<<"scale=2; $1/$COUNT")"
		echo "- ${CONV} ${i}io"
		COUNT="$(bc<<<"$COUNT*1024")"
	else
		return 0
	fi
	done 1>&2
}

################################################
## Résoudre le probleme des chaines longues dans les comparaisons nnumériques ##
################################################

function COMPARE()
{
	ZERO="$(bc<<<"$1<=$2")"
	return "$ZERO"
}

###################
## Lire une archive ULTRA ##
###################

function READ()
{
	ZIP="$1"
	NOM_ZIP="$(basename "$1")"
	DICT="$(echo "$NOM_ZIP" | cut -d'.' -f1)"
	TXT_DICT="$DICT.txt"
	TXT_SEP="$DICT.sep"
	eval $(7z e -so "$ZIP" -- "$TXT_SEP" 2>/dev/null | cat)

	while read WORD
	do
		if [[ es"$SEP"pace = "es pace" ]]
		then
			7z e -so "$ZIP" -- "$DICT" 2>/dev/null | sed -u -e "/$WORD/d; s/^/$WORD /g"
		else
			7z e -so "$ZIP" -- "$DICT" 2>/dev/null | sed -u -e "/$WORD/d; s/^/$WORD /g; s/ /$SEP/g" 
		fi
	done <<<"$(7z e -so "$ZIP" -- "$TXT_DICT" 2>/dev/null | cat)"
}

################
## On parse les options ##
################

while getopts ":l:L:w:i:d:r:P:s:vyCh" OPT_PASS
do
	case "$OPT_PASS" in
	l)
		LONGMIN="$OPTARG";;
	L)
		LONGMAX="$OPTARG";;
	w)
		SEQ="$OPTARG";;
	i)
		ORIGINAL="$OPTARG"
		if [[ ! -e "$ORIGINAL" ]]
		then
			echo "Le fichier n'existe pas" 1>&2
			exit 1
		fi
		DIR="${ORIGINAL%/*}";;
	v)
		VITESSE="1";;
	d)
		WDIR="$OPTARG"
		mkdir -p "$WDIR"
		DIR="$WDIR";;
	y)
		REPONSE="y"
		EXIT="y";;
	C)
		COMPRESSE="0";;
	r)
		ZIP="$OPTARG"
		if [[ ! -e "$ZIP" ]]
		then
			echo "Le fichier n'existe pas" 1>&2
			exit 1
		fi
		if [[ "$(file "$OPTARG" | grep -w "7-zip")" = "1" ]]
		then
			echo "Cette archive n'est pas pris en charge" 1>&2
			exit 1
		fi
		READ "$ZIP"
		exit 0;;
	P)
		NBRM="$OPTARG";;
	s)
		SEP="$OPTARG"
		NULL="0";;
	h)
		HELP
		exit 0;;
	*)
		HELP
		exit 1;;
	esac
done

#################
## Pas d'options -> help ##
#################

if [[ "$(echo "$@"no)" = "no" ]]
then
	HELP
	exit 1
fi
################################
## Le mode compression désactive le mode verbeux ##
################################


if [[ "$COMPRESSE" = "0" ]]
then
	if  [[ "$VITESSE" = "1" ]]
	then
		echo -e "Le mode compression et le mode verbeux sont inccompatibles" 1>&2
	exit 1
	fi
	VITESSE="2"
fi

##########################
## On se place dans le dossier de travail ##
##########################

cd "$DIR"

#####################################
## On trie le dictionnaire en fonction de la longeur des mots ##
#####################################

LONGX="$(bc<<<"$LONGMAX +1")"
sed   "/^.\{$LONGMIN\}/!d; /^.\{$LONGX\}/d" "$ORIGINAL" | sort -u -R > "$DICO"

##################################
## On reccupere le nombre de mots du dictionnaire trié ##
##################################

LIGNE="$(wc -l<"$DICO")"
MULTIPLI="$LIGNE"

#############################################################
## Si le nombre de mots par phrases à créer est supérieur au nombre de mot du dictionnaire , on quitte ##
#############################################################

if COMPARE   "$SEQ"  "$LIGNE"
then
	echo "Le nombre de mots composants la phrase doit être égal ou inférieur au nombre de mots composants le dictionnaire :
	Nombre de lignes du dictionnaire : $LIGNE
	Nombre de mots par phrase :$SEQ " 1>&2
	rm "$DICO"
	exit 1
fi

###########################
## Calcul du poid et du nombre de phrases ##
###########################

POID="$(stat -c %s "$DICO")"
PMOY="$(bc<<<"$POID/$LIGNE")"
MAX="$(bc<<<"($NBRM/($LIGNE-$SEQ))+1")"
MX="$(bc<<<"($MAX/$LIGNE)+1")"

while [[ "$NBR" != "$SEQ" ]]
do
	(( NBR ++ ))
	MULTIPLI="$(bc<<<"$MULTIPLI - 1")"
	FACT="$(bc<<<"$FACT*$MULTIPLI")"
done

PHRASE="$(bc<<<"$LIGNE*$FACT")"
TOTAL="$(bc<<<"$POID*$FACT*$SEQ")"
PTOT="$(bc<<<"$PMOY*$SEQ*$NBRM")"

if COMPARE "$NBRM" "$PHRASE"
then
	PTOT="$TOTAL"
	NBRM="$PHRASE"
fi

if [[ "$VITESSE" = "2" ]]
then	
	PTOT="$(bc<<<"(($PMOY*($SEQ-1)*$MAX)+$POID)/33")"
fi


##################################################
## On invite l'utilisateur à choisir si oui ou non il souhaite exploser son disque dur :) ##
##################################################

LIBRE="$(bc<<<"$(df "$DICO" | grep dev | awk '{ print $4 }')*1024")"
echo "Espace libre disponible : $LIBRE octets" 1>&2
CONVERTION "$LIBRE"

echo -e "\n\
Nombre de lignes du dictionnaire : $LIGNE
Longueur minimal des mots : $LONGMIN
Longueur maximal des mots : $LONGMAX
Nombre de mots par phrase : $SEQ
Nombre de phrases : $PHRASE
Poid : $TOTAL octets" 1>&2
CONVERTION "$TOTAL"

echo -e "\n\
Nombre de phrases limitées à : $NBRM
Poid supposé du fichier généré : $PTOT octets" 1>&2
CONVERTION "$PTOT"

POURCENT="$(bc -l<<<"100*($NBRM/$PHRASE)")"

echo -e "\nCe fichier couvre $POURCENT % des possibibiltées !"  1>&2

if COMPARE "$PTOT" "$LIBRE"
then
	echo -e "\nVous ne disposez pas de l'espace disque nécessaire !\nVeuillez corriger les options sélectionnées ." 1>&2
	exit 1
fi

##############
## On lance la bête ##
##############

if [[ "$REPONSE" = "n" ]]
then
	echo -e "\nSouhaitez vous poursuivre ?\n[y/n]" 1>&2
	read REPONSE
else
	echo -e "\nExécution sans confirmation\n" 1>&2
fi


case "$REPONSE" in
	y) 
		cp "$DICO" "$NEW"
		DEBUT="$(date +%s)"
		PERMUTE "$VITESSE"
		FIN="$(date +%s)"
		GEN="$(bc<<<"$FIN-$DEBUT")";;
	n)
		echo "On quitte"
		CLEAN
		exit 0;;
	*)
		echo "Choix invalide , on quitte ." 1>&2
		CLEAN
		exit 1;;
esac

##############################
## Quelques informations sur le fichier produit ##
##############################

TOTAL="$(stat -c %s "$DICO")"
DATE="$(date +"%H h %M mn %S s" -d "0000-01-01 $GEN seconds")"
VIT="$(bc<<<"$NBRM/$GEN")"
TVIT="$(bc<<<"$PHRASE/$VIT")"
TANS="$(bc<<<"$TVIT/$ANS")"
TREST="$(bc<<<"$TVIT-($TANS*$ANS)")"
TMOIS="$(bc<<<"$TREST/$MOIS")"
TREST="$(bc<<<"$TREST-($TMOIS*$MOIS)")"
TJOURS="$(bc<<<"$TREST/$JOURS")"
TREST="$(bc<<<"$TREST-($TJOURS*$JOURS)")"
TDATE="$(date +"$TANS années $TMOIS mois $TJOURS jours %H heures %M minutes %S secondes" -d "0000-01-01 $TREST seconds")"

echo -e "
Fichier de sortie : $DIR/$DICO
Poid du fichier produit : $TOTAL octets" 1>&2
CONVERTION "$TOTAL"

echo -e "
Temps écoulé ; $GEN secondes
Soit : $DATE" 1>&2

echo -e "\nVitesse d'éxécution : $VIT phrases par seconde" 1>&2

echo -e "\nTemps nécessaire à la créations de toutes les phrases :\n$TDATE" 1>&2

if [[ "$EXIT" = "y" ]]
then
	exit 0
fi

echo -e "
Souhaitez vous vérifier le nombre de phrases générées ?
Attention cette opération peut être très longue
[y/n]" 1>&2

read VERIF

if [[ "$VERIF" = "y" ]]
then
	if [[ "$VITESSE" = "2" ]]
	then
		eval $(READ "$DICO" | wc -l -c | awk '{ printf "NBR_PH=\"%s\"\nPOID=\"%s\"\n", $1, $2 }')
		TXCMP="$(bc<<<"$POID/$TOTAL")"
		echo -e "\nPoid décompressé : $POID octets" 1>&2
		CONVERTION "$POID"
		echo -e "\nNombre de phrases générées : $NBR_PH\nTaux de compression : $TXCMP" 1>&2
		exit 0
	else
		NBR_PH="$(wc -l<"$DICO")"
		echo -e "\nNombre de phrases générées : $NBR_PH" 1>&2
	fi
fi

exit 0

À enregistrer sous permute.sh par exemple puis le rendre executable :

chmod 755 /chemin/vers/permute.sh

Exemples 1 000 000 de clées wpa type livebox compressées , 26 caractères (2x13 hexadecimal) :

Le dictionnaire de base :

01
02
03
04
05
06
07
08
09
0A
0B
0C
0D
0E
0F
10
12
13
14
15
16
17
18
19
1A
1B
1C
1D
1E
1F
20
21
23
24
25
26
27
28
29
2A
2B
2C
2D
2E
2F
30
31
32
34
35
36
37
38
39
3A
3B
3C
3D
3E
3F
40
41
42
43
45
46
47
48
49
4A
4B
4C
4D
4E
4F
50
51
52
53
54
56
57
58
59
5A
5B
5C
5D
5E
5F
60
61
62
63
64
65
67
68
69
6A
6B
6C
6D
6E
6F
70
71
72
73
74
75
76
78
79
7A
7B
7C
7D
7E
7F
80
81
82
83
84
85
86
87
89
8A
8B
8C
8D
8E
8F
90
91
92
93
94
95
96
97
98
9A
9B
9C
9D
9E
9F
A0
A1
A2
A3
A4
A5
A6
A7
A8
A9
AB
AC
AD
AE
AF
B0
B1
B2
B3
B4
B5
B6
B7
B8
B9
BA
BC
BD
BE
BF
C0
C1
C2
C3
C4
C5
C6
C7
C8
C9
CA
CB
CD
CE
CF
D0
D1
D2
D3
D4
D5
D6
D7
D8
D9
DA
DB
DC
DE
DF
E0
E1
E2
E3
E4
E5
E6
E7
E8
E9
EA
EB
EC
ED
EF
F0
F1
F2
F3
F4
F5
F6
F7
F8
F9
FA
FB
FC
FD
FE
00
11
22
33
44
55
66
77
88
99
AA
BB
CC
DD
EE
FF

À enregistrer sous double_hexa.txt par exemple

La commande shell :

permute.sh -i double_hexa.txt -w 13 -s "" -P 1000000 -C

Résultat :

Espace libre disponible : 208892764160 octets
Soit :
- 203996840.00 Kio
- 199215.66 Mio
- 194.54 Gio

Nombre de lignes du dictionnaire : 256
Longueur minimal des mots : 1
Longueur maximal des mots : 4
Nombre de mots par phrase : 13
Nombre de phrases : 14879476555971175569951129600000
Poid : 580299585682875847228094054400000 octets
Soit :
- 566698814143433444558685600000.00 Kio
- 553416810686946723201841406.25 Mio
- 540446104186471409376798.24 Gio
- 527779398619600985719.52 Tio
- 515409568964454087.61 Pio
- 503329657191849.69 Eio
- 491532868351.41 Zio
- 480012566.74 Yio

Nombre de phrases limitées à : 1000000
Poid supposé du fichier généré : 4513 octets
Soit :
- 4.40 Kio

Ce fichier couvre 0 % des possibibiltées !

Souhaitez vous poursuivre ?
[y/n]
y
Progression : 100/100

Fichier de sortie : /media/Perso/Bureau/.PERMUTE/1361123685_DICO.7z
Poid du fichier produit : 4312 octets
Soit :
- 4.21 Kio

Temps écoulé ; 50 secondes
Soit : 00 h 00 mn 50 s

Vitesse d'éxécution : 20000 phrases par seconde

Temps nécessaire à la créations de toutes les phrases :
23575592085020086176 années 2 mois 4 jours 15 heures 30 minutes 36 secondes

Souhaitez vous vérifier le nombre de phrases générées ?
Attention cette opération peut être très longue
[y/n]
y

Poid décompressé : 27116208 octets
Soit :
- 26480.67 Kio
- 25.86 Mio

Nombre de phrases générées : 1004304
Taux de compression : 6288

Comment lire une archive compressée :

permute.sh -r 1234567890.7z

Comment coupler la lecture d'une archive à aircrack-ng :

permute.sh -r 1234567890.7z |  aircrack-ng -w - -e MON_ESSID MA_CAPTURE.cap

Quelques captures d'écrant :