1. #1
    Expert éminent sénior

    Avatar de Neckara
    Homme Profil pro
    Étudiant
    Inscrit en
    décembre 2011
    Messages
    6 395
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 24
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : Enseignement

    Informations forums :
    Inscription : décembre 2011
    Messages : 6 395
    Points : 16 492
    Points
    16 492

    Par défaut Défi : Notez le générateur de mots de passe de Angelsafrania

    Bonjour,

    La rubrique sécurité vous propose de noter le générateur de mot de passe de Angelsafrania dans le cadre de ce défi.

    N'oubliez pas que notre partenaire livre, les éditions ENI, offrira aux trois meilleures participations un livre intitulé Ethical Hacking, dont vous pouvez consulter les retours par nos membres.

    Participation :

    • Auteur : Angelsafrania
    • Type de projet : Web
    • Tester : lien
    • Sources : voir ci-dessous
    • Description :

    Citation Envoyé par Angelsafrania
    C'est un générateur testeur de mot de passe en HTML5 CSS3 et JS, il faut donc un navigateur récent.
    C'est en une page, donc tout est exécuté niveau client, pas de sauvegarde de mot de passe généré. Récupération des mots de passe possible que si le poste de la personne est mise à mal.

    Pour le système de calcul des difficultés de mot de passe j'ai pris deux systèmes.
    Le premier décrit dans sur le site gouvernemental français : http://www.securite-informatique.gou...rticle728.html
    Le second j'ai tenté de faire un système à point (en pourcentage) avec bonus malus (qu'il faut amélioré normalement).
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    423
    424
    <!DOCTYPE html>
    <html>
    <head>
    	<title>G&eacute;n&eacute;rateur de mot de passe</title>
    	<style type="text/css">
    
    		/* Smartphones & tablettes */
    		@media (max-width: 800px) { 
    			body {
    				text-align : center;
    			}
    			section {
    				margin-bottom:20px;
    			}
    		}
    
    		/* Tablettes paysage & écran classique */
    		@media (min-width: 801px) and (max-width: 1200px) { 
    			nav {
    				display: none;
    			}
    			section h1{
    				text-align:center;
    			}
    			section:nth-of-type(2n + 1) {
    				width:38%;
    				margin-left:2%;
    				float:left;
    			}
    			section:nth-of-type(2n) {
    				width:58%;
    				margin-right:2%;
    				float:right;
    			}
    		}
    
    		/* Grands écrans */
    		@media (min-width: 1200px) {
    			section h1{
    				text-align:center;
    			}
    			section:nth-of-type(2n + 1) {
    				width:30%;
    				margin-left:10%;
    				float:left;
    			}
    			section:nth-of-type(2n) {
    				width:50%;
    				margin-right:10%;
    				float:right;
    			}
    		}
    
    
    		section p label {
    			float:left;
    			text-align:right;
    			display:block;
    			width:45%;
    		}
    		section p button {
    			float:left;
    			text-align:center;
    			display:block;
    			width:15%;
    			margin-left:30%;
    		}
    		
    		section p input, section p select {
    			text-align:left;
    			margin-left:5%;
    		}		
    
    		input[required] {
    			padding : 2px;
    		}
    		input[required]:invalid, select:invalid {
    			border-color: #FF6A6A;
    			box-shadow: 0px 0px 5px red;
    			transition-property : box-shadow border-color;
    			transition-duration:0.5s;
    		}
    		input[required]:valid, select:valid  {
    			border-color: #7BCC70;
    			box-shadow: 0px 0px 4px green;
    			transition-property : box-shadow border-color;
    			transition-duration:0.5s;
    		}
    		input[required]:focus, select:focus {
    			border-color: #7EB6FF;
    			box-shadow: 0px 0px 6px blue;
    			transition-property : box-shadow border-color;
    			transition-duration:0.5s;
    		}
    		
    		#couleurForce {
    			margin-left:auto;
    			margin-right:auto;
    			width:80%;
    		}
    
    		section h1 {
    			font-size:1.5em;
    			text-align:center;
    		}
    		section h2 {
    			font-size:1.25em;
    			text-align:center;
    		}
    		table {
    			text-align:center;
    			margin:auto;
    			border-spacing: 0px;
    			border-collapse: collapse;
    		}
    		td {
    			padding:2px;
    		}
    		tr:nth-child(even) {
    			background-color:#EEE;
    		}
    	</style>
    	
    	<script type="text/javascript">
    		//Donne un mot de passe
    		function getMotDePasse (ensembleCaractere, longueur) {
    			var password = "";
    			var nbEnsemble = ensembleCaractere.length;
    			for (var i = 0; i < longueur; i++) {
    				password += ensembleCaractere[Math.floor(Math.random() * nbEnsemble)];
    			}
    			return password;
    		}
    
    		//Calcule la force de l'ensemble de cataractère associé à la longueur du mot de passe
    		function getForce (tailleEnsembleCaractere, longueur) {
    			var nbCombinaison = Math.pow(tailleEnsembleCaractere, longueur);
    			var force = 0;
    			do {
    				nbCombinaison /= 2;
    				force++;
    			} while(nbCombinaison > 1.5)
    			return force;
    		}
    
    		var ensembleCaracteres = [
    			{"valeur" : "abcdefghijklmnopqrstuvwxyz",  "nom" : "Alphab&eacute;tique minuscule",    "regex" : "[a-z]" },
    			{"valeur" : "0123456789",                  "nom" : "Num&eacute;rique",                 "regex" : "[0-9]" },
    			{"valeur" : "ABCDEFGHIJKLMNOPQRSTUVWXYZ",  "nom" : "Alphab&eacute;tique Majuscule",    "regex" : "[A-Z]" },
    			{"valeur" : "_-+!?;:.,*&",                 "nom" : "Caract&egrave;re sp&eacute;ciaux", "regex" : "[-_!?;:.,*&]"}
    		];
    
    		var forceMotDePasse = [
    			{"minPourcentage" :  0, "min" :   1, "nom" : "Tr&egrave;s tr&egrave;s faible", "rgb" : "#8C1717"},
    			{"minPourcentage" : 25, "min" :  49, "nom" : "Tr&egrave;s faible",             "rgb" : "#FC1501"},
    			{"minPourcentage" : 50, "min" :  65, "nom" : "faible",                         "rgb" : "#EE4000"},
    			{"minPourcentage" : 65, "min" :  78, "nom" : "Moyen",                          "rgb" : "#FF7F00"},
    			{"minPourcentage" : 75, "min" :  82, "nom" : "Bon",                            "rgb" : "#FCD116"},
    			{"minPourcentage" : 85, "min" : 104, "nom" : "Fort",                           "rgb" : "#D1E231"},
    			{"minPourcentage" : 95, "min" : 130, "nom" : "Tr&egrave;s fort",               "rgb" : "#CAFF70"}
    		];
    
    		var ponderationForce = [
    			{"bonusInitial" :   0, "bonusIncremental" :  -5, "nom" : "Chiffre uniquement à la fin", "regex" : "^[^0-9]*[0-9]+$"},
    			{"bonusInitial" :   0, "bonusIncremental" :  -5, "nom" : "Chiffre uniquement à au début", "regex" : "^[0-9]+[^0-9]*$"},
    			{"bonusInitial" :   0, "bonusIncremental" :  -5, "nom" : "Caractère spécial uniquement à la fin", "regex" : "^[^-?./:;,#\"\\'+&^$£€]*[-?./:;,#\"\\'+&^$£€]+$"},
    			{"bonusInitial" :   0, "bonusIncremental" :  -15, "nom" : "Répétition", "regex" : "(.{3,}).*\\1"},
    			{"bonusInitial" : -30, "bonusIncremental" :  30, "nom" : "Minimum de 6 caract&egrave;res", "regex" : "^.{6,}$"},
    			{"bonusInitial" : -10, "bonusIncremental" :  20, "nom" : "Minimum de 8 caract&egrave;res", "regex" : "^.{8,}$"},
    			{"bonusInitial" : -10, "bonusIncremental" :   5, "nom" : "Minimum de 2 caract&egrave;res alphab&eacute;tiques", "regex" : "[a-z]"},
    			{"bonusInitial" : -10, "bonusIncremental" :   5, "nom" : "Minimum de 2 caract&egrave;res majuscules", "regex" : "[A-Z]"},
    			{"bonusInitial" : -10, "bonusIncremental" :   5, "nom" : "Minimum de 2 chiffres", "regex" : "[0-9]"},
    			{"bonusInitial" :  -5, "bonusIncremental" :   5, "nom" : "Minimum de 1 caractère sp&egrave;cial", "regex" : "[^0-9A-Za-z]"}
    		];
    
    		//Variables globales.
    		var inputLongueurMotDePasse;
    		var inputMotDePasse;
    		var inputMotDePasseTesteur;
    		var nodeCouleurForceFr;
    		var nodeCouleurForcePond;
    		var nodeEnsembleCaractere;
    		var nodeAutre;
    		var nodeParagrapheAutre;
    		var autreActive = false;
    		var nodeParagrapheSelectionCaractere;
    		var nodeEnsembleCaractereAutre;
    
    		//Lance l'application
    		function lancerApplication() {
    			//Récupération des variables globales
    			inputLongueurMotDePasse = document.getElementById('longueurMotDePasse');
    			inputMotDePasse = document.getElementById('motDePasse');
    			inputMotDePasseTesteur = document.getElementById('motDePasseTesteur');
    			nodeCouleurForceFr = document.getElementById('couleurForceFr');
    			nodeCouleurForcePond = document.getElementById('couleurForcePond');
    			nodeEnsembleCaractere = document.getElementById('ensembleCaractere');
    			nodeEnsembleCaractereAutre = document.getElementById('ensembleCaractereAutre');
    			nodeParagrapheSelectionCaractere = document.getElementById('paragrapheSelectionCaractere');
    
    			nodeParagrapheAutre = document.createElement('p');
    			var labelAutre = document.createElement('label');
    			labelAutre.innerHTML = 'Caract&egrave;res additionnelles : ';			
    
    			nodeAutre = document.createElement('input');
    			nodeAutre.type='text';
    			nodeAutre.required = 'required';
    			
    			nodeParagrapheAutre.appendChild(labelAutre);
    			nodeParagrapheAutre.appendChild(nodeAutre);
    
    			// Remplissage des options d'ensemble de caractères
    			for(var i = 0; i < ensembleCaracteres.length; i++) {
    				var input = document.createElement('option');
    				input.value = i;
    				input.innerHTML = ensembleCaracteres[i].nom;
    				nodeEnsembleCaractere.insertBefore(input, nodeEnsembleCaractereAutre);
    			}
    			ensembleCaractere.size = ensembleCaracteres.length + 1;
    			
    			//Affichage du panel de couleur pour la force
    			for(var i = 0; i < forceMotDePasse.length; i++) {
    				var span = document.createElement('div');
    				span.style.backgroundColor = forceMotDePasse[i].rgb;
    				span.style.float = 'left';
    				span.style.width = Math.floor(100/forceMotDePasse.length) + '%';
    				span.style.opacity = '0.25';
    				span.innerHTML = '&nbsp;';
    				forceMotDePasse[i].nodeFr = span;
    				nodeCouleurForceFr.appendChild(span);
    
    				var span = document.createElement('div');
    				span.style.backgroundColor = forceMotDePasse[i].rgb;
    				span.style.float = 'left';
    				span.style.width = Math.floor(100/forceMotDePasse.length) + '%';
    				span.style.opacity = '0.25';
    				span.innerHTML = '&nbsp;';
    				forceMotDePasse[i].nodePond = span;
    				nodeCouleurForcePond.appendChild(span);
    			}
    			//Affichage des ponderations
    			var nodePonderationTBody = document.getElementById('ponderationTBody');
    			for(var i = 0; i < ponderationForce.length; i++) {
    				var tr = document.createElement('tr');
    				nodePonderationTBody.appendChild(tr);
    				var tdNom = document.createElement('td');
    				tdNom.innerHTML = ponderationForce[i].nom;
    				tr.appendChild(tdNom);
    				var tdBonus = document.createElement('td');
    				tdBonus.innerHTML = ponderationForce[i].bonusInitial;
    				tr.appendChild(tdBonus);
    				var tdBonusIncremental = document.createElement('td');
    				tdBonusIncremental.innerHTML = ponderationForce[i].bonusIncremental;
    				tr.appendChild(tdBonusIncremental);
    				var tdNbReussite = document.createElement('td');
    				tdNbReussite.innerHTML = 0;
    				tr.appendChild(tdNbReussite);
    				var tdTotal = document.createElement('td');
    				tdTotal.innerHTML = ponderationForce[i].bonusInitial;
    				tr.appendChild(tdTotal);
    				var tdRegex = document.createElement('td');
    				tdRegex.innerHTML = ponderationForce[i].regex;
    				tr.appendChild(tdRegex);
    				ponderationForce[i].nodeNbReussite = tdNbReussite;
    				ponderationForce[i].nodeTotal = tdTotal;
    			}
    		}
    
    		//Génère le mot de passe en fonction des otpions sélectionné
    		function generer() {		
    			if (inputLongueurMotDePasse.validity.valid 
    				&& ensembleCaractere.validity.valid
    				&& (!autreActive || nodeAutre.validity.valid)) {
    				var longueur = inputLongueurMotDePasse.value;
    				var  strEnsembleCaractere = '';
    				for (var i = 0; i < ensembleCaractere.options.length; ++i) {
    					if (ensembleCaractere.options[i].selected && ensembleCaractere.options[i].value == parseInt(ensembleCaractere.options[i].value) ) {
    						strEnsembleCaractere += ensembleCaracteres[ensembleCaractere.options[i].value].valeur;
    					}
    				}
    				if (autreActive) {
    					strEnsembleCaractere += nodeAutre.value;
    				}
    				inputMotDePasse.value = getMotDePasse(strEnsembleCaractere,longueur);
    				inputMotDePasseTesteur.value = inputMotDePasse.value;
    				afficheForce();
    			} else {
    				inputMotDePasse.value = '';
    			}
    		}
    
    		//Affiche la force du mot de passe dans l'input motDePasseTesteur
    		function afficheForce() {
    			afficheForceFr();
    			afficheForcePond();
    		}
    		function afficheForceFr() {
    			document.getElementById('forceFr').innerHTML = '&nbsp;';
    			var nbEnsemble = getNbEnsemblePourTester();
    			var force = getForce(nbEnsemble, inputMotDePasseTesteur.value.length);
    			for (var i = 0; i < forceMotDePasse.length;++i) {
    				if (force <= forceMotDePasse[i].min) {
    					forceMotDePasse[i].nodeFr.style.opacity = '0.25';
    				} else {
    					document.getElementById('forceFr').innerHTML = forceMotDePasse[i].nom;
    					forceMotDePasse[i].nodeFr.style.opacity = '1';
    				}
    			}
    		}
    
    		function afficheForcePond() {
    			document.getElementById('forcePond').innerHTML = '&nbsp;';
    			var force = calculPonderation(inputMotDePasseTesteur.value);
    			for (var i = 0; i < forceMotDePasse.length;++i) {
    				if (force <= forceMotDePasse[i].minPourcentage) {
    					forceMotDePasse[i].nodePond.style.opacity = '0.25';
    				} else {
    					document.getElementById('forcePond').innerHTML = forceMotDePasse[i].nom;
    					forceMotDePasse[i].nodePond.style.opacity = '1';
    				}
    			}
    		}
    
    		//Donne le pourcentage de ponderation du mot de passe
    		function calculPonderation (motDePasse) {
    			var pourcentage = 50;
    			for (var i = 0; ponderationForce.length > i; ++i) {
    				pourcentage += ponderationForce[i].bonusInitial;
    				var expression = new RegExp(ponderationForce[i].regex);
    				
    				var tmpMotDePasse = motDePasse;
    				var nb = 0;
    				while (expression.test(tmpMotDePasse)) {
    					nb+=1;
    					pourcentage += ponderationForce[i].bonusIncremental;
    					tmpMotDePasse = tmpMotDePasse.replace(expression,'');
    				}
    				ponderationForce[i].nodeNbReussite.innerHTML = nb;
    				ponderationForce[i].nodeTotal.innerHTML = nb * ponderationForce[i].bonusIncremental + ponderationForce[i].bonusInitial;
    			}
    
    			if (motDePasse.length <= 0) {
    				return 0;
    			}
    			return pourcentage <= 0 ? 1 : pourcentage;
    		}
    
    		//donne le nombre de l'ensemble caractère pour utilisé dans le mot de passe.
    		function getNbEnsemblePourTester() {
    			var nbEnsemble = 0;
    			var input = inputMotDePasseTesteur.value;
    			for(var i = 0; i < ensembleCaracteres.length; i++) {
    				var expression = new RegExp(ensembleCaracteres[i].regex);
    				if (expression.test(input)) {
    					nbEnsemble += ensembleCaracteres[i].valeur.length;
    					input = input.replace(new RegExp(ensembleCaracteres[i].regex, 'g'),'');
    				}
    			}
    			// Si toutes les correspondances ne sont pas prise
    			if (input.length != 0) {
    				nbEnsemble += input.length;//Il faut d'abord dédoubler les potentielle lettre
    			}
    			return nbEnsemble;
    		}
    		
    		function montrerAutre() {
    			if (nodeEnsembleCaractereAutre.selected) {
    				nodeParagrapheSelectionCaractere.appendChild(nodeParagrapheAutre);
    				autreActive = true;
    			} else if (autreActive) {
    				autreActive = false;
    				nodeParagrapheSelectionCaractere.removeChild(nodeParagrapheAutre);
    				return;
    			}
    		}
    	</script>
    </head>
    <body onload="lancerApplication()">
    	<section>
    		<h1 id="generation">G&eacute;n&eacute;rateur de mot de passe</h1>
    		<form action="#">
    		<p>
    			<label for="longueurMotDePasse"> Longueur du mot de passe : </label>
    			<input type="number" min="1" placeholder="1" id="longueurMotDePasse" required="required"/>
    		</p>
    
    		<p id="paragrapheSelectionCaractere">
    			<label for="ensembleCaractere">S&eacute;lection des ensembles de caract&egrave;re : </label>
    			<select required="required" multiple="multiple" id="ensembleCaractere" onclick="montrerAutre()" onchange="montrerAutre()">
    				<option id="ensembleCaractereAutre">Autre</option>
    			</select>
    		</p>
    		<p>
    			<button onclick="generer()">G&eacute;n&eacute;rer</button>
    			<input type="text" id="motDePasse"/>
    		</p>
    		</form>
    	</section>
    	<section>
    		<h1 id="testeur">Testeur de fiabilit&eacute; de mot de passe</h1>
    		<p>
    			<label for="motDePasseTesteur">Mot de passe à tester :</label> <input type="text" id="motDePasseTesteur" onkeyup="afficheForce()" onchange="afficheForce()"/>
    		</p>
    		<p>
    			<h2>M&eacute;thode du gouvernement Français</h2>
    			<div id="couleurForceFr">&nbsp;</div>
    			<span id="forceFr">&nbsp;</span>
    		</p>
    
    		<p>
    			<h2>M&eacute;thode Pond&eacute;r&eacute;e</h2>
    			<div id="couleurForcePond">&nbsp;</div>
    			<span id="forcePond">&nbsp;</span>
    			<table>
    				<caption>Explication de la ponderation de la force</caption>
    				<theader><tr><th>Nom de la ponderation</th><th>Bonus de base</th><th>Bonus incr&eacute;mental</th><th>Nombre de r&eacute;ussite</th><th>Total</th><th>Regex</th></tr></theader>
    				<tbody id="ponderationTBody">
    				</tbody>
    			</table>
    		</p>
    	</section>
    </body>
    </html>
    On dit "chiffrer" pas "crypter" !

    On dit "bibliothèque" pas "librairie" !

    Ma page DVP : http://neckara.developpez.com/

  2. #2
    Membre habitué

    Profil pro
    Inscrit en
    janvier 2003
    Messages
    65
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : janvier 2003
    Messages : 65
    Points : 139
    Points
    139

    Par défaut

    Note globale 11.1 / 20

    J'essaye d’être le plus objectif possible, mais ayant soumis moi même soumis une proposition à ce concours c'est relativement délicat pour moi de noter.

    fonctionnalités : 2,4 points

    • Les fonctions demandées sont présentes
    • Bon point pour le test du gouvernement Francais et le test pondéré
    • Bon point: On peut tester un mot de passe non généré
    • Dommage: Pas de recherche dictionnaire ni de génération de mot de passe plus facile a mémoriser
    • Dommage: faible portabilité, nécessite un navigateur...
    • Dommage: pas d'API pour réutiliser le générateur ou les tests de robustesse


    qualité du code : 1.5 points ;

    • Le code n'est pas si mauvais en soi.
    • Toutefois tout est regroupe dans la page HTML: javascript/CSS (pourquoi pas trois fichiers?)
    • Il n'est pas facile d’intégrer le code dans une autre page HTML que celle fournie.. Ne parlons pas d'utiliser en dehors d'un browser.
    • Ne respecte pas les standards de codage Javascript (pas plus que moi en tous cas)
    • Vraiment pas bon: le code est place sur le forum, ce qui laisse supposer qu'il n'y a pas de gestion de configuration. Github/sourceforge/...etc. est gratuit pourquoi se priver?


    commentaire et documentation : 1 points

    • Peu de commentaires, et en Français (mauvaise habitude l'anglais est le standard de fait pour la programmation)
    • Pas de documentation du tout
    • Pas d'information de licence

    Il y a vraiment peu a noter... D’où une note plutôt faible.

    sécurité de l'application : 3.7 points ;

    • Comme les autres Javascript la sécurité devrait être bonne, je ne vais pas m’épancher sur le sujet


    design et inventivité de l'interface : 2.5 points.

    • L'interface bien qu’austère est toutefois originale. C'est du fait main et c'est a son honneur.
    • Bon point: La méthode ponderee donne une indication visuelle de pourquoi le mot de passe est bien ou mal noté

Discussions similaires

  1. Réponses: 6
    Dernier message: 06/04/2014, 18h58
  2. Réponses: 4
    Dernier message: 15/03/2014, 23h16
  3. Réponses: 1
    Dernier message: 14/03/2014, 00h04
  4. Réponses: 1
    Dernier message: 13/03/2014, 23h43
  5. Défi : Notez le générateur de mot de passe de Adrael66
    Par Neckara dans le forum Sécurité
    Réponses: 1
    Dernier message: 05/03/2014, 15h35

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo