Contenu | Rechercher | Menus

Annonce

DVD, clés USB et t-shirts Ubuntu-fr disponibles sur la boutique En Vente Libre

Si vous avez des soucis pour rester connecté, déconnectez-vous puis reconnectez-vous depuis ce lien en cochant la case
Me connecter automatiquement lors de mes prochaines visites.

À propos de l'équipe du forum.

#1 Le 04/09/2022, à 21:22

Petit Lynx

Mot de passe : 3 mots simple => 1 mots de passe fort

Bonjour,

Je crois que le point faible des gestionnaires de mot de passe...
C'est le mot de passe pour l'activer lol

J'ai créer une petite parade :
fusionner des mots de votre choix (facile à se souvenir) pour créer un mot de passe bien coriace que les (éventuels) spyware vont bien se faire ... à trouver.

Dernière modification par Petit Lynx (Le 04/09/2022, à 22:44)


Ubuntu 20.04 64 bits
Le "Hardware", c'est la partie qui prends les coups quand le "Software" plante...

Hors ligne

#2 Le 04/09/2022, à 22:33

Petit Lynx

Re : Mot de passe : 3 mots simple => 1 mots de passe fort

#!/usr/bin/env python3
# coding: utf-8
# la 1e ligne indique au systéme que le programme est écrit en Python3, ce n'est pas un commentaire
# la 2e ligne permet de declarer le codage du texte, ce n'est pas un commentaire
version= "v0.4"
date_version= "04/07/2022 "
description ="programme de fusion de mots de passe pour en obtenir un meilleur"


# paramétres par défaut
# nombre de mots en entrée:
QteMot=3
# affichage des statistiques
# (0:non, 1:résumé, 2:complets):
stat=1
# affichage de l'évolution de la liste de mot
# (1:oui, 0:non):
evol=1
# pause finale
# (1:oui, 0:non):
pausEnd=1
# si lancé en mode graphique, cette pause permet de lire le résultat final avant la fermeture de la fenêtre

# import 
import argparse
import sys
parser = argparse.ArgumentParser(description=description)
# la description est visible lors de l'utilisation de -h ou --help
parser.add_argument("-c1"     , help="mot de passe créé avec 1 mots en entrée" , action="store_true")
parser.add_argument("-c2"     , help="mot de passe créé avec 2 mots en entrée" , action="store_true")
parser.add_argument("-c3"     , help="mot de passe créé avec 3 mots en entrée" , action="store_true")
parser.add_argument("-c5"     , help="mot de passe créé avec 5 mots en entrée" , action="store_true")
parser.add_argument("-stat0"  , help="n'affiche pas les statistiques"          , action="store_true")
parser.add_argument("-stat1"  , help="affiche les statistiques (résumé)"       , action="store_true")
parser.add_argument("-stat2"  , help="affiche les statistiques (complets)"     , action="store_true")
parser.add_argument("-ver"    , help="affiche la version"                      , action="store_true")
args = parser.parse_args()


errFatal_msg="erreur fatale: arret du programme"
XPsolve_msg ="solution expérimentale non optimale"

# message de démarrage
print(description)
print("FusePassWord", version,"du",date_version)
if args.ver:
    sys.exit(1)

# sélection du nombre de mots en entrée
if args.c1 or args.c2 or args.c3 or args.c5:
    if args.c1 + args.c2 + args.c3 + args.c5 >1:
        print("demande incohérente")
        print(errFatal_msg)
        sys.exit(1)
    elif args.c2:
        QteMot=2
    elif args.c3:
        QteMot=3
    elif args.c5:
        QteMot=5
if   QteMot==2:
    lenmotmin=5
    lenmotmax=12
elif QteMot==3:
    lenmotmin=6
    lenmotmax=12
elif QteMot==5:
    lenmotmin=6
    lenmotmax=18

# sélection de l'affichage des infos statistiques
if args.stat0 or args.stat1 or args.stat2:
    if args.stat0 + args.stat1 + args.stat2>1:
        print("demande incohérente")
        stat=1
    elif args.stat0:
        stat=0
    elif args.stat1:
        stat=1
    elif args.stat2:
        stat=2

# constantes:
nombre   ="0123456789"
majuscule="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
minuscule="abcedfghijklmnopqrstuvwxyz"
# symboles supprimés:
symbolSup=[" ",":","/","'",","]
# symboles conservés:
symbolCon=["@"]
# lettres accuentuées:
accentsFr="éèêà"

# matrice aléatoire de correspondance Alphabêtique->numérique
MatCanum=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
MatCanum[0] =[0, 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]
MatCanum[1] =[14, 16, 25, 11, 21, 23, 0, 4, 22, 7, 3, 20, 1, 6, 13, 10, 15, 9, 5, 8, 24, 2, 18, 19, 17, 12]
MatCanum[2] =[8, 23, 3, 4, 11, 10, 1, 2, 14, 15, 7, 0, 18, 25, 22, 5, 6, 24, 19, 16, 9, 12, 21, 13, 20, 17]
MatCanum[3] =[20, 8, 5, 14, 25, 0, 11, 10, 9, 18, 17, 1, 7, 6, 24, 3, 21, 16, 4, 23, 22, 19, 12, 2, 13, 15]
MatCanum[4] =[1, 18, 10, 20, 5, 3, 16, 9, 19, 0, 7, 13, 15, 8, 22, 12, 25, 14, 2, 21, 11, 23, 4, 24, 17, 6]
MatCanum[5] =[23, 15, 4, 7, 24, 17, 5, 12, 10, 13, 8, 25, 3, 19, 0, 21, 9, 18, 16, 22, 14, 2, 11, 20, 6, 1]
MatCanum[6] =[17, 12, 18, 21, 6, 2, 22, 16, 7, 25, 5, 14, 4, 23, 20, 24, 13, 19, 3, 0, 1, 10, 15, 8, 9, 11]
MatCanum[7] =[10, 25, 16, 2, 0, 24, 13, 22, 12, 15, 20, 6, 17, 7, 19, 4, 3, 18, 1, 9, 8, 14, 5, 21, 11, 23]
MatCanum[8] =[6, 8, 10, 13, 5, 12, 9, 15, 3, 17, 2, 0, 16, 14, 22, 18, 11, 7, 23, 4, 21, 19, 24, 1, 25, 20]
MatCanum[9] =[9, 7, 6, 19, 2, 3, 12, 21, 17, 0, 1, 22, 24, 18, 11, 5, 23, 13, 10, 20, 4, 15, 25, 16, 14, 8]
MatCanum[10]=[2, 20, 9, 14, 7, 25, 0, 8, 5, 13, 19, 4, 21, 1, 23, 6, 10, 18, 12, 3, 24, 16, 17, 15, 22, 11]
MatCanum[11]=[10, 4, 13, 23, 8, 9, 11, 1, 21, 15, 16, 3, 22, 6, 2, 7, 24, 19, 20, 5, 25, 17, 14, 0, 18, 12]
MatCanum[12]=[16, 11, 15, 21, 18, 4, 7, 8, 12, 14, 24, 25, 23, 5, 3, 2, 6, 0, 19, 9, 22, 10, 13, 17, 1, 20]
MatCanum[13]=[12, 20, 7, 4, 22, 10, 23, 5, 0, 18, 13, 15, 3, 8, 1, 25, 19, 16, 21, 14, 2, 9, 11, 6, 17, 24]
MatCanum[14]=[24, 3, 1, 25, 11, 21, 18, 14, 15, 0, 12, 7, 10, 9, 23, 2, 20, 19, 6, 5, 17, 8, 13, 22, 16, 4]
MatCanum[15]=[22, 9, 16, 10, 17, 15, 4, 1, 13, 11, 5, 14, 24, 25, 3, 0, 12, 7, 23, 2, 21, 18, 6, 19, 20, 8]



def lenWord(x):
    """calcule la taille du mot d'index spécifié """
    lenWord=len( str(word[x]) )
    return(lenWord)


def compteur(x):
    # nombres
    numDif.append(0)
    numId.append([0]) # crée une liste dans la liste
    for var in nombre:
        if var in word[x]:
            numDif[x] +=1
            identique = word[x].count(var)
            if identique>1:
                numId[x].append(identique)

    # minuscules
    minDif.append(0)
    minId.append([0]) # crée une liste dans la liste
    for var in minuscule:
        if var in word[x]: 
            minDif[x] +=1
            identique = word[x].count(var)
            if identique>1:
                minId[x].append(identique)

    # majuscules
    majDif.append(0)
    majId.append([0]) # crée une liste dans la liste
    for var in majuscule:
        if var in word[x]: 
            majDif[x] +=1
            identique = word[x].count(var)
            if identique>1:
                majId[x].append(identique)


# fonction de comptage. tentative de simplification et d'adaptation de la fonction précedente
def compteur0(x):
    Dif       = [numDif, minDif   , majDif]
    Id        = [numId , numId    , majId ]
    caractere = [nombre, minuscule, majuscule]
    for y in range (0,3):
        if x>0:
            # x=0 : bilan les listes sont déjà créées
            Dif[y].append(0) 
            Id[y].append([0])
        for var in caractere[y]:
            if var in word[x]: 
                Dif[y][x] +=1
                identique = word[x].count(var)
                if identique>1:
                    Id[y][x].append(identique)
                    

def SumIdIn0(x):
    """calcule le nombre de répétition de caractéres au sein du mot """
    minId[x][0]=sum(minId[x])-len(minId[x])+1
    majId[x][0]=sum(majId[x])-len(majId[x])+1
    numId[x][0]=sum(numId[x])-len(numId[x])+1
    # 2 caractéres identiques=> ...Id[x][0]=1
    if x==0:
        allId[0]= minId[x][0] + majId[x][0] + numId[x][0] 


def printStatWord(x):
    """affiche les stat du mot"""
    print(" -longueur du mot       :",  size[x])
    if stat==2:
        print(" -chiffres   différents :",numDif[x])
        print(" -minuscules différentes:",minDif[x])
        print(" -majuscules différentes:",majDif[x])
        print(" -caractéres différents :",allDif[x])
    elif stat==1:
        print(" -caractéres différents :",allDif[x])
    if stat==2:
        print(" -chiffres   identiques :",numId[x])
        print(" -minuscules identiques :",minId[x])
        print(" -majuscules identiques :",majId[x])
    print(" -caractéres identiques :",allId[x])


def reduceWord(x):
    """ réduction d'un mot de la liste en supprimant les caractéres identiques dans ce mot """
    msg=str(x)+"e mot"
    if evol: print("réduction ",msg)
    for var in str(minuscule)+str(majuscule)+str(nombre):
        if var in word[x]:
            identique = word[x].count(var)
            if identique>1:
                word[x]=word[x].replace(var,"")
    # mise à jour de la taille du mot réduit:
    size[x]=lenWord(x)
    return(size,word)


def convertB36_B10(NumBase36,lineMat=0):
    """converti une suite alphanumérique en nombre décimal"""
    Canum=MatCanum[lineMat]
    NumBase36=NumBase36.lower()
    poids=0
    var=0
    base=36
    for carac in reversed(NumBase36):
        if    carac in minuscule:
            index =minuscule.index(carac)
            valBit=10+Canum[index]
        elif carac in nombre:
            valBit=int(carac)
        var=valBit*base**poids+var
        poids+=1
    numBase10=var
    return(numBase10)


ok=0
while not ok:
    # (ré-)initialisation des variables
    word   = [0]   #liste  de mot
    size   = [0]   #taille du mot
    numDif = [0]   #nombre de chiffres           différents
    minDif = [0]   #nombre de lettres minuscules différentes
    majDif = [0]   #nombre de lettres majuscules différentes
    allDif = [0]   #nombre de caractéres         différents
    numId  =[[0]]  #nombre de chiffres           identiques
    minId  =[[0]]  #nombre de lettres minuscules identiques
    majId  =[[0]]  #nombre de lettres majuscules identiques
    allId  = [0]   #nombre de caractéres         identiques

    for x in range (1,QteMot+1):
        ok=0
        while not ok:
            old=1
            while old or rev:
                msg="e mot de passe: "
                msg=str(x)+str(msg)
                new=input(msg)
                wen=new[::-1] # donne l'inverse de la chaine
                for var in symbolSup:
                    if var in new:
                        new=new.replace(var,"")
                old= new in word
                if old:
                    print("mot déjà utilisé, en choisir un autre")
                rev= wen in word
                if rev:
                    print("mot correspondant à l'inverse d'un mot utilisé, en choisir un autre")
            word.append(new)
            size.append( lenWord(x) )
            if lenWord(x)<lenmotmin:
                print("",lenmotmin,"caractéres minimum, ce mot est trop court")
            else:
                ok=1

            compteur(x)

            # caractéres identiques
            SumIdIn0(x)
            allId.append( minId[x][0] + majId[x][0] + numId[x][0] )
    
            # caractéres différents
            allDif.append( minDif[x] + majDif[x] + numDif[x] )
            if   allDif[x]> lenmotmax:
                print("",lenmotmax,"caractéres différents maximum, ce mot est trop long")
                ok=0
            if   allDif[x]> 20: melt=1
            elif numDif[x]>  8: melt=1
            elif   size[x]<= 6 and allDif[x]>= 0.75*size[x]: melt=1
            elif   size[x]<=16 and allDif[x]>=10/16*size[x]: melt=1
            elif   size[x]<=20 and allDif[x]>=12/20*size[x]: melt=1
            elif   size[x]<=25 and allDif[x]>=14/25*size[x]: melt=1
            else:
                print(" ce mot ne contient pas suffisament de caractéres différent")
                ok=0
            if stat:
                printStatWord(x)
            if not ok:
                print("\033[33m mot refusé\033[0m, on recommence")
                # \033[33m couleur \033[0m => couleur est écrit en orange
                # suppession du mot refusé et des données du mot refusé
                del word[x]
                del size[x]
                del numDif[x]
                del minDif[x]
                del majDif[x]
                del allDif[x]
                del minId[x]
                del majId[x]
                del numId[x]
                del allId[x]
            else:
                print("\033[32m mot accepté\033[0m")
                # \033[32m couleur \033[0m => couleur est écrit en vert
        if x<QteMot: 
            print("=>suivant")
        else: 
            print("=>prépation au mixage...")

    # calcul et évaluation globale
    size[0]=sum(size)
    var=""
    for x in range (1,len(word)):
        var = var + str(word[x])
    word[0]= var
    
    compteur0(0)
    SumIdIn0(0)
    x=0
    allDif[0]= minDif[0] + majDif[0] + numDif[0]
    if   allDif[x]> 30: melt=1
    elif   size[x]<=16 and allDif[x]>= 9/16*size[x]: melt=1
    elif   size[x]<=20 and allDif[x]>=11/20*size[x]: melt=1
    elif   size[x]<=30 and allDif[x]>=14/30*size[x]: melt=1
    elif   size[x]<=40 and allDif[x]>=16/40*size[x]: melt=1
    elif   size[x]> 40 and allDif[x]>=20: melt=1
    elif   QteMot== 2 and allDif[x]>= 8: melt=1
    elif   QteMot== 3 and allDif[x]>=16: melt=1
    else:
        print(" cette combinaison ne contient pas suffisament de caractéres différents")
        ok=0

    if stat:
        print("statistiques globales (cumul+mots):")
        print(" -longueur des mots     :",size)
        if stat==2:
            print(" -chiffres   différents :",numDif)
            print(" -minuscules différentes:",minDif)
            print(" -majuscules différentes:",majDif)
        print(" -caractéres différents :",allDif)
        if stat==2:
            print(" -chiffres   identiques :",numId)
            print(" -minuscules identiques :",minId)
            print(" -majuscules identiques :",majId)
        print(" -caractéres identiques :",allId)
    
    if not ok:
        print("\033[33m combinaison refusée\033[0m, on recommence")
        # \033[33m couleur \033[0m => couleur est écrit en orange
    else:
        print("\033[32m combinaison accepté\033[0m")
        # \033[32m couleur \033[0m => couleur est écrit en vert
        ok=1


if evol:
    print("données initiales:")
    print(word[1:])

# comparaison des longueurs de mots entrés
maxSize   =max(size[1:])
maxSizeIn =size.index(maxSize)
minSize   =min(size[1:])
minSizeIn =size.index(minSize)
DeltaSize =maxSize-minSize
otherSize =lenWord(0)-maxSize

reduceAsk=0
revlst=[]
# 2 mots => gestion spécfique (inversion + réduction)
if   QteMot==2:
    if DeltaSize==0:
        revlst=2
    elif DeltaSize<minSize:
        revlst=[maxSizeIn]
    else:
        print(XPsolve_msg)
        revlst=[minSizeIn]
        reduceAsk=1

# >2 mots => gestion reduction 
elif maxSize>otherSize+1:
    if allDif[maxSizeIn]<otherSize:
        reduceAsk=1
    else:
        print("mot trop long par rapport aux autres")
        print(errFatal_msg)
        sys.exit(2)

if reduceAsk:
    reduceWord(maxSizeIn)
    compareSize()

# >2 mots => définition de la logique d'inversion
if QteMot==3:
    revlst=[1,3] # valeur par défaut
    if   maxSizeIn in [1,3]:
        if DeltaSize<3:
            revlst=[1,3]
        elif otherSize==maxSize:
            revlst=[2]

if evol: print("liste inversion:",revlst,"\n",word[1:])

# inversion 
for x in range (1,QteMot+1):
    if x in revlst:
        word[x]=word[x][::-1]
        
if evol: print("inversion:","\n",word[1:])


# fusion des x mots de passe (résultat provisoire) 
# x: numéro dans la liste des mots entrés
# y: numéro dans la chaine du mot  entré
# la "bidouille" maxSize est nécésaire sinon le plus grand mot n'est pas "pris en sandwich" et donc pas "déformé"

var=""
for y in range (1,maxSize+1):
    for x in range (1,QteMot+1):
        if (x%2)^(maxSizeIn%2):
            if y<=lenWord(x):
                var=str(var)+str( str(word[x])[y-1] )
                # l'écriture commence au début
        else:
            debut= maxSize - lenWord(x)
            if y>= debut:
                var=str(var)+str( str(word[x])[y-debut-1] )
                # l'écriture se termine à la fin
word[0]=var

if evol:
    print("fusion:","\n",word[0])


minSum=0
for var in minuscule:
    minSum=minSum+ word[0].count(var)
majSum=0
for var in majuscule:
    majSum=majSum+ word[0].count(var)
letSum     = majSum + minSum
repMinMaj  = abs(majSum-minSum)/letSum
digit      = 1/len(word)
  
if   repMinMaj==1:
    if   majSum==0:
            if stat: print("majusctules à 100%")
            putMaj=1
    elif minSum==0:
            if stat: print("minuscules à 100%")
            putMin=1
elif   repMinMaj<=0+digit:
    if stat: print("répartition minuscule/majuscule à 50% +/-1 caratére") 
elif repMinMaj<=0.1:
    if stat: print("répartition minuscule/majuscule compris entre 90% et 10%")
else:
    if stat: print("répartition minuscule/majuscule compris entre 90% et 10%")
    

print("\033[34mrésultat final\033[0m (",lenWord(0),"caractéres ):")
# \033[34m couleur \033[0m => couleur est écrit en bleu
print("",word[0])

if pausEnd:
	input("Fin de programme")

Ubuntu 20.04 64 bits
Le "Hardware", c'est la partie qui prends les coups quand le "Software" plante...

Hors ligne

#3 Le 04/09/2022, à 22:48

Petit Lynx

Re : Mot de passe : 3 mots simple => 1 mots de passe fort

Le travail du programme:

*@**~/Python programmes$ python3 FpassWord.py3
programme de fusion de mots de passe pour en obtenir un meilleur
FusePassWord v0.4 du 04/07/2022 
1e mot de passe: maxime
 -longueur du mot       : 6
 -caractéres différents : 5
 -caractéres identiques : 1
 mot accepté
=>suivant
2e mot de passe: laurent
 -longueur du mot       : 7
 -caractéres différents : 7
 -caractéres identiques : 0
 mot accepté
=>suivant
3e mot de passe: stéphanie
 -longueur du mot       : 9
 -caractéres différents : 8
 -caractéres identiques : 0
 mot accepté
=>prépation au mixage...
statistiques globales (cumul+mots):
 -longueur des mots     : [22, 6, 7, 9]
 -caractéres différents : [13, 5, 7, 8]
 -caractéres identiques : [8, 1, 0, 0]
 combinaison accepté
données initiales:
['maxime', 'laurent', 'stéphanie']
liste inversion: [1, 3] 
 ['maxime', 'laurent', 'stéphanie']
inversion: 
 ['emixam', 'laurent', 'einahpéts']
fusion: 
 leaimuneramehinpxtéatms
majusctules à 100%
résultat final ( 23 caractéres ):
 leaimuneramehinpxtéatms
Fin de programme

Ubuntu 20.04 64 bits
Le "Hardware", c'est la partie qui prends les coups quand le "Software" plante...

Hors ligne

#4 Le 04/09/2022, à 23:15

MicP

Re : Mot de passe : 3 mots simple => 1 mots de passe fort

Bonjour

Dans tes 3 mots, insère par-ci par-là quelques caractères spéciaux,
car les attaques par force brute utilisent des dictionnaires, et donc ce sera d'abord les mots existants qui seront testés => mot de passe plus vite trouvé
mais si tu insères dans chacun des mots un ou plusieurs caractères spéciaux, ça augmentera énormément le temps de recherche en cas d'attaque par force brute.

Voir :

Wikipedia -> Attaque par force brute

Wikipedia -> Attaque par dictionnaire

mot-De-Passe.png <- Cliquez sur l'image pour l'agrandir

Dernière modification par MicP (Le 04/09/2022, à 23:27)


Retour utilisable de commande
2.d  Le prompt final : permet de s'assurer que la commande est allée à son terme, permet de s'assurer que le retour de commande a été copié/collé dans son intégralité et fournit dans certains cas d'autres informations très importantes.
voir le message #42

Hors ligne

#5 Le 05/09/2022, à 02:15

Petit Lynx

Re : Mot de passe : 3 mots simple => 1 mots de passe fort

Dans tes 3 mots, insère par-ci par-là quelques caractères spéciaux,

Je ne crois pas, le but c'est d'utiliser des mots facilement mémorisables par une personne normale pour le transformer en un mot de passe inattaquable par dictionnaire. Ça n'est pas un "générateur de mots de passe aléatoire", Firefox fait ça très bien.

Le mot de passe qui est généré, dans cet exemple est :
leaimuneramehinpxtéatms
l'utilisateur, lui doit simplement se souvenir de "maxime","laurent","stéphanie" (dans le même ordre)
ensuite, il fait un copié-collé.

je crois que les attaques par dictionnaire pour trouver ce code... ça va être difficile pour eux

attaque par force brute: 23 caractères, majuscules + minuscules + chiffres => 1.7*10^41 combinaisons possibles
en supposant un balayage avec 1 combinaison à la µs => 500 ans pour balayer toutes les combinaisons


Ubuntu 20.04 64 bits
Le "Hardware", c'est la partie qui prends les coups quand le "Software" plante...

Hors ligne

#6 Le 05/09/2022, à 07:15

iznobe

Re : Mot de passe : 3 mots simple => 1 mots de passe fort

Bonjour , juste un detail , rien a voir avec l' idée :

3e mot de passe: stéphanie
 -longueur du mot       : 9
 -caractéres différents : 8
 -caractéres identiques : 0

caractéres differents 8 , ca devrait pas indiqué 9 plutot ?
ou si non alors carcteres identiques devrait alors indiqué 1 tongue


retour utilisable de commande
MSI Z490A-pro , i7 10700 , 32 GB RAM .

Hors ligne

#7 Le 05/09/2022, à 09:37

kholo

Re : Mot de passe : 3 mots simple => 1 mots de passe fort

salut,
un "petit" commentaire également :

d'une façon générale, il y a certainement beaucoup de if qui peuvent virer en prenant les choses différemment...

si tu travailles avec des dictionnaires, ce sera plus simple de faire une table de correspondance entre les lettres et leur code ascii... et ça peut éviter l'import de argparse

tu as de une bibliothèque random pour les nombres aléatoires...

je ne vois pas l’underscore dans tes gestions de caractères... je crois...

tu peux voir pour gérer l'envoie d'arguments au script pour ne pas avoir à les taper durant le déroulement

python3 FpassWord.py3 maxime laurent stéphanie

... et pk .py3 ?
le shebang est justement là pour déclarer python 3

#!/usr/bin/env python3
# -*- coding: UTF8 -*-

... python-is-python3 évitera de mettre la version de python au lancement

ce serait sympa d'avoir juste ça !?

./FpassWord.py "maxime" "laurent" "stéphanie"

voire

./FpassWord.py "maxime laurent stéphanie"

comme je le disais

parser = argparse.ArgumentParser(description=description)
# la description est visible lors de l'utilisation de -h ou --help
parser.add_argument("-c1"     , help="mot de passe créé avec 1 mots en entrée" , action="store_true")
parser.add_argument("-c2"     , help="mot de passe créé avec 2 mots en entrée" , action="store_true")
parser.add_argument("-c3"     , help="mot de passe créé avec 3 mots en entrée" , action="store_true")
parser.add_argument("-c5"     , help="mot de passe créé avec 5 mots en entrée" , action="store_true")
parser.add_argument("-stat0"  , help="n'affiche pas les statistiques"          , action="store_true")
parser.add_argument("-stat1"  , help="affiche les statistiques (résumé)"       , action="store_true")
parser.add_argument("-stat2"  , help="affiche les statistiques (complets)"     , action="store_true")
parser.add_argument("-ver"    , help="affiche la version"                      , action="store_true")
args = parser.parse_args()

peut se faire avec un dico...
même si l'idée et l'utilisation sont sympa !

les phrases peuvent être importées depuis un fichier de conf qui simplifiera la localisation...
tu peux déclarer tes chaînes au début du script pour commencer puis les externaliser pour localiser le script plus tard...

pour les listes :

MatCanum[0] =[0, 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]

avec un split, c'est simple de transformer une chaîne de caractère en liste wink

une_chaine = "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"
une_liste = une_chaine.split(" ")
print(une_liste)

ensuite, pareil, tu peux mettre ces chaînes dans un fichier externe si tu n'utilises pas random

si tu veux jouer avec les mots de passe, tu as des substitutions amusantes :
$ pour le S
@ pour le a
0 pour le O
2 pour de
...
motdepasse => M0t2P@$$

pour réduire les doublons, en python on utilise des set
tu charges un set lettre par lettre et si cette lettre existe déjà elle n'est pas ajoutée

def LettreUnique (phrase) : 
    des_caracteres = set()
    for une_lettre in phrase :
        if une_lettre != " ":
            des_caracteres.add(une_lettre)

    une_liste = sorted(des_caracteres)
    return une_liste

mots = "maxime laurent stéphanie"
mes_lettres = LettreUnique (mots)
print(type(mes_lettres), mes_lettres)

une entête sympa :

__module__ = "xxxxxxxxxx"

__title__ = "Je suis un titre"
__author__ = 'qui tu veux'
__license__ = 'GNU'
__copyright__ = 'GNU 2021 07 24'
__ver_major__ = 0
__ver_minor__ = 1
__ver_patch__ = 0
__ver_sub__ = ''
__version__ = "%d.%d.%d%s" % (__ver_major__, __ver_minor__,
                              __ver_patch__, __ver_sub__)

ici, tu as une bonne façon de générer des mots de passe depuis une string
une petite modif et j'incorpore ma fonction pour avoir ça :

import random
import string
  
def rand_pass(size, scope = string.ascii_letters + string.digits):
      
    # Takes random choices from ascii_letters and digits
    generate_pass = ''.join([random.choice(scope)
                             for n in range(size)])
                         
    return generate_pass

def LettreUnique (phrase) : 
    des_caracteres = set()
    for une_lettre in phrase :
        if une_lettre != " ":
            des_caracteres.add(une_lettre)

    une_liste = sorted(des_caracteres)
    return une_liste

mots = "maxime laurent stéphanie"
mes_lettres = ''.join(LettreUnique (mots))
# print(type(mes_lettres), mes_lettres)

nbre_lettres = len(mes_lettres)
# print(nbre_lettres)
password = rand_pass(nbre_lettres, mes_lettres)
print(password)

quant à la vision des mots de passe... un bon mot de passe est un mot de passe dont on ne peut pas se souvenir parce qu'il a trop de lettres dont le type est trop disparate... rien ne vaut un gestionnaire de mots de passe
... mais c'est une stratégie à mettre en place... et tout dépend du contexte


pour aller plus loin :
maintenant que tu sais comment faire ton programme, tu peux changer de paradigme et te mettre à la POO ! lol
et un peu de lecture
Bonne continuation ! cool

Hors ligne

#8 Le 05/09/2022, à 11:23

Petit Lynx

Re : Mot de passe : 3 mots simple => 1 mots de passe fort

Hello!

kholo a écrit :

d'une façon générale, il y a certainement beaucoup de if qui peuvent virer en prenant les choses différemment...

C'est bien possible, je suis un modeste amateur...

@iznobe:
Tu as raison! Je n'ai pas pensé à ajouter les accents et les symboles dans le comptage des caractères différents

kholo a écrit :

un bon mot de passe est un mot de passe dont on ne peut pas se souvenir parce qu'il a trop de lettres dont le type est trop disparate... rien ne vaut un gestionnaire de mots de passe

On est bien d'accord!
L'idée de ce programme n'est pas de remplacer un gestionnaire de programme, mais de travailler avec.
De fournir le mot de passe du gestionnaire de mot de passe qui permet de chiffer/déchiffrer tout les autres.
Je suppose que certains spyware doivent essayer d'attaquer les gestionnaires de mots de passe...

kholo a écrit :

tu peux voir pour gérer l'envoie d'arguments au script pour ne pas avoir à les taper durant le déroulement

Surtout pas! Les commandes du terminal sont gardées en mémoire, un hacker pourrait s'en servir pour retrouver le code. A l'intérieur d'un programme, je crois que c'est pas possible (ou plus difficile).

kholo a écrit :

tu as de une bibliothèque random pour les nombres aléatoires...

Si c'est aléatoire, tu ne peux pas retrouver le même code final à partir de quelques mots identiques et c'est le but recherché.

pour les listes :
MatCanum[0] =[0, 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]
avec un split, c'est simple de transformer une chaîne de caractère en liste :wink:

C'est pas seulement une liste.
En fait, j'ai généré une "matrice" avec un autre programme en python et c'était facile de présenter ça comme ça.
Je pensais l'exploiter dans le programme et je ne l'ai pas (encore) fait.
Cette matrice te donne 16 manières différentes de réorganiser aléatoirement les lettres de l'alphabet.
Dans cette matrice, un chiffre ne se retrouve jamais à la même place dans chacune des 16 combinaisons.
Celle qui est dans le programme est celle par défaut.
A l'époque, je pensais en mettre une autre en fichier "ini" pour que le programme puisse avoir accès à une réorganisation spécifique et non plus commune à tout ceux qui possèdent le programme.

les phrases peuvent être importées depuis un fichier de conf qui simplifiera la localisation...
tu peux déclarer tes chaînes au début du script pour commencer puis les externaliser pour localiser le script plus tard...

Ça, j'avais essayé un truc spécial de gestion de langue pour un autre programme... J'ai pas réussis!
Donc j'ai pas fait avec celui là que je voulais en plus, le plus simple possible à partager

Note:
J'ai écrit ça lorsque j'étais débutant en Python (et c'est un stade que je n'ai jamais dépassé lol tongue ) et ça fait plus d'un an que je ne m’amuse plus avec Python...


Ubuntu 20.04 64 bits
Le "Hardware", c'est la partie qui prends les coups quand le "Software" plante...

Hors ligne

#9 Le 21/11/2022, à 00:51

cristobal78

Re : Mot de passe : 3 mots simple => 1 mots de passe fort

Intéressant  ce post mais je ne comprends pas pourquoi vouloir générer des mots de passe plus ou moins aléatoires (si j'ai bien compris la quête de Petit Lynx).
Par ailleurs je ne suis pas vraiment d'accord avec l'excellent Kholo dont j'apprécie depuis longtemps les interventions sur le forum  smile
Kholo dit : ..un bon mot de passe est un mot de passe dont on ne peut pas se souvenir parce qu'il a trop de lettres dont le type est trop disparate..."

Pour moi un bon mot de passe est un de mot passe (long donc 16 car au moins ) dont on ne peut pas se souvenir certes, MAIS que moi et moi seul peux retrouver immédiatement.
Pour ma part j'utilise une méthode assez connue qui consiste à prendre la 1-ere lettre de chaque mot d'une phrase impossible à oublier.

Exemple :
Jvpdutqlmdvanppc15051970@

il a 25 caractères, utilise des majuscules, des minuscules, des chiffres et un caractère bizarre ici @
Il est impossible à retenir et pourtant je le retrouve instantanément.

En effet en prenant la première lettre des premiers mots de la chanson "La Bohême" d'Aznavour
Je vous parle d'un temps que les moins de vingt ans ne peuvent pas connaître
suivi de ma date de naissance (rassurez vous je ne suis pas né le 15 mai 1970 )
et je termine par un @
Enfantin pour moi de retrouver ce mot de passe, impossible pour la force brute.

Par ailleurs un mot de passe qui résiste à la force brute pendant 500 ans a-t-il vraiment un intérêt ?
N'importe quel "secret" que j'aurais à protéger aujourd'hui n'aura plus aucune valeur pour personne dans 20 ans. On n'est pas le KGB ou la CIA !!!

Dernière modification par cristobal78 (Le 21/11/2022, à 00:53)


Laptop Lenovo Ubuntu 20.04 LTS / DELL Mint 20.2 - XFCE / Laptop HP Mint 20.2 - XFCE

Hors ligne

#10 Le 21/11/2022, à 12:17

Petit Lynx

Re : Mot de passe : 3 mots simple => 1 mots de passe fort

Bonjour.

Ça n'est pas une requête, mon programme fonctionne. Je partage.

Le mot de passe n'est pas vraiment aléatoire, comme dans ton exemple, il est  difficile à trouver quand on ne sais pas à partir de quoi il a été créé.

Quand j'ai créer ce programme, j'avais besoin de créer des mots de passe pour mes gestionnaires de mots de passe.

Une autre application que je n'ai pas encore utilisée (et qui pourrait être un jeu) serait de fournir un mot (ou une énigme) à x personnes pour leur permettre l'accès à un fichier (ou à la victoire pour un jeu).


Ubuntu 20.04 64 bits
Le "Hardware", c'est la partie qui prends les coups quand le "Software" plante...

Hors ligne