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 03-02-2013 20:45:19

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

Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Bonjour à tous

Introduction

Je vais vous présenter un outils capable de générer :

- 1 000 000 (1 million) de clee hexadecimal , de 5 caracteres ( 5x2 ) , separé par " : " ( deux points ) , en moin de 5 secondes , pour un poid de 5 Kio

- 1 000 000 (1 million) de clee alpha-numerique , de 10 caracteres  ,sans separateur , en moin de 5 secondes , pour un poid de 16 Kio

Prologue

permute.sh  a été créé pour démontrer l'inutilitée du force brute pur !
C'est à dire qu'il démontre l'absurditée de sa propre existence !

Là , vous vous dites : mais il est pas bien celui la roll

Je suis parti d'un simple constat :

- générer un dico de clées purement aléatoire est inutile si le type de clées générées ne correspond pas à la cible
- générer toutes les combinaisons possibles est inutiles car l'enssemble des combinaisons comprend également des clées improbable (du type aaaaaaaaaaaaaaaaaaaaaaaaaaa , bbbbbbbbbbbbbbbbbbbbbbb , etc ...)
- il est impossible de stocker toutes les clées qu'il est possible de générer
- le temps nécessaires à la génération de toutes les clées dépasse de loin le temps de passage d'un humain sur terre
- le temps nécessaires à la lecture de toutes les clées dépasse de loin le temps de passage d'un humain sur terre

Ceci étant dit , j'ai pensé qu'il fallait :

- cibler le type de clées à générer
- ne pas créé de clées de façon aléatoire
- empecher la création de clées "absurde"
- ne pas créer de doublon
- limiter la génération des cléés a une utilisation humaine

J'ai donc créé spécifiquement permute.sh pour répondre à tout ces critéres , et limité l'utilisation du script à ceux ci !

Le script

Créez un fichier texte nommé permute.sh et copier/coller le code suivant dedant :

#!/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

Enregistez le srcipt créé et rendez le éxecutable :

- ou clique droit -> propiété -> permission -> rendre executable
- ou ouvrir un terminal et changer le bit d'execution :

chmod +x /chemin/vers/le/script/permute.sh

La même chose en octale

chmod 755  /chemin/vers/le/script/permute.sh

Vous disposez maintenant de permute.sh dans sa derniere version , le script est executable , nous allons pouvoir passer au travail !

Le manuel d'aide

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

Exemple d'utilisation

1) Générer 1000000 de clées hexadecimal de 5 caratere ( 5x2 ) , avec comme separateur le caratere " : " (deux points):

D'apres le manuel nous avons besoin d'un dictionnaire de travail , ce dictionnaire ne comprend que des "mots" , un "mots" par ligne , pas d'espaces .

Pour l'exercice nous avons donc besoin d'un dictionnaire "hexadecimal" , c'est à dire de tout les mots existant , composé de deux carateres , formé avec les caracteres suivant : 0 1 2 3 4 5 6 7 8 9 A B C D E F

On créé un fichier texte que nous appelons simple_hexa.txt et on colle les caracteres qui nous interresse :

A
B
C
D
E
F
0
1
2
3
4
5
6
7
8
9

Et nous allons créé toutes les combinaisons de 2 caracteres , sans doublon :

permute.sh -i simple_hexa.txt -l 1 -L 2 -w 2 -s ""

-i  simple_hexa.txt-> chemin vers le dictionnaire simple_hexa.txt
-l 1 -> on selectionne les mots de au moin 1 caractere du dictionnaire
-L 2 -> on selectionne les mots de moin de 2 caracteres du dictionnaire
-w 2 -> on créé des phrases de 2 mots
-s "" -> on souhaite modifier le caractere d'espacement , un espace par defaut , ici aucun espace

Résultat :

Espace libre disponible : 204613095424 octets
Soit 199817476.00 Kio
Soit 195134.25 Mio
Soit 190.56 Gio

Nombre de lignes du dictionnaire : 16
Longueur minimal des mots : 1
Longueur maximal des mots : 4
Nombre de mots par phrase : 2
Nombre de phrases à générées : 240
Poid du fichier généré : 960 octets

Nombre de phrases limitées à : 240
Poid supposé du fichier généré : 960 octets

Souhaitez vous poursuivre ?
[y/n]
y

real	0m0.080s
user	0m0.000s
sys	0m0.008s

Fichier de sortie : /media/Perso/Bureau/1359916193_DICO.txt
Poid du fichier produit : 720 octets

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

Nombre de phrases générées : 240

On renome le fichier en double_hexa.txt  pour ne pas se perdre , on peut verifier son contenu pour verifier :

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

J'ai maintenant un dictionnaire contenant tout les caractere hexadecimaux ( par pair) , passont à la création de 1000000 (1 million) de phrases composé de 5 mots separé par " : " (deux points) :

permute.sh -i double_hexa.txt -l 1 -L 2 -w 5 -s ":" -P 1000000

-i  double_hexa.txt-> chemin vers le dictionnaire double_hexa.txt
-l 1 -> les mots de plus de 1 caractere
-L 2 -> les mots de 2 caracteres au plus
-w 5 -> 5 mots par phrases
-s ":" -> j'utilise " : " comme separateur de mot
-P 1000000 -> je veux 1 million de phrases

Résultat :

Espace libre disponible : 204614021120 octets
Soit 199818380.00 Kio
Soit 195135.13 Mio
Soit 190.56 Gio

Nombre de lignes du dictionnaire : 240
Longueur minimal des mots : 1
Longueur maximal des mots : 4
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 à : 1000000
Poid supposé du fichier généré : 15000000 octets
Soit 14648.43 Kio
Soit 14.30 Mio

Souhaitez vous poursuivre ?
[y/n]
y

real	0m6.657s
user	0m4.648s
sys	0m1.448s

Fichier de sortie : /media/Perso/Bureau/1359918132_DICO.txt
Poid du fichier produit : 15000000 octets
Soit 14648.43 Kio
Soit 14.30 Mio

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

Nombre de phrases générées : 1000000

Il est preferable de ne pas ouvrir ce fichier car trop volumineux mais on peut verifier sont contenu avec la commande "head" :

head /chemin/vers/le/fichier/genere

Dans mon cas :

head /media/Perso/Bureau/1359918132_DICO.txt
80:AC:D9:93:70
80:AC:D9:93:14
80:AC:D9:93:18
80:AC:D9:93:A8
80:AC:D9:93:29
80:AC:D9:93:96
80:AC:D9:93:A1
80:AC:D9:93:5F
80:AC:D9:93:8B
80:AC:D9:93:C3

Et si je voulais compresser ces données ? J'utilise l'option -C :

permute.sh -i double_hexa.txt -w 5 -s ":" -P 1000000 -C
Espace libre disponible : 204599017472 octets
Soit 199803728.00 Kio
Soit 195120.82 Mio
Soit 190.54 Gio

Nombre de lignes du dictionnaire : 240
Longueur minimal des mots : 1
Longueur maximal des mots : 4
Nombre de mots par phrase : 5
Nombre de phrases à générées : 763565765760
Poid du fichier généré : 1470658254 octets
Soit 1436189.70 Kio
Soit 1402.52 Mio
Soit 1.36 Gio

Nombre de phrases limitées à : 1000000
Poid supposé du fichier généré : 1926 octets
Soit 1.88 Kio

Souhaitez vous poursuivre ?
[y/n]
y

real	0m7.032s
user	0m3.384s
sys	0m4.136s

Fichier de sortie : /media/Perso/Bureau/1359918424_DICO.7z
Poid du fichier produit : 3781 octets
Soit 3.69 Kio

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

Nombre de phrases générées : 1004416

Vous remarquerez que l'archive pese 3.69 Kio , aucun archiveur ne peut compresse a ce point un fichier de ce type , mais permute.sh le peut

2) Utiliser une archive crée avec permute.sh avec aircrack-ng

Vous avez vos 1000000 de clée dans une archive crée avec permute.sh , vous extrayer sont contenu et la le drame ! Il y a 3 fichiers et aucun ne corresponds au travail demander ?!
C'est normal , il ne faut pas extraire l'archive mais l'utiliser telle quel !
Mais pourquoi ?
Avec permute.sh vous pouvez généré des fichier bien plus gros que votre disque dur ne le permet , pour cela j'utilise une compression double : une mathematique , et celle fourni par 7z . Aucun fichiers n'est rellement créé , sauf l'archive
Comment s'en servir ?
Pour lire l'archive j'utilise l'option -r , je peux alors utiliser l'archive comme un fichier texte , et donc m'en servir avec aircrack-ng par exemple:

permute.sh -r 1234567890_DICO.7z |  aircrack-ng -w - -e MON_essid  MON_essid.cap

Conclusion

Aucun logiciel n'est capable de fournir le même travail
Aucun logiciel n'est capable de compressé a ce point ( des milliers de fois )
Aucun logiciel ne fourni une qualitée et une rapidite d'execution equivalente : des millions de clee genere en quelque secondes , aucun doublon , pas de repetition d'un meme mot par phrase

Vous pouvez maintenant créé des dico de quelque kilo qui contiennent des terra octets de clee!

J'espere avoir été clair , et attends vos retour , merci

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

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 04-02-2013 11:09:27

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Merci pour le tuto.
Je me suis permis d'éditer ton titre en quittant les fautes d'orthographes car il y en avait à tire larigot...  (ceci dit je compatis et suis compréhensif vu celles que je fais tongue )
C'est vraiment impressionnant le niveau de compression auquel tu arrives avec 7z!  smile
Quel est l'impact sur la vitesse de crack lorsque tu lances le crack en pipe avec aircrack-ng en mode "on the fly" ( "-w - ")?

Hors Ligne

#3 04-02-2013 11:24:55

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Bonjour

Il n'y a quasi aucun impacte !

En fait les phrases arrivent par vagues , si l'archive contient énormement de phrases , genre 1 000 000 000 , un certain temps est nécessaire pour que le travail debute , mais dès que les phrases arrivent tu ne perd rien en vitesse !

Pour t'en rendre compte tu peux créé un dico d'1 000 000 de phrases compressé , et le reconstituer sous çà forme réelle , c'est à dire un fichier texte comme ceci :

permute.sh -r 1234567890.7z > mon_dico.txt

Tu te rendra alors compte de la vitesse de sortie : tu sera limité par la vitesse d'écriture sur tes disques !

Je déconseille vraiment d'utiliser cette méthode car lors de mes testes j'ai réalisé des archives de 20 Kio qui contenaient plus d'1 Tio de données !

Donc si tu souhaite reconstituer le dico assure toi de l'avoir compressé toi même , regarde les statistiques données et assure toi d'avoir l'espace libre suffisant !

Sinon merci pour les fautes , mais quand je code je ne fais pas très attention , et hier quand j'ai posté j'était en pleine ébulition .

Hors Ligne

#4 04-02-2013 11:37:23

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Et pour le fun quelques archives généré : 105.569.881 phrases pour un poid total de 1.3 Mo = 1.6 Go



1359972421_DICO.7z
1359972263_DICO.7z
1359971932_DICO.7z
1359971809_DICO.7z
1359971414_DICO.7z
1359971214_DICO.7z
1359970972_DICO.7z
1359970786_DICO.7z
1359970553_DICO.7z
1359970410_DICO.7z

NOM NBR_DE_PHRASES TYPE NBR_DE_MOTS_PAR_PHRASE

1359970410_DICO.7z 10384632 alpha-num-MAJ x10
1359971214_DICO.7z 10384632 alpha-num-min x10
1359971414_DICO.7z 10192324 alpha-num-min-MAJ x10
1359972421_DICO.7z 11666669  simple-hexa x10
1359970553_DICO.7z  11666669 double-hexa x10(10x2)
1359970786_DICO.7z 10625017 min x10
1359970972_DICO.7z 10625017 MAJ x10
1359971809_DICO.7z 10007266 Dico x3(1->8)
1359971932_DICO.7z 10008311 Dico x4(1->8)
1359972263_DICO.7z  10009344 Dico x5(1->8)

total : 105569881 de phrases

Les md5 :

2c31f8e0e35198db627fd7289bcdef2a  1359970410_DICO.7z
05ed1cf8b031643833eeebbd8779a344  1359970553_DICO.7z
1c2ac1354af1a9ba3eede7426434ff81  1359970786_DICO.7z
8b2bb9eddcceabe50db35db78b63e7ba  1359970972_DICO.7z
14cdbf7994dd36947641b7d3e86056b8  1359971214_DICO.7z
55745c507fe182980d5010d1e3bd4e90  1359971414_DICO.7z
c3bccc7114e5f4067959ae4d3a4afaed  1359971809_DICO.7z
685936ec2eca98bf40345fe5283a4166  1359971932_DICO.7z
0ecaadf1a8a956bfad70d487c028f554  1359972263_DICO.7z
dd07b2ba9482ba474a2dc3ca810bbcba  1359972421_DICO.7z

Il est important de ne pas renommer les archives sous peines de non fonctionnement !
Les dico de type DICO sont réalisés sur la base des 1500 mots les plus utilisés de la langue française , mots de 1 à 8 caractères !

Amusez-vous bien , j'attends vos retours !

Merci .

Dernière modification par Yannou90 (04-02-2013 13:23:51)

Hors Ligne

#5 04-02-2013 13:04:59

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Un petit benchmark pour se rendre compte :

J'ai utilisé "dd" pour mesurer le débit de sortie de permute.sh :

permute.sh -r 1234567890_DICO.7z | dd of=/dev/null

À vous de juger l'efficacitée de permute.sh cool

Benchmark de 1359970410_DICO.7z :

223092+32 enregistrements lus
223107+1 enregistrements écrits
114230952 octets (114 MB) copiés, 34,7498 s, 3,3 MB/s

10384632 phrases --> 300607 phrases par secondes

Benchmark de 1359970553_DICO.7z :

250643+16 enregistrements lus
250651+1 enregistrements écrits
128333359 octets (128 MB) copiés, 46,7932 s, 2,7 MB/s

11666669 phrases --> 246093 phrases par secondes

Benchmark de 1359970786_DICO.7z :

228258+22 enregistrements lus
228271+1 enregistrements écrits
116875187 octets (117 MB) copiés, 37,5158 s, 3,1 MB/s

10625017 phrases --> 281517 phrases par secondes

Benchmark de 1359970972_DICO.7z :

228258+22 enregistrements lus
228271+1 enregistrements écrits
116875187 octets (117 MB) copiés, 36,8231 s, 3,2 MB/s

10625017 phrases --> 290598 phrases par secondes

Benchmark de 1359971214_DICO.7z :

223092+32 enregistrements lus
223107+1 enregistrements écrits
114230952 octets (114 MB) copiés, 34,7928 s, 3,3 MB/s

10384632 phrases --> 300607 phrases par secondes

Benchmark de 1359971414_DICO.7z :

218943+57 enregistrements lus
218975+1 enregistrements écrits
112115564 octets (112 MB) copiés, 32,8852 s, 3,4 MB/s

10192324 phrases --> 309409 phrases par secondes

Benchmark de 1359971809_DICO.7z :

366110+1186 enregistrements lus
366607+1 enregistrements écrits
187703224 octets (188 MB) copiés, 29,5109 s, 6,4 MB/s

10007266 phrases --> 340672  phrases par secondes

Benchmark de 1359971932_DICO.7z :

464935+1188 enregistrements lus
465480+1 enregistrements écrits
238326148 octets (238 MB) copiés, 33,8596 s, 7,0 MB/s

10008311 phrases --> 294362  phrases par secondes

Benchmark de 1359972263_DICO.7z :

581855+1187 enregistrements lus
582349+1 enregistrements écrits
298163001 octets (298 MB) copiés, 39,1256 s, 7,6 MB/s

10009344 phrases --> 255271   phrases par secondes

Benchmark de 1359972421_DICO.7z :

250643+16 enregistrements lus
250651+1 enregistrements écrits
128333359 octets (128 MB) copiés, 51,9189 s, 2,5 MB/s

11666669 phrases --> 227864  phrases par secondes

Résultats :

Poid total décompressé :1554 MB
Nombre total de phrases : 105569881
Vitesse maximum : 7.6 MB/s
Vitesse minimum : 2,5 MB/s
Moyenne des vitesses : 4,09 MB/s
Débit maximum : 309409 phrases par secondes
Débit minimum : 246093 phrases par secondes
Moyenne des débits : 284700 phrases par secondes

Dernière modification par Yannou90 (04-02-2013 13:08:49)

Hors Ligne

#6 18-04-2013 14:15:51

freekiss
Membre Indéboulonnable
Lieu : Belgique
Inscription : 07-09-2011
Messages : 108

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

tester et approuvé,
merci, je trouve sympa mais faudrais pouvoir faire cela avec que minuscule ou maj et caractere speciaux, etc.
Sinon, parfais, merci


Si j'étais un crapaud, je serais un backtractien, smile

Hors Ligne

#7 18-04-2013 15:51:18

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

C'est gentil de donner un retour wink , je désespérais lol

Mais pour ta remarque c'est tout à fait possible , permute ce base sur un dictionnaire "initial" contenant uniquement les caracteres spécifiés par l'utilisateur : il suffit de créé ce dico  et tout est possible : livebox , freebox , login , anagramme et même toutes les combinaisons possible du loto ou d'euro million ...

Possible egalement avec des morceaux de cléés , enfin tout quoi ...

Si tu souhaites des exemples ou que je précise quelque chose n'hésite pas!

La seul limitation de permute.sh est :
un seul même mot par phrase , une seule même phrase par dico généré

Hors Ligne

#8 18-04-2013 19:16:53

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

À quoi bon gacher du temps à générer et à stocker un dictionnaire à partir d'une expression régulière alors qu'on peut le tester à la volée ?


@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

#9 23-04-2013 04:46:33

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

spawn a écrit :

À quoi bon gacher du temps à générer et à stocker un dictionnaire à partir d'une expression régulière alors qu'on peut le tester à la volée ?

Je ne comprends pas ?
Comment fais-tu ?

Hors Ligne

#10 26-04-2013 16:41:01

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

J'utilise un 'pipe' unix depuis crunch vers l'outil dont je me sers.

Lancer ton script est une perte de temps. (sans animosité aucune wink )
Faire un gros dictionnaire pour le découper sur plusieurs machines est aussi inutile, tu peux découper des portions d'espaces de mots de passe à parcourir avec des expressions régulières.


@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

#11 05-05-2013 21:19:15

Anthonyy59
Membre V.I.P.
Inscription : 03-09-2012
Messages : 277

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Merci pour ce script Yannou90, j'ai une question, j'ai une dartybox dont la clé WPA est longue de 26 caractères, donc j'ai modifier les commandes pour faire des clés de 26 caractères mais je vois qu'il génère des dicos avec le nom "1367784469_PASSE_26.txt" (chiffre augmente de 1 à 26) et le dico se supprime, as-tu une idée?
Et aussi question bête, aircrack teste-il les ":" dans les clés? Merci !

Hors Ligne

#12 05-05-2013 23:21:28

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Bonjour et merci pour le retour .
Ton archive/dico final doit se nommer 1367784469_DICO.txt apres la derniere passe , et pour aircrack , il passe toutes les clées qu'on lui donne .
Sinon si ton dico disparait reellement pourrais tu me renvoyer le retour du terminal par un copier/coller .
Merci

Hors Ligne

#13 06-05-2013 17:30:35

Anthonyy59
Membre V.I.P.
Inscription : 03-09-2012
Messages : 277

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Ah non c'etait une erreur de ma part, en tout cas ton script est vraiment impressionnant niveau compression et bien pensé ! Le tuto est clair, rien à dire wink
Mais une clé comme livebox contenant toutes les lettres de l'alphabet et tout les chiffres de 0 à 9, ça fait pas un peu trop de possibilités pour toutes les essayer?

Hors Ligne

#14 06-05-2013 17:39:38

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Il est bien évident que si tu souhaites essayer toutes les combinaisons , ta vie ne suffira pas !

Maintenant permute.sh cré uniquement des clées sans doublons : un "mot" par phrases et une "phrase" par dico , ce qui réduit énormément le nombre de cléés générées mais ne garantie en rien que ces clées soient valide .
Comme je l'indique , ce script se "moque" de lui même , il présente des statistiques qui permettent de faire comprendre à l'utilisateur que malgrés ses efforts il seront vains !

Je veux dire par là qu'il est évident qu'en essayant toutes les combinaisons on trouvera la bonne clée , mais il faudra quelques milénaires .

Ce script est utile pour créé des clées très personnalisé et ne fonctionne pas du tout comme d'autres générateurs .

Merci pour les retours wink

Hors Ligne

#15 06-05-2013 23:34:18

vances1
Membre Indispensable
Inscription : 20-03-2011
Messages : 530
Site Web

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Ton script pourrait faire des merveilles sur les clés Neufbox si elles sont bien compartimentés au préalable ...

vorg3swebasjiuvlycs3
igenvuchfimthidoruk6
moosgevfiddikiakmid8       
vuvyozind3glekyuptoc       
diottacdoseufvifuct5           
soshbatduedyttadhij9         
defmovholcivlejmarj7       
tedonciwosyek5oggefi   
shewjoijcylj9shnotpi         
yiddotvod5gryidyogcy     
kishleizdytomhunirr9

Et sur les Freebox

concolorum??-persuide?-perminimam6
advolarem!!-denecales8-reorantes3

Dernière modification par vances1 (06-05-2013 23:37:13)


Gagner de l'argent en Bourse https://www.youtube.com/watch?v=mq96BGWfE4U
Travailler à domicile Sondage rémunéré http://www.avis-sondages.fr/
Méthode et solution pour gagner de l'argent sur internet http://www.methodeargent.net/

Hors Ligne

#16 07-05-2013 08:37:47

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Merci
Mais nous nous somme croisé sur un autre topic : ici où justement je donnais 2 dicos spécial freebox .
Bon j'ai une version d'avance sur permute.sh et quelques idées pour générer des dicos spécifiques : livebox , neufbox , freebox ... et une GUI à venir .
Enfin bref , je n'avais pas énormément de retour donc j'ai un peu lâché le developpement ...

Hors Ligne

#17 09-05-2013 18:36:36

keysbreaker
N00b
Inscription : 05-05-2013
Messages : 2

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

AU lieu de perdre du temps a generer un dico ne serait-il pas astucieux d'en telecharger un.
Vraiment pas enrichissant.
Une question big man: T es nouveau dans l domaine  ???

Dernière modification par keysbreaker (09-05-2013 18:55:17)

Hors Ligne

#18 09-05-2013 20:14:09

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Pas compris là ??

T'es en colère , t'as mal quelque part ?
Je vois pas pourquoi tu es  aussi agressif ?
Bon si tu est adepte du clic à gauche ou à droite y'a pas de soucis !

Mon script ne permet que des choses dont j'avais besoin , j'en ai profité pour le partager , c'est tout .
Je n'oblige personne à l'utiliser et si il peut servir tand mieux !

Maintenant si tu peux me trouver des dicos perso qui correspondent exactement à ce dont j'ai besoin c'est cool , mais je ne pense pas que tu le puisse ... enfin bon je m'excuse d'avoir proposé mon petit script , et d'avoir osé le soumettre à ton approbation et ta critique si juste .

Excuse moi encore , je ne le ferais plus

Hors Ligne

#19 09-05-2013 22:53:27

Anthonyy59
Membre V.I.P.
Inscription : 03-09-2012
Messages : 277

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

keysbreaker a écrit :

AU lieu de perdre du temps a generer un dico ne serait-il pas astucieux d'en telecharger un.
Vraiment pas enrichissant.
Une question big man: T es nouveau dans l domaine  ???

Toi qui est si astucieux, poste nous un petit lien vers tes dicos miraculeux ! wink
Je pense que vu la vitesse où le dico se génère, tu prendras plus de temps a le télécharger !

Ne t'en fais pas Yannou90, je pense que tu as eu beaucoup plus de retours positifs que négatifs et ça reste super sympa que tu puisses nous partager tes scripts, tu aurais très bien pu les garder pour toi !

Sinon à propos de tes dicos freebox je suis super intéressé car ils sont rares sur le net, ton post était passé inaperçu, tu devrai essayé de créer de nouveaux topics pour attirer l'attention ! smile

Hors Ligne

#20 09-05-2013 23:40:07

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Merci

Je sais pas si çà vaut le coup de faire un topic pour çà , je peux générer d'autres dicos mais tout les outils sont là ...
Si certains sont interressés je peux en poster d'autres .

Hors Ligne

#21 09-05-2013 23:43:45

Anthonyy59
Membre V.I.P.
Inscription : 03-09-2012
Messages : 277

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Je suis le premier interessé, mais ça vaut vraiment le coup de laisser tourner le pc des jours pour une clé? Comme tu avais di précedement que c'est une perte de temps

Hors Ligne

#22 10-05-2013 07:38:10

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Le mieux est de savoir ce que l'on cherche , dans le cas présent c'est du brute force ...
C'est long , voir très long suivant le matos et ne connaissant pas l'algo de départ c'est pas garantie du tout .

Hors Ligne

#23 23-05-2013 19:01:14

ANONYMOUS38
Membre Actif
Inscription : 09-05-2013
Messages : 25

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

J'ai un probleme, des fois quand je veux generer un dico, il me met :

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 : 0
        Nombre de mots par phrase :5

Pourtant j'ai suivi les instructions a la lettre et je n'ai pas fais d'erreur, je ne comprend pas, peut être devrais-je mettre permute autre part que sur mon bureau?, question peut être bête, mais je trouve ce script tres interessant et j'aimerais en savoir un peu plus, et la prochaine version, c'est pour quand?

Cordialement
Merci de vos réponses.

Dernière modification par ANONYMOUS38 (23-05-2013 19:07:01)

Hors Ligne

#24 23-05-2013 20:45:43

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Merci

Pour ton soucis : permute.sh traite par défaut un "dictionnaire" de base en fonction de la longueur des "mots" qui le composent : par défaut minimum = 1 , maximum = 4

Si tu traite de longueur de chaine spécifique tu dois appliquer un filtre sur ton dictionnaire de base , par exemple :
tout les "mots" de 5 (-l 5) à 8 ( -L 8 ) caractéres :

permute.sh -i dico_base.txt -l 5 -L 8

Hors Ligne

#25 23-05-2013 21:01:03

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

Re : Générer 1 million de clefs hexadécimales de 10 caractères pour 6kb

Suivant les filtres appliqués ton dictionnaire est plus ou moin garni !

Si tu souhaite plus de permutations que de mots composants ton dico tu te prend une erreur :

- ou tes filtres sont trop restrictifs -> pas/peu de mots dans le dico
- ou tu souhaites l'impossible ; ex : composé des phrases de 3 mots permutés dans une liste de 2 mots sans répétition d'un même mot dans une même phrase

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...

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.038 seconds ]   Forum Stat - [ Most users ever online on the forum was : 150 on 20-09-2009 17:06:59 ]