Ubuntu-fr

nesthib

[JEU] challenge bash #4

[informations sur le jeu]

<<    challenge bash #4   >>

génération d'un mot de passe

le challenge consiste à réaliser un script capable de générer un mot de passe aléatoire. Attention à la simplicité apparente du challenge, devant le grand nombre de méthodes disponibles nous serons très critiques quand à la qualité du script, son originalité et son utilisabilité (méthode de génération du mot de passe, options du script, …)

contrainte : le mot de passe doit pouvoir comporter minuscules / MAJUSCULES / caractères spéciaux : $%!-#~"*'[]?@,.;

Soyez d'autant plus attentifs que ce challenge est le premier d'une série de 3 challenges imbriqués !

---

GUL Bordeaux : Giroll – Services libres : TdCT.org
Hide in your shell, scripts & astuces :  applications dans un tunnel – smart wget – trouver des pdf – install. auto de paquets – sauvegarde auto – ♥ awk
  ⃛ɹǝsn xnuᴉꞁ uʍop-ǝpᴉsdn

nesthib

Re : [JEU] challenge bash #4

solution de sputnick :

#!/usr/bin/env bash
#
# ------------------------------------------------------------------
#	 made by sputnick in da FreAkY lApPy lAb (c) 2009
# 	 gilles.quenot <AT> gmail <DOT> com
#
#    This program is free software; you can redistribute it and/or
#    modify it under the terms of version 2 of the GNU General Public
#    License published by the Free Software Foundation.
#	 	(see http://www.gnu.org/licenses/gpl.html).
#
# ------------------------------------------------------------------
#   ,,_
#  o"  )@
#   ''''
# ------------------------------------------------------------------
# vim:ts=4:sw=4
#
# password-generator.bash comme son nom l'indique, génère un mot de passe alleatoire
#   en se servant de la table ASCII en decimale.
# ( On convertit le nombre decimal en octal pour l'affichage ).
# Par defaut sans arguments, on affiche un mot de passe avec des caracteres 
#   alphanumeriques d'une longueur de 7 caracteres.
# Pour afficher des caracteres speciaux on utilise le flag -s comme Special.
# Pour definir de façon arbitraire la longueur du mot de passe, on utilise le flag -l

while getopts "l:sh" opt; do
	case $opt in
		l) len=$OPTARG ;;
		s) cas=ALL ;;
		*) printf "Usage :\n\t${0##*/} [-l <N>] [-sh]\n\nSyntax:\n\t-l\tlength integer\n\t-s\tadd special caracters\n\t-h\tthis help\n"; exit 1 ;;
	esac
done

ALNUM="{48..57} {65..90} {97..122}" ALL="{33..126}" cas=${cas:=ALNUM} ARR=( $(eval echo ${!cas}) ) arrcount=${#ARR[@]} len=${len:-7}

for ((i=0; i<len; i++)); do printf \\$(printf '%03o' ${ARR[RANDOM%arrcount]}); done; echo

solution de Totor :

#!/bin/bash

myHelp()
{
	[ $# -ne 0 ] && echo >&2 -e  "$@"
	cat >&2 <<EOF
	Usage : ${0##*/} [[-c <key=value>] ...] [[-q <key=value>]...] [[-u <key=value>] ...] [-n <number>] [-d]

	Options:
	-c : Définition d'une classe (jeux de caractères)
	-q : Indique la quantité de caractères de la classe devant être présents dans le mot de passe (nombre >=0)
	-u : Indique si les caractères de la classe peuvent être en doublon dans le mot de passe (1 : unique; <>1 : doublon autorié)
	-d : Utilise le device /dev/urandom plutôt que la variable bash RANDOM
	-n : Nombre de mot de passe à générer (1 par défaut)

	Valorisation:
	key : indentifiant numérique de la classe (>=0)
	value : valeur de l'option pour la classe donnée


	Classes:
	Il existe 4 classes definies par défaut :
	0 : ${charsMin}
	1 : ${charsMaj}
	2 : ${charsDig}
	3 : ${charsSpe}

	Si l'option -c est utilsée avec une "key" ayant une valeur déjà définie alors la classe correspondante est écrasée.
	Si un caractère est commun à deux classes, la géneration du mot de passe n'a pas lieu.


	Quantités et unicités :
	La quantité par defaut est 2.
	L'unicité par defaut est 1 (donc un caractère ne peut être en doublon).
EOF
	[ $# -ne 0 ] && exit 1
	exit 0
}

# suppression des espaces ajoutés par la commande {X..Y}
deleteSpaces()
{
	chars="$@"
	echo "${chars// }"
}

# Ajoute le caractère d'échappement avant tous les caractères de la chaine passée en paramètre
getPattern()
{
	pattern=""
	for((idx=0;idx<${#1};idx++))
	do
	  pattern="${pattern}\\${1:${idx}:1}"
	done
	echo "${pattern}"
}

# verification du format key=valeur
verifOptionValue()
{
	def="$1"
	txt="$2"

	[[ "${def}" != *=* ]] && myHelp "Valeur non valide pour l'option ${option} : ${def}"

	id="${def%%=*}"
	value="${def#*=}"
	# test de la valeur de id
	ID="${id}"
	( ((id*=1)) || ((id==0)) )  && ((id>=0)) || myHelp "Identifiant non valide ${txt} : ${ID}"

	nomTab="tab${id}"
	
	# si la classe n'existait pas, on définit les valeur par défaut pour le nom du tablea, la quantité et l'unicité
	
	[ ! "${tabTab[${id}]}" ] && { 
		tabTab[${id}]="${nomTab}"
		eval "${nomTab}=\"\""
	}
	[ ! "${tabUnq[${id}]}" ] && tabUnq[${id}]=${defaultUnq}
	[ ! "${tabQte[${id}]}" ] && tabUnq[${id}]=${defaultQte}
}

# definition d'une classe depuis une valeur passée à l'option -c  en ligne de commande
setClass()
{
  verifOptionValue "$1" "de classe"
  
  # on definie le nom dans le tableau  
  tabTab[${id}]="${nomTab}"
  # valorisation de la liste des caractère de la classe

  eval "${nomTab}=\"${value}\""
}

# définitition d'une quantité de caractère à inclure dans le password depuis une valeur passée à option -q de la ligne de commande
setQte()
{
	verifOptionValue "$1" "de quantité"
	
	val="${value}"	
	( ((value*=1)) || ((value==0)) ) && ((value>=0)) || myHelp "Quantité non valide pour l'id ${id} : ${val}"
	
	tabQte[${id}]="${value}"
}

# définitition d'une quantité de caractère à inclure dans le password depuis une valeur passée à option -q de la ligne de commande
setUnq()
{
	verifOptionValue "$1" "d'unicité"
	
	val="${value}"
	( ((value*=1)) || ((value==0)) ) && ((value>=0)) || myHelp "Unicitée non valide pour l'id ${id} : ${val}"
	
	tabUnq[${id}]="${value}"
}

# generation du password
genPwd()
{
	pwd=""
	allChars=""
	tabChars=()

	for((index=0;index<${#tabTab[@]};index++))
	do
		chars=""
		[ ${tabQte[${index}]} -lt 0 ] && tabQte[${index}]=0
		[ ${tabQte[${index}]} -ne 0 ] && {
			nomTab="${tabTab[${index}]}"
			chars="${!nomTab}"
			tabChars[${index}]="${chars}"
			allChars="${allChars}${chars}"
			[ ${tabQte[${index}]} -gt ${#chars} ] &&  [ ${tabUnq[${index}]} -eq 1 ] && tabQte[${index}]=${#chars}
		}
		[ ! "${chars}" ] && tabQte[${index}]=0
		tabRes[${index}]=tabQte[${index}]
	done

	length="${tabQte[@]}"
	length="${length// /+}"
	length=$((${length}))

	while [ ${#pwd} -lt ${length} ];
	do
		# commenter pour ne pas utiliser le device /dev/urandom
		${useRandom} && {
			index=$((${#allChars}*${RANDOM}/32768))
			char="${allChars:${index}:1}"
		} || IFS="" read -n1 char < /dev/urandom

		[ "${allChars}" ] && pattern="$(getPattern "${allChars}")" || char=""

		char="${char/[^${pattern}]}"

		[ "${char}" ] && {
			# recherche du tableau auquel appartient le caractere
			for ((index=0; index<${#tabTab[@]}; index++))
			do
			[ "${tabChars[${index}]}" ] && {
				# il y a des caractères dans cette classe, on peut la vérifier
				pattern="$(getPattern "${tabChars[${index}]}")"
				[ "${char//[^${pattern}]}" ] && {
					# on a trouve le tableau
					# on peut rajouter le caractère au mot de passe car il reste au moins 1 caractère de cette classe à positionner dans le pwd
					pwd="${pwd}${char}"
					# on décrémente le nombre de caractères restant à ajouter pour cette classe
					tabRes[${index}]=$((${tabRes[${index}]}-1))

					[ ${tabUnq[${index}]} -eq 1 ] && {
						# le caractère ne doit être présent qu'une seule fois, on le supprime donc des caractères autorisés
						unChar="\\${char}"
						tabChars[${index}]="${tabChars[${index}]//${unChar})}"
						allChars="${allChars//${unChar}}"
					}

					[ ${tabRes[${index}]} -eq 0 ] && {
						# on ne peut plus mettre de caractères de cette classe, on supprime donc tous les caractères de cette classe à ceux autorisés
						pattern="$(getPattern "${tabChars[${index}]}")"
						allChars="${allChars//[${pattern}]}"
						tabChars[${index}]=""
					}
				}
			}
			done
		}
	done
	echo "${pwd}"
}

# verification ne caractères en commun entre 2 classes
verifClass()
{
	for ((index=0;index<$((${#tabTab[@]}-1));index++))
	do
		nomTab="${tabTab[${index}]}"
		chars="${!nomTab}"
		for((idx=$((index+1)); idx<${#tabTab[@]};idx++))
		do
			nomTab="${tabTab[${idx}]}"
			charsT="${!nomTab}"
			pattern="$(getPattern "${charsT}")"
			[[ "${chars}" == *[${pattern}]* ]] && myHelp "Des caractères sont en communs entre deux classes : \n\tclasse n°${index}=${chars}\n\tclasse n°${idx}=${charsT}"
		done
	done
}

# tableau des caractères autorisés
charsMin="$(deleteSpaces {a..z})"
charsMaj="$(deleteSpaces {A..Z})"
charsDig="$(deleteSpaces {0..9})"
charsSpe="$ %~*'[]?@;.><()\"!"

defaultQte=2
defaultUnq=1
nbPwd=1

# tableau contenant la liste des tableaux
tabTab=( charsMin charsMaj charsDig charsSpe )
tabQte=( ${defaultQte} ${defaultQte} ${defaultQte} ${defaultQte} )
tabUnq=( ${defaultUnq} ${defaultUnq} ${defaultUnq} ${defaultUnq} )

userRandom=true
while getopts :c:q:u:n:dh option
do
  case "${option}" in
    c) setClass "${OPTARG}";;
    q) setQte "${OPTARG}";;
    u) setUnq "${OPTARG}";;
    d) useRandom=false;;
	n) nbPwd="${OPTARG}"
		((nbPwd*=1)) && ((nbPwd>=1)) || myHelp "Nombre de mot de passe à générer non valide : ${OPTARG}";;
    h) myHelp; exit;;
    :) myHelp "Argument manquant pour l'option '${OPTARG}'";;
    ?) myHelp "Option non valide : ${OPTARG}.";;
  esac
done

verifClass

for((cpt=1;cpt<=${nbPwd};cpt++))
do
	genPwd
done

---

GUL Bordeaux : Giroll – Services libres : TdCT.org
Hide in your shell, scripts & astuces :  applications dans un tunnel – smart wget – trouver des pdf – install. auto de paquets – sauvegarde auto – ♥ awk
  ⃛ɹǝsn xnuᴉꞁ uʍop-ǝpᴉsdn

n3o51

Re : [JEU] challenge bash #4

donc une ligne en perl ça compte pas

je sais ou es la sortie <===

Dernière modification par n3o51 (Le 21/02/2010, à 01:47)

---

Welcome to the real world
________________________________

nesthib

Re : [JEU] challenge bash #4

@n3o51 : fais comme tu veux après à nous de juger (mais on ne sait jamais, et puis tu peux proposer plusieurs solutions…)

---

GUL Bordeaux : Giroll – Services libres : TdCT.org
Hide in your shell, scripts & astuces :  applications dans un tunnel – smart wget – trouver des pdf – install. auto de paquets – sauvegarde auto – ♥ awk
  ⃛ɹǝsn xnuᴉꞁ uʍop-ǝpᴉsdn

n3o51

Re : [JEU] challenge bash #4

Effectivement mais cela n'inclus aucune option

ça génère un passe de 10 caractères

perl -e '@pass=("A".."Z",0..9,"a".."z");print join("",@pass[map{rand @pass}(1..10)])'

résultat :

0JB9RgrLJa

---

Welcome to the real world
________________________________

nesthib

Re : [JEU] challenge bash #4

et les caractères spéciaux ?

---

GUL Bordeaux : Giroll – Services libres : TdCT.org
Hide in your shell, scripts & astuces :  applications dans un tunnel – smart wget – trouver des pdf – install. auto de paquets – sauvegarde auto – ♥ awk
  ⃛ɹǝsn xnuᴉꞁ uʍop-ǝpᴉsdn

Yannou90

Re : [JEU] challenge bash #4

Bonsoir (rebonsoir )
Methode gros tricheur :

pwgen -s -y -1 20 1

ce qui donne:

]c>!5CP"ZN@taeF&zCU=

Donc , pour que les choses soient clair , il faut produire un script equivalent a l'utilisation de pwgen ?!?
Il va me falloir 2/3 bassines de caféine , une perfusion , et un cendrier maousse costos comme dirait l'autre !!

Dernière modification par Yannou90 (Le 21/02/2010, à 21:58)

nicolas66

Re : [JEU] challenge bash #4

Bon, je me lance même s'il me paraît évident qu'on puisse faire plus court :

#!/bin/bash
###########################################################################
# Filename    : random_string.sh                                          #
# Description : generates a random string of given length                 #
# Author      : nicolas66                                                 #
# Last release: 21-02-2010                                                #
###########################################################################

###### Functions ######
function usage()
{
	local COMMAND="`basename $0` [-n] [-d] [-s] length"

cat << EOF
usage: ${COMMAND}

generates a random string of given length

OPTIONS:

 -n  string length (default 10)
 -d  use digits (default no)
 -s  use special chars (default no)
 -h  show this message
EOF
}

######### Core ########
# Variables
USE_DIGITS="no"
USE_SPECIAL_CHARS="no"
STR_LENGTH=10

# We parse input arguments
while getopts "hdsn:" OPT
do
	case "${OPT}" in
		h)
			usage && exit 0;;
		d)
			USE_DIGITS="yes";;
		s)
			USE_SPECIAL_CHARS="yes";;
		n)
			STR_LENGTH="${OPTARG}";;
		\?)
			usage && exit 1;;
	esac
done

# We check if the string length is a valid integer
if ! grep -q "^[1-9][0-9]*$" <<< ${STR_LENGTH}; then
	echo "error: the string length must be a strictly positive integer"
	exit 1
fi

# We generate a random string
chars="A-Za-z"

[ ${USE_DIGITS} = "yes" ] && chars="${chars}0-9"
[ ${USE_SPECIAL_CHARS} = "yes" ] && chars="${chars}~\"#'{([-|\`_\\^@])=+}\$%*!?,;./"

cat /dev/urandom | tr -dc "${chars}" | head -c ${STR_LENGTH}

exit 0

EDIT 1 : rajout de deux options
EDIT 2 : corrections de nesthib, ajout de caractères spéciaux

Dernière modification par nicolas66 (Le 21/02/2010, à 23:05)

---

"The computer was born to solve problems that did not exist before." (B. Gates)

Yannou90

Re : [JEU] challenge bash #4

Bon ben vite fait et a corriger :

#!/bin/bash

OPT_PASS=$1
RAND_PASS=
NBR_PASS=10
MAJ_PASS='A-Z'
MIN_PASS='a-z'
SPE_PASS='~"#{([-|`_\'

PERSO_PASS()
{
printf "Définissez les caractères\n"
read RAND_PASS
}

MAN_PASS()
{
printf "Utilisation : [script] [-nMmsp]\n-n=Nombre de caractères\n-M=Majuscule\n-m=Minuscule\n-s=Caractères spéciaux\n-p=Caractères définis par l'utilisateur\n-h=Afficher les options disponibles\n"
}

if [ $# = 0 ]
then
MAN_PASS
exit 1
fi

while getopts ":nMmsp" OPT_PASS
  do
	case "$OPT_PASS" in
	n )
	printf "Nombre de caractères du mot de passe\n"; read NBR_PASS;;
    	M )
    	RAND_PASS=$RAND_PASS$MAJ_PASS;;
    	m )
    	RAND_PASS=$RAND_PASS$MIN_PASS;;
    	s )
    	RAND_PASS=$RAND_PASS$SPE_PASS;;
    	p )
    	PERSO_PASS;;
    	h )
    	MAN_PASS;;
    	* )
    	MAN_PASS;;
	esac
done
grep -a -o "[$RAND_PASS]" /dev/urandom | tr -d "\n" | head -c "$NBR_PASS"
echo
exit

Par contre 2 tiot soucis (je trouverais pourquoi et comment

-Je me suis inspirer du script de AnsuzPeorth (http://forum.ubuntu-fr.org/viewtopic.php?pid=3275745#p3275745) pour getopts mais j'ai une erreur avec grep ?!
-J'ai essayer d'inclure tout les caracteres que j'ai trouver mais cela ne fonctionnait pas j ai encore du mal avec ces bêbête , j'ai donc reduit le nombre de caractere et oh surprise,sans les mettres tous ils apparaissent dans le resultat ?!?
La syntaxe employée permet elle alors l'utilisation de TOUT les caracteres speciaux ?

nesthib

Re : [JEU] challenge bash #4

@nicolas66 :

! echo "${STR_LENGTH}" | grep -q "^[1-9][0-9]*$"

n'est pas très habile et peut être remplacé par :

! grep … <<<${STR_LENGTH}

ou encore mieux

[ ${STR_LENGTH} -gt 0 ] 2>/dev/null

--------------------------------

for k in `seq 1 ${STR_LENGTH}`

par

for ((k=1 ; k<=${STR_LENGTH} ; k++))

---

GUL Bordeaux : Giroll – Services libres : TdCT.org
Hide in your shell, scripts & astuces :  applications dans un tunnel – smart wget – trouver des pdf – install. auto de paquets – sauvegarde auto – ♥ awk
  ⃛ɹǝsn xnuᴉꞁ uʍop-ǝpᴉsdn

Yannou90

Re : [JEU] challenge bash #4

Edit:Bon j'ai modifié mon script et compris d'où venaient ces caractères , suis-le bête des fois !

Bonjour

Apres m'être arraché la moitié des cheveux j'ai quelque chose qui tiend a peu près la route !

Utilisation :
[script] [-nMmspc] [defaut=-Mmsc]
-M=Majuscule
-m=Minuscule
-s=Caractères spéciaux
-n=Nombre de caractères
-c=Nombre
-p=Choix des caractères par l'utilisateur
-h=Afficher les options disponibles
Le script :

#!/bin/bash

OPT_PASS=$1
NBR_PASS=10
MAJ_PASS='A-Z'
MIN_PASS='a-z'
CHI_PASS='0-9'
SPE_PASS=',-|'
DEF_PASS="$MAJ_PASS$MIN_PASS$CHI_PASS$SPE_PASS"

MAN_PASS()
{
printf "Utilisation : [script] [-nMmsp]\n-n=Nombre de caractères\n-M=Majuscule\n-m=Minuscule\n-s=Caractères spéciaux\n-c=Nombre\n-p=Caractères définis par l'utilisateur\n-h=Afficher les options disponibles\n"
}

[ "$OPT_PASS" = '-n' ] && RAND_PASS="$DEF_PASS"

while getopts ":nMmscp" OPT_PASS
  do
	case "$OPT_PASS" in
	n )
	printf "Nombre de caractères du mot de passe\n"
	read NBR_PASS;;
    	M )
    	RAND_PASS=$RAND_PASS$MAJ_PASS;;
    	m )
    	RAND_PASS=$RAND_PASS$MIN_PASS;;
    	s )
    	RAND_PASS=$RAND_PASS$SPE_PASS;;
    	c )
    	RAND_PASS=$RAND_PASS$CHI_PASS;;
    	p )
    	printf "Définissez les caractères\n"
	read RAND_PASS;;
    	h )
    	MAN_PASS && exit 0;;
    	* )
    	MAN_PASS && exit 1;;
	esac
done

[ $# = 0 ] && RAND_PASS="$DEF_PASS"

grep -a -o "[$RAND_PASS]" /dev/urandom | tr -d "\n" | head -c "$NBR_PASS"
echo
exit 0

Exemple:

moguaye52@nunux:~$ /home/moguaye52/Bureau/script.sh
e9c3*YcpR$
moguaye52@nunux:~$ /home/moguaye52/Bureau/script.sh -sn
Nombre de caractères du mot de passe
40
'=/#'|}=\`)={`>*\>)*+*}<{}|'>}"<+&?<+>:>

Dernière modification par Yannou90 (Le 21/02/2010, à 15:13)

AnsuzPeorth

Re : [JEU] challenge bash #4

Bjr,
J'avais justement fait un petit script y'a un baille pour générer des mots de passe. Je l'ai volontairement compliqué un peu  (niveau lecture du script, et il n'y a plus les caractères écrit en 'dur').
J'utilse la commande random et modulo pour obtenir un résultat pseudo-aléatoire (à l'époque, de nombreux essais m'avais permis de trouver cette solution pour avoir de bon résultats, même sur une petite séquence de caractères 'source').

abs.traduc:

Un vrai « hasard », si tant est qu'il puisse exister, peut seulement être trouvé dans certains phénomènes naturels compris partiellement tels que la destruction radioactive. Les ordinateurs simulent le hasard et les séquences générées par ordinateur de nombres « aléatoires » sont du coup appelés pseudo-aléatoires

#!/bin/bash
ch="60 71"
min="141 172"
maj="101 132"
spe="41 57 72 100 133 140 173 175"

function Usage() 
{
echo "Usage : ./scritp.sh [-mMcsA] [nb caractères] [nb pass]
Script sans arguments, options: -A 6 5
Options :
   -m    minuscule
   -M    MAJUSCULE
   -c    chiffre
   -s    caractères spéciaux 
   -A    all
   -h    Aide"
exit
}

function GenPass ()
{
while [ "${#tab[@]}" -gt 0 ]
    do
	for ((i=${tab[0]};i<=${tab[1]};i++)); do
		[[ "$i" =~ [89] ]] && continue
		tab1=( ${tab1[@]} \\$i ); done  
	tab[0]=; tab[1]=; tab=( ${tab[@]} )
    done 
     
for ((i=1;i<=${nbc:=6};i++))
    do   
        pass="${pass}${tab1[$((RANDOM%${#tab1[@]}))]}"
    done  
printf "$pass\n"
unset pass
}

if [ -z "$*" ]; then
	var="$min $maj $ch $spe"
else
	while getopts ":mMcsA" Option
	  do
	    case $Option in
	        m)
	         var="${var} $min";;
	        M)
	         var="${var} $maj";;
	        c)
	         var="${var} $ch";;
	        s)
	         var="${var} $spe";;
	        A)
	         var="$min $maj $ch $spe";;
	        *|h)
	         Usage;;
	    esac
	  done
	shift $(($OPTIND - 1))
	nbc=$1
	nbp=$2
fi

tab=( $var )

for ((d=1;d<=${nbp:=5};d++))
    do
	GenPass
    done
exit

~$ /challenge4.sh 
F7g3t"
#$Sl2|
@Pn3mg
/6C/!A
dWMS|e

~$ /challenge4.sh -mMs 10 2
bUT`[ksDKi
V>Qm\!ZPD.

EDIT; Je me suis limité aux caractères spéciaux habituels, j'aurais pu en ajouter d'autres (en faisant légèrement différent), mais problème d'encodage lors de la copie vers fichier, pourtant, le résultat était ok en console.

Dernière modification par AnsuzPeorth (Le 21/02/2010, à 18:32)

---

Interface graphique pour bash, python ou autre: glade2script
Support Tchat: http://chat.jabberfr.org/muckl_int/inde … ade2script  (Hors ligne)

nicolas66

Re : [JEU] challenge bash #4

@nesthib > Peux-tu expliquer ce qui justifie tes modifs' ?

---

"The computer was born to solve problems that did not exist before." (B. Gates)

Ph3nix_

Re : [JEU] challenge bash #4

Plop les gens, voici ma contribution:

#!/bin/bash
CARAC=( '+ = $ % ! - # ~ " * [ ] ? @ , . ;' "$(echo {A..Z} {a..z})" "$(echo {0..9})" )
NB=( 2 5 3 10 )

gen() {
	n=$((RANDOM%3))
	[ ${NB[$n]} -gt 0 ] && {
		NB[$n]=$((NB[n]-1))
		PWD_="$PWD_""${CARAC[$n]:$((RANDOM%$((${#CARAC[$n]}/2))*2)):1}"
		((NB[3]--)); }
	[ ${NB[3]} -gt 0 ] && gen
}
gen
echo "$PWD_"

J'ai pas fait de gestion des options, mais il serait facile d'en rajouter une:

NB=( 2 5 3 10 )

- Le premier chiffre correspond au nombre de caractères spéciaux dans le mot de passe (ici 2)
- Le second au nombre de caractères alphabetiques (abcd.....zABC...Z) (ici 5)
- Le troisième au nombre de chiffre (ici 3)
- Le dernier a la taille du mot de passe (la somme des 3 précédents)

Les mot de passe généré sont 100% aléatoires (exemple d'exécution):

D*A@2Yk6R8
!8q5-4qUlq
?rh+iuc815
%%36W2whge
13[E2Kq+nw
54.6@hQoXi
IIXW.@F106
e=*3D3h7tv
[7FQ*11RmX
$gv%8hhp55
3x51-"vvLL
7.8~3lnInM
[3$17jKkVd
=w~034LsWQ
*O?16b4IUr
2F=d48vAi+
6=j11N%EtT
V8av~~0vL0
qe2[?61CTI
+u5O=X0e3y

---

Hiroshima 45 / Chernobyl 86 / Windows '95

toto2006

Re : [JEU] challenge bash #4

bon ma solution est un peu laborieuse

#!/bin/bash

NB_ALPHA_CHARS=8 
NB_NUMERIC_CHARS=0 
NB_SPECIAL_CHARS=0 
NB_CAPS_CHARS=0  
SPECIAL_CHARS="\$%!-#~\"*'[]?@,.;"
ALPHA_CHARS_CONS="bcdfghjklmnpqrstvwxz"
ALPHA_CHARS_VOY="aeiouy"
NUMERIC_CHARS="0123456789"
CAPS_CHARS="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
NB_MDP=1

usage(){

cat << EOF

  usage: ${0} [OPTION...]

  GENERE (NB_MDP FOIS) UN MOT DE PASSE ALEATOIREMENT.
  
  Contenant:
   
  NB_ALPHA_CHARS  caracteres alphabetiques 
  NB_SPECIAL_CHARS  caracteres speciaux  
  NB_NUMERIC_CHARS caracteres numeriques 
  
  NB_CAPS_CHARS designe le nombre de caracteres majuscules
  parmis les NB_ALPHA_CHARS caracteres alphabetiques. 
  
  OPTIONS:

  -h  THIS HELP
  -a  NB_ALPHA_CHARS (default 8)
  -m  NB_SPECIAL_CHARS (default 0)
  -c  NB_NUMERIC_CHARS (default 0)
  -j  NB_CAPS_CHARS (default 0)
  -n  NB_MDP (default 1)
  
EOF

}

GenereMdp(){

	for ((i=0; i < NB_ALPHA_CHARS; i++)){	
		 [ "$i" -lt "$NB_CAPS_CHARS" ] && mdp="$mdp${CAPS_CHARS:$(($RANDOM % 26)):1}"  || {				
			[ $((i%2)) == 0 ]  && mdp="$mdp${ALPHA_CHARS_CONS:$(($RANDOM % 20)):1}" ||  mdp="$mdp${ALPHA_CHARS_VOY:$(($RANDOM % 6)):1}"
		}
	}
	for ((i=0; i <NB_NUMERIC_CHARS ; i++)){
		mdp="$mdp${NUMERIC_CHARS:$(($RANDOM % 10)):1}"
	}
	for ((i=0; i <NB_SPECIAL_CHARS ; i++)){
		mdp="$mdp${SPECIAL_CHARS:$(($RANDOM % 16)):1}"
	}

}

MelangeMdp(){	
	
	chaine=$1
	TC=${#chaine}
	mdp=""	
	
	for((i=0;i<TC;i++)){			
		Tchaine=${#chaine}	
		RND=$(($RANDOM % $Tchaine))						
		mdp="$mdp${chaine:$((RND)):1}"
		
		tmp=""		
		for((j=0;j<Tchaine;j++)){
			[ $((RND)) != $((j)) ] && tmp=$tmp${chaine:$((j)):1}			
		}
		chaine=$tmp		
	}
}

TestVar(){

	var=$1
	
	[ $var -eq 0 ] 2> /dev/null
	[ $? -ne 0 -a $? -ne 1 ] && {
		echo "Erreur $1 n'est pas un entier"
		exit 1
	}

}


while getopts "ha:m:c:j:n:" Option
do
	case $Option in
	 h )
	    usage && exit 0;;
        a)
            NB_ALPHA_CHARS=$OPTARG  && TestVar  $NB_ALPHA_CHARS;;
        m)
            NB_SPECIAL_CHARS=$OPTARG && TestVar  $NB_SPECIAL_CHARS;;
        c)
            NB_NUMERIC_CHARS=$OPTARG && TestVar  $NB_NUMERIC_CHARS;;
	j)
            NB_CAPS_CHARS=$OPTARG && TestVar  $NB_CAPS_CHARS;;	
	n)
            NB_MDP=$OPTARG && TestVar  $NB_MDP;;	
	    
        esac
done


for((a=0;a<NB_MDP;a++)){
	
	mdp=""
	GenereMdp
	MelangeMdp $mdp
	echo $mdp
}

exit 0

 ./mdp.sh -a 5 -m1 -c 2 -j2 -n 5
w2~6iFRs
Kg8Gen0@
4z]WzS7o
F'n20Wfi
0IlE-h8a

sputnick

Re : [JEU] challenge bash #4

@nesthib > Peux-tu expliquer ce qui justifie tes modifs' ?

nesthib t'explique que ta syntaxe est un peu "tordue". C'est pas des modifs, c'est des pistes d'améliorations. T'es pas obligé

Pour manipuler les chiffres la syntaxe avec les parenthèses me semble plus adaptée.

Pourquoi écrire

[ $var -lt 6 ]

quand on peux écrire simplement

(( var < 6 ))

?

Et puis quitte à utiliser les

[ ]

autant utiliser la version full bash

[[ ]]

qui est plus évoluée :
[[ $var -lt 6 ]]

<greybot> [[ is a bash keyword similar to (but more powerful than) the [ command. See http://mywiki.wooledge.org/BashFAQ/031 and http://mywiki.wooledge.org/BashGuide/Practices/BashTests Unless you are scripting for POSIX sh we recommend [[.

Dernière modification par sputnick (Le 21/02/2010, à 20:20)

---

Je sais, un peu partout, tout le monde s'entretue, c'est pas gai, mais d'autres s'entrevivent, j'irai les retrouver. Jacques Prévert
https://sputnick.fr

nicolas66

Re : [JEU] challenge bash #4

nesthib t'explique que ta syntaxe est un peu "tordue".

Perso, je trouve ça plus court d'utiliser seq que d'écrire la boucle en entier. Je pense que les scripts vont surtout différer sur la méthode de génération aléatoire. J'ai un doute sur la qualité des nombres pseudo-aléatoires obtenus via la variable RANDOM. Le mieux serait sans doute d'utiliser la batterie de tests NIST.

---

"The computer was born to solve problems that did not exist before." (B. Gates)

nesthib

Re : [JEU] challenge bash #4

l'intérêt de [ $var -gt 0 ] est que le test retourne un code d'erreur si var <= 0 et si var n'est pas un entier (pas (( var > 0 )) , enfin que dans un sens, je ne sais pas pourquoi…) mais on peut tout à fait utiliser la syntaxe [[ ]]

pour seq ce n'est pas une question d'être plus court mais plus efficace `seq …` = 1 process pour seq, 1 pour `…`

---

GUL Bordeaux : Giroll – Services libres : TdCT.org
Hide in your shell, scripts & astuces :  applications dans un tunnel – smart wget – trouver des pdf – install. auto de paquets – sauvegarde auto – ♥ awk
  ⃛ɹǝsn xnuᴉꞁ uʍop-ǝpᴉsdn

Yannou90

Re : [JEU] challenge bash #4

PFFFFFF...:rolleyes:
On les voit les docteurs !!

Bon ben je reprends mon sac de billes et je me pose vite fait dans un couin(couin)
Euhhhh , ici

x<--

Sans rire ,y'a du lourd là , çà calme bien!
Mais pourquoi etais-je tand rebelle dans mes années college !
POURQUOI
x<--(j'y retourne)

AnsuzPeorth

Re : [JEU] challenge bash #4

Re,
Bon, j'ai rajouté des caractères. (j'aurais pu en ajouter plus, mais bon, ca suffit là, pour le cracker ce pass ... !)

#!/bin/bash

ch="48 57"
min="97 122"
maj="65 90"
spe="33 47 58 64 91 96 123 126"
spe1="194_161 194_172 194_174 194_191 195_128 195_191 196_128 196_191 197_128 197_191"
function Usage() 
{
echo "Usage : ./scritp.sh [-mMcsAS] [nb caractères] [nb pass]
Script sans arguments, options: -A 6 5
Options :
   -m    minuscule
   -M    MAJUSCULE
   -c    chiffre
   -s    caractères spéciaux 
   -A    all [-mMcs]
   -S    autres caractères spéciaux   
   -h    Aide"
exit
}

function GenPass ()
{
n=0
while [ "${#tab[@]}" -gt 0 ]
    do
	if [[ ${tab[0]} =~ _ ]]; then
	    MIN=${tab[0]/*_/}
	    MAX=${tab[1]/*_/}
	    IND=${tab[0]/_*/}
	    flag=1
	else
	    MIN=${tab[0]}
	    MAX=${tab[1]}
	    flag=0
	fi
	for ((i=$MIN;i<=$MAX;i++)); do
	n=$((n+1))
		if [ $flag = 1 ]; then
		   tab1=( ${tab1[@]} $(printf "%x_%x" $IND $i) )
		else
		   tab1=( ${tab1[@]} $(printf "%x" $i) )		
		fi
	 done  
	tab[0]=; tab[1]=; tab=( ${tab[@]} )
 
printf "$n caractères utilisés\r"    
    done 

for ((i=1;i<=${nbc:=6};i++))
    do   
        pass="${pass}\x${tab1[$((RANDOM%${#tab1[@]}))]//_/\x}"
    done  
printf "\n$pass"
unset pass
}

if [ -z "$*" ]; then
	var="$min $maj $ch $spe"
else
	while getopts ":mMcsAS" Option
	  do
	    case $Option in
	        m)
	         var="${var} $min";;
	        M)
	         var="${var} $maj";;
	        c)
	         var="${var} $ch";;
	        s)
	         var="${var} $spe";;
	        S)
	         var="${var} $spe1";;
	        A)
	         var="$min $maj $ch $spe";;
	        *|h)
	         Usage;;
	    esac
	  done
	shift $(($OPTIND - 1))
	nbc=$1
	nbp=$2
fi

tab=( $var )

for ((d=1;d<=${nbp:=5};d++))
    do
	GenPass
    done
echo
exit

~$ './challenge4.sh' -A 10 5
94 caractères utilisés
UVQ$&,<y[X
76}W-J[?J|
\Dg=&C8?j)
27&t}-m=b:
cm[NL&2<*D

~$ './challenge4.sh' -AS 10 5
316 caractères utilisés
ÜË!ċÃų4dcM
ņŝÈ\ŇÔőªįň
'ĺšúäłŕï¨Ī
ÍEÞżĦŭ7ſxŖ
Ïĥ3ĤĜĽąz8ļ

EDIT: J'ai fait un essais sur 5000 pass générés (min,Maj,chiffres), pas de doublons, donc l'aléatoire est efficasse ! (il faudrait tester sur un plus gros echantillon, mais bon ....

Dernière modification par AnsuzPeorth (Le 22/02/2010, à 02:18)

---

Interface graphique pour bash, python ou autre: glade2script
Support Tchat: http://chat.jabberfr.org/muckl_int/inde … ade2script  (Hors ligne)

Yannou90

Re : [JEU] challenge bash #4

Bonjour a tous

J'ai ajouté l'option "multiple mdp" et corrigé le script:

Utilisation :

[script] [-n -N -Mmscp]

-N=Nombre de mots de passe
-n=Nombre de caractères
-M=Majuscule
-m=Minuscule
-s=Caractères spéciaux
-c=Nombre
-p=Caractères définis par l'utilisateur
-h=Afficher les options disponibles

Le script :

#!/bin/bash

OPT_PASS=$1
VAR_NBR=0
NBR_FOI=1
NBR_PASS=10
MAJ_PASS=
MIN_PASS=
CHI_PASS=
SPE_PASS=
DEF_PASS="A-Za-z,-|0-9"

MAN_PASS()
{
printf "Utilisation : [script] [-n -N -Mmcsp]\n-N=Nombre de mots de passe\n-n=Nombre de caractères\n-M=Majuscule\n-m=Minuscule\n-s=Caractères spéciaux\n-c=Nombre\n-p=Caractères définis par l'utilisateur\n-h=Afficher les options disponibles\n"
}

while getopts ":N:n:Mmscp" OPT_PASS
  do
    case "$OPT_PASS" in
	N )
	NBR_FOI=$OPTARG;;
	n )
	NBR_PASS=$OPTARG;;
        M )
        DEF_PASS=
        MAJ_PASS='A-Z';;
        m )
        DEF_PASS=
        MIN_PASS='a-z';;
        s )
        DEF_PASS=
        SPE_PASS=',-|';;
        c )
        DEF_PASS=
        CHI_PASS='0-9';;
        p )
        printf "Définissez les caractères\n"
	read DEF_PASS;;
        h )
        MAN_PASS && exit 0;;
        * )
        MAN_PASS && exit 1;;
    esac
done

while [ "$VAR_NBR" != "$NBR_FOI" ]
do
grep -a -o "[$DEF_PASS$MAJ_PASS$MIN_PASS$CHI_PASS$SPE_PASS]" /dev/urandom | tr -d "\n" | head -c "$NBR_PASS"
echo
let "VAR_NBR++"
done
exit 0

Exemple :

./script sh
o2[}xGa?yE
./script sh  -n 50
@=a,k9HBTV+Nq.fsS9(x:MyQ^(qXA&,9]}K/}cN;<[o9#=1At^
./script sh  -n 30 -s -N 10
!<`,:?#\?\$+&:=/,+[,=#(,?}};'?
!.!:&=,)..+'#:)+|{#%<][[^{`'!^
\#:|\+[;|!{!,&/#>=(@{|(>?<]`*#
):,*\/$:`(&::})|#`+'`@\.#+$&($
:.{/[@<<?!!{~[$÷({]^%|!##{{$)
~}@]#:`&{<.[,::[):^\>$("+/~%)+
=>{%,$#)`${/!*(?[!({]^{=?<,,{(
`|+'"^~#]``}`\<&[&.+"`(,;<+*{<
{[}~~?~?.}~{]%^`{!:|][,'!?."!|
%~=!`^{"+>%!+{[{?(<$;|@#=<~/(*

Dernière modification par Yannou90 (Le 22/02/2010, à 09:10)

nesthib

Re : [JEU] challenge bash #4

      --- FIN DU CHALLENGE ---

le gagnant est AnsuzPeorth

solutions au post #2

n'oubliez pas de faire vos faire vos propositions de challenges

---

GUL Bordeaux : Giroll – Services libres : TdCT.org
Hide in your shell, scripts & astuces :  applications dans un tunnel – smart wget – trouver des pdf – install. auto de paquets – sauvegarde auto – ♥ awk
  ⃛ɹǝsn xnuᴉꞁ uʍop-ǝpᴉsdn

Yannou90

Re : [JEU] challenge bash #4

Bonsoir

Bravo AnsuzPeorth !!

Sur l'action je n'ai pas perçu le pourquoi de la difficultée , mais a la lecture de ton code , j'ai vite compris que des heures de recherches m'attendaient pour la préhension du résultat que tu souhaitais : à savoir déterminer de l'aléatoire .

Comme d'habitude je suis bluffé des solutions proposées

La solution de sputnick est violement denuée de code en étant particulièrement efficace (équivalente a la soluce de  AnsuzPeorth si je ne dis pas de bétises) :

On convertit le nombre decimal en octal pour l'affichage

Faut être vicieux quand même , on sent l'expérience , y'a pas photos !!

La solution de totor est a son image : puissante , détailler voir explicite mais incompréhensible pour le commun des mortels
Je veux dire que pour une foie la "solution"(la mienne hein ! ) m'a sautée aux yeux et d'ailleurs j'ai posé mon faut bout de code de façon instantanée et fonctionnel , trop même puisque sans maîtrise il me donnait tout de même le résultat attendu (ch'uis bête des fois) !
Puis les débats ce sont ouvert sur la qualitée d'une caractéristique aléatoire ou pseudo-aléatoire (comment générer du on-ne-sait-quoi avec du je-sais-quoi)
Toujours est-il que j'ai alors compris la complexitée dissimulée de l'énoncé !
Comme d'habitude ce challenge m'a permi de progresser grâce a la lecture des codes des différents contribueurs et des recherches entreprises , ainsi que de confirmer mes convictions : VIVE LE LIBRE , VIVE LES CONTIBUEURS , VIVE LE PARTAGE !!!

Bravo à vous tous !

Merci à tous !!

Dernière modification par Yannou90 (Le 24/02/2010, à 00:07)

AnsuzPeorth

Re : [JEU] challenge bash #4

+1 sur l'analyse de Yannou90 au sujet des scripts de totor et sputnick.
D'ailleurs, sputnick arrive au même résultat que moi en 2 lignes ..... ! (j'avais un peu compliqué le truc, c'est vrai, mais j'étais , à l'origine, loin de 2 lignes ).

@sputnick
J'aime bien: (par contre, pourquoi le '!' ?)

$(eval echo ${!cas})

J'avais déjà cherché, en vain, comment remplacer par une variable  {0..10} (dans une boucle for par exemple).

cas="{33..126}"
for nb in $(eval echo ${cas}); do echo $nb; done

---

Interface graphique pour bash, python ou autre: glade2script
Support Tchat: http://chat.jabberfr.org/muckl_int/inde … ade2script  (Hors ligne)

nesthib

Re : [JEU] challenge bash #4

c'est une syntaxe de substitution de contenu en nom de variable

variable=texte
abc=variable
echo ${!abc}

---

GUL Bordeaux : Giroll – Services libres : TdCT.org
Hide in your shell, scripts & astuces :  applications dans un tunnel – smart wget – trouver des pdf – install. auto de paquets – sauvegarde auto – ♥ awk
  ⃛ɹǝsn xnuᴉꞁ uʍop-ǝpᴉsdn