Générer un password

[cacaphonie]

Bonjour,

Nice bout de code Cacophonie.

Juste une petite chose (tu vas dire que je chipotte ) mais à chaque condition tu fait:

Code PYTHON :


mdpFinal = mdpFinal + mdpAjout
 

Tu peux le faire qu'une seule fois a la fin. Après ton 'else' et ca t'évites de le l'écrire 3 fois.

Code PYTHON :


#!/usr/bin/env python2.7
# -*- coding: utf-8 -*-
import random
import string

def genPassword():
    lettre = list(string.ascii_lowercase)
    LETTRE = list(string.ascii_uppercase)
    chiffre = list(string.digits)
    mdpFinal = ""
    while(len(mdpFinal) < 9):
        hasard = random.randint(1, 3)
        if(hasard == 1):
            mdpAjout = random.choice(lettre)
        elif(hasard == 2):
            mdpAjout = random.choice(LETTRE)
        else:
            mdpAjout = random.choice(chiffre)
        mdpFinal = mdpFinal + mdpAjout
    print(mdpFinal)
genPassword()
 

De plus tu a oublié le '!' dans ton shébang.

Sinon nice fonction et merci du partage.

Junky,

Ah ouais enfaite je flippais juste que le programme me renvoyait seulement le dernier resultat

Tant qu'à chipoter, autant le faire jusqu'au bout :

Code PYTHON :


mdpFinal += mdpAjout
 

Thx pour le partage

Faut que je perde cette mauvaise attitude
edit: habitude*

[notfound]

Ma touche personnelle :

Code BASH :


$ gpg --gen-random 0 9|base64
 

Et si vous êtes parano, vous pouvez utiliser le lvl 2 qui se base sur /dev/random :

Code BASH :


open("/dev/random", O_RDONLY)
 

My 2 cents

[sakiir]

moi je dis : ssh-keygen

[Junky]

moi je dis : ssh-keygen

?

[notfound]

moi je dis : ssh-keygen

Tu veux dire utiliser une clé à la place de générer un password ?

[sakiir]

ben tu fais un mote de passe en fonction des la clé généré quoi

[Sh4dows]

C'est super tout ça, mais il ne faut pas oublier qu'outre la complexité, un bon mot de passe c'est aussi sa durée de vie limité.

Bonnes fêtes au passage

[GreenBlood]

Code BASH :


 p="";for i in {1..10}; do for j in $(seq $(($RANDOM%30+10))); do t=$(head -c $RANDOM /dev/urandom | md5sum | cut -d' ' -f1); echo -n $t; sleep 0.01; echo -en "\r$p"; done; p=$p$(head -c1 <<<$t); done;echo -e "$(tr 'a-z0-9' ' ' <<< $t)"
 

Outre la beauté du code, j'aime beaucoup comment ça se génère, la progression tout ça

[sakiir]

BTW , un ptit code pour la sécurité d'un mot de passe , c'est un peu bidon mais bon ..

Code PYTHON :


import re
 
def isok(password):
    nbr = 0
    maj = 0
    min = 0
    if(re.match("[a-zA-Z0-9]+", password)):
        for char in data:
            if(ord(char) > 64 and ord(char) < 91):  #Maj Checking
                maj = maj + 1
            if(ord(char) > 96 and ord(char) < 123): #Min Checking
                min = min + 1
            if(ord(char) > 47 and ord(char) < 58):  #Nbr Checking
                nbr = nbr + 1
        if(len(password) >= 10 and nbr >= 1 and min >= 1 and maj >= 1):
            return 1
        else:
            return 0
 

[gruik]

hum.. si ton mdp ne match pas la regex, la fonction isok() est censée retourner... quoi ?
et data c'est défini où ?

c'est carrément bidon même je dirais, tu l'as testé ton code avant de le poster ?

toujours dans le même esprit, on pourra discuter du bienfondé des règles mais au moins le code est valide et un peu plus propre:

Code PYTHON :

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import string

MOT_DE_PASSE_OK, PAS_SUFFISAMENT_MIXTE, MOT_DE_PASSE_TROP_COURT, CARACTERES_NON_PREVUS = (1,0,0,0) # restrictif
#MOT_DE_PASSE_OK, PAS_SUFFISAMENT_MIXTE, MOT_DE_PASSE_TROP_COURT, CARACTERES_NON_PREVUS = (1,0,0,1) # permissif

def isok(password):
    nb_chiffres = 0
    nb_minuscules = 0
    nb_majuscules = 0
    nb_autres = 0

    for i in password:
        if i in string.ascii_lowercase:
            nb_minuscules += 1
        elif i in string.ascii_uppercase:
            nb_majuscules += 1
        elif i in string.digits:
            nb_chiffres += 1
        else:
            nb_autres += 1

    if len(password) < 10: # au moins 10 caracteres de long
        return MOT_DE_PASSE_TROP_COURT
    if nb_minuscules < 3 or nb_majuscules < 3 or nb_chiffres < 2:  # au moins 3 minuscules, 3 majuscules et 2 chiffres
        return PAS_SUFFISAMENT_MIXTE
    if nb_autres > 0:  # on fait quoi ? on valide ou pas ? (cf restrictif/permissif plus haut)
        return CARACTERES_NON_PREVUS
    return MOT_DE_PASSE_OK

if __name__ == '__main__':
    print 'le mot de passe choisi est %s' % (isok(raw_input('entrez un mot de passe: ')) and 'OK' or 'PAS BON')
    print '''
rappel, un bon mot de passe (selon mes criteres tout pourris) doit :
    - faire plus de 10 caracteres
    - comporter au minimum 3 majuscules
    - comporter au minimum 3 minuscules
    - comporter au minimum 2 chiffres'''
    if not CARACTERES_NON_PREVUS:
        print '''    - ne pas comporter d'autre caractere que majuscules, minuscules ou chiffres'''
 

et le résultat, avec en entrée un mot de passe très sûr :

Code :

entrez un mot de passe: ILoveYou123
le mot de passe choisi est OK

[sakiir]

oui c'est archi bidon je sais , c'est l’interpréteur python de checkio.org qui me l'a validé.

[ZanyMonk]

Bon c'est pas grand chose mais j'ai vu le titre du topic ça m'a donné envie de faire le mien, alors voilà. C'pas grand chose mais je crache jamais sur un peu de pratique en Python

Code PYTHON :


#!/usr/bin/env python2
import re, sys, string, random, argparse

parser = argparse.ArgumentParser(
        description='Generates a password'
)
parser.add_argument(
        '-l', '--length',
        type=int, default=8,
        help='Select password length (default: 8)'
)
parser.add_argument(
        '--lvl',
        type=int, default=3,
        help='Select password level between 1 & 5 (default: 3)'
)
args = parser.parse_args()

charsets = [
        string.ascii_lowercase,
        string.ascii_uppercase,
        string.digits,
        '+=!?-',
        ',;/:*$'
]

def generatePassword(length, level):
        charset = []
        for i in range(level):
                charset += list(charsets[i])
       
        password = ''
        while 1:
                for c in range(length):
                        password += str(random.choice(charset))
                if(checkPassword(password, level)):
                        break
                password = ''

        return password

def checkPassword(password, level):
        for i in range(level):
                if(not re.search(r"[" + re.escape(charsets[i]) + r"]", password)):
                        return False
        return True

print generatePassword(args.length, args.lvl)
 

[otherflow]

Bonjour à tous,

Pour ma part, mon script de génération de mots de passe est écrit en bash. Il se base sur les outils tr pour la gestion des différents charsets, et sur head pour la gestion de la taille du mot de passe. L'entropie, quant à elle, est obtenu grâce à l'utilisation du pseudo device /dev/urandom. Ce script est doté d'une petite interface homme machine en ligne de commande permettant de paramétrer la taille et le charset souhaité.

La description des options :

Code :

$ genpasswd

Usage : /usr/local/bin/genpasswd <options>

Options :
    --taille    [taille]
    --type      [type]    

Types disponibles :

alnum    lettres et chiffres
alpha    lettres
digit    chiffres
graph    caracteres imprimables, sans inclure les blancs
lower    lettres minuscules
print    caracteres imprimables, incluant les blancs
punct    caracteres de ponctuation
upper    lettres majuscules
xdigit   chiffres hexadecimaux

Le code :

Code :

#!/bin/bash

TYPES[0]="alnum"
TYPES[1]="alpha"
TYPES[3]="digit"
TYPES[4]="graph"
TYPES[5]="lower"
TYPES[6]="print"
TYPES[7]="punct"
TYPES[8]="upper"
TYPES[9]="xdigit"

OK=2

function usage() {
    echo -e "\nUsage : $0 <options>"
    echo -e "\nOptions :\n\t--taille\t[taille]\n\t--type\t\t[type]\t\n\nTypes disponibles :\n"
    echo -e "alnum\tlettres et chiffres"
    echo -e "alpha\tlettres"
    echo -e "digit\tchiffres"
    echo -e "graph\tcaracteres imprimables, sans inclure les blancs"
    echo -e "lower\tlettres minuscules"
    echo -e "print\tcaracteres imprimables, incluant les blancs"
    echo -e "punct\tcaracteres de ponctuation"
    echo -e "upper\tlettres majuscules"
    echo -e "xdigit\tchiffres hexadecimaux\n"
}

if [ $# -lt 1 ]
then
    usage
    exit
fi

# Traitement des arguments du script
ARG=("$@")

for N in `eval echo {0..$(($#-1))}`
do
    if [ -n "${ARG[$N]}" ]
    then
        if [ "${ARG[$N]}" == "--type" ] && [ -n "${ARG[$(($N+1))]}" ]
        then
            TYPE=${ARG[$(($N+1))]}
            N=$(($N+1))
        elif [ "${ARG[$N]}" == "--taille" ] && [ -n "${ARG[$(($N+1))]}" ]
        then
            LENGTH=${ARG[$(($N+1))]}
            N=$(($N+1))
        fi
    else
        usage
        exit
    fi
done

# Vérification de la validité du type passée en paramètre
for T in ${TYPES[*]}
do
    if [ "$TYPE" ==  "$T" ]
    then
        OK=$(($OK-1))
        break
    fi
done

# Vérification de la validité de la taille passée en paramètre
if [[ $LENGTH =~ ^-?[0-9]+$ ]]
then
    OK=$(($OK-1))
fi

# Génération du mot de passe
if [ $OK -eq 0 ]
then
    echo $(tr -cd "[:$TYPE:]" < /dev/urandom | head -c $LENGTH)
else
    usage
fi

Un exemple d'utilisation générant un mot de passe de 15 caractères alphanumérique :

Code :

$ genpasswd --taille 15 --type alnum
IFCMXcn30QDRNHC

otherflow

[pepperspray77]

Ma devise favorite avec Python, plus c’est court.. mieux c’est

Code :

import string, random
carac = string.ascii_letters + string.digits
mdp = "".join(random.choice(carac) for _ in range(9))
print(mdp)