#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 
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 16.04-> 20.04 -> 22.04 ...
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 16.04-> 20.04 -> 22.04 ...
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 programmeUbuntu 16.04-> 20.04 -> 22.04 ...
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
<- Cliquez sur l'image pour l'agrandir
Dernière modification par MicP (Le 04/09/2022, à 23:27)
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 16.04-> 20.04 -> 22.04 ...
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 : 0caractéres differents 8 , ca devrait pas indiqué 9 plutot ?
ou si non alors carcteres identiques devrait alors indiqué 1 
retour COMPLET et 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 
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 !
et un peu de lecture
Bonne continuation ! 
Hors ligne
#8 Le 05/09/2022, à 11:23
- Petit Lynx
Re : Mot de passe : 3 mots simple => 1 mots de passe fort
Hello!
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
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...
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).
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é ) et ça fait plus d'un an que je ne m’amuse plus avec Python...
Ubuntu 16.04-> 20.04 -> 22.04 ...
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 
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 16.04-> 20.04 -> 22.04 ...
Le "Hardware", c'est la partie qui prends les coups quand le "Software" plante...
Hors ligne