Le «mot de passe le plus fort»

J'ai une application protégée par un code PIN à quatre chiffres et l'utilisateur a obtenu cinq tentatives de connexion avant le verrouillage du compte.

Maintenant, un de mes clients veut "renforcer" la sécurité et plaider pour une autre solution:

• PIN à six chiffres
• AUCUN "même chiffre côte à côte": par exemple: 11 3945 ou 39 55 94
• AUCUN "numéro à trois séquences": par exemple: 123 654 ou 53 789 3

Passons maintenant à la question: quelle solution est la plus solide?

Je peux calculer les quatre chiffres assez facilement, mais comment calculer l'autre?

Merci!

Mise à jour

Vous obtenez ce que vous demandez - surtout lorsque vous travaillez avec les mathématiques :)

Donc, ce que je demandais, c'était le nombre de combinaisons pour les deux séquences de nombres.

En lisant les réponses et les commentaires, il m'est apparu clairement que cela n'avait pas vraiment d'importance. Si vous avez 5 suppositions, cela n'a pas d'importance si vous avez 10 000 ou ~ 800 000 parmi lesquels choisir. Plus important est d'exclure 1234 et le jour de naissance. Dans ma situation, j'ai en fait le jour de naissance des utilisateurs, donc j'ai quelque chose à vérifier.

Merci pour une super discussion!

Vous avez demandé l'aide d'un forum de statisticiens sur cette question, je vais donc vous fournir une réponse basée sur des statistiques. Il est donc raisonnable de supposer que vous êtes intéressé par la probabilité de deviner un code PIN au hasard (pour une certaine définition du hasard), mais cela en lit plus sur la question que ce qui est fourni.

Mon approche sera d'énumérer toutes les options possibles sans restreindre, puis de soustraire les options nulles. Cela a un coin pointu, cependant, appelé le principe d'inclusion-exclusion, qui correspond à l'idée intuitive que vous ne voulez pas soustraire deux fois la même chose d'un ensemble!

Dans un code PIN à six chiffres sans restriction et avec un système de nombres décimaux, il y a combinaisons possibles, de 000 000 à 999 999 : chaque chiffre a 10 options.$10^6$$000 000$$999 999:$

Considérez à quoi ressemblent «deux chiffres adjacents identiques»: , où les positions étiquetées A sont les mêmes et X peut être n'importe quel chiffre décimal. Considérez maintenant combien d'autres façons la chaîne A A peut être organisée en six chiffres: X A A X X X , X X A A X X , X X X A A X et X X X X A $AAXXXX$$A$$X$$AA$$XAAXXX$$XXAAXX$$XXXAAX$$XXXXAA$. Ainsi, pour toute commande particulière (une de ces options), il y a au moins combinaisons, car il y a 10 4 chiffres sans restriction. Maintenant, combien de choix de A y a-t-il? Nous travaillons avec des chiffres décimaux, donc il doit y en avoir 10. Il y a donc 10 5 choix pour une commande particulière. Il y a cinq ordonnances de ce type, il existe donc 5 × 10 5 arrangements qui répondent à cette définition. (Ce que cela signifie en termes de sécurité peut être mesuré en termes d'une mesure théorique de l'information de combien cela réduit l'entropie de l'espace PIN.)$10^4$$10^4$$A$$10^5$$5\times10^5$

$ABCXXX$

• 012XXX
• 123XXX
• 234XXX
• 456XXX
• 789XXX

et à ce stade, il n'est pas clair s'il y a un «enroulement». S'il y en a, nous incluons également

• 890XXX
• 901XXX

$10^3$$XABCXX.$

Nous arrivons maintenant au coin aigu, qui est le principe d'inclusion-exclusion. Nous avons regroupé l'ensemble des codes PIN à six chiffres en trois ensembles:

A. NIP autorisés B. NIP nuls en raison de "chiffres adjacents" C. NIP nuls en raison de "chiffres séquentiels"

$B$$C$$|S|=|A|-|B|-|C|,$$|S|=|A|-|B|-|C|+|B\cap C|,$$B\cap C$$B$$C$$B$$C$

Cela peut se produire de plusieurs manières:

• $AABCXX$
• $ABCXDD$

Des approches légèrement plus avancées tireraient parti des résultats combinatoires de base et du théorème fondamental du comptage, mais j'ai choisi cette avenue car elle impose le plus petit fardeau technique au lecteur.

$\frac{1}{|S|}$

La ride de "cinq jusqu'au verrouillage" est décidément la meilleure protection contre les accès non autorisés, car dans le schéma à 4 ou 6 chiffres, il existe un très grand nombre d'options, et même cinq hypothèses différentes et aléatoires ont un faible probabilité de succès. Pour une question de probabilité bien posée, il est possible de calculer la probabilité de réussite d'une telle attaque.

Mais d'autres facteurs que la probabilité de séquences de nombres peuvent influencer la sécurité du mécanisme PIN. Surtout, les gens ont tendance à ne pas choisir les codes PIN au hasard! Par exemple, certaines personnes utilisent leur date de naissance, ou la date de naissance de leurs enfants, ou un numéro personnel similaire comme code PIN. Si un attaquant connaît le DOB de l'utilisateur, ce sera probablement parmi les premières choses qu'il essaie. Ainsi, pour un utilisateur particulier, certaines combinaisons peuvent être plus probables que d'autres.

* Les séquences que vous listez augmentent strictement, et il n'est pas clair si elles augmentent ou diminuent lorsque vous dites "nombre à trois séquences".

L'obtention d'une formule fermée semble complexe. Cependant, il est assez facile de les énumérer. Il existe 568 916des codes possibles pour la deuxième solution. Ce qui est plus grand que le nombre de solutions avec un code PIN à quatre chiffres. Le code pour les énumérer est ci-dessous. Bien qu'il ne soit pas optimisé, son exécution ne prend que quelques secondes.

Remarque. J'ai supposé que la séquence devait être en ordre croissant (qui peut être facilement modifiée en three_running)

N = 999999

candidates = range(N)

def same_consecutive_digits(x):
    x_string = str(x).zfill(6)
    for i in range(1,len(x_string)):
        if x_string[i] == x_string[i-1]:
            return True
    return False

def three_running(x):
    x_string = str(x).zfill(6)
    for i in range(2,len(x_string)):
        if int(x_string[i]) == int(x_string[i-1]) + 1 and int(x_string[i-1]) == int(x_string[i-2]) + 1:
            return True
    return False

def valid(x):
    return not same_consecutive_digits(x) and not three_running(x)

assert(same_consecutive_digits(88555))
assert(same_consecutive_digits(123))
assert(not same_consecutive_digits(852123))
assert(three_running(123456))
assert(not three_running(4587))
assert(valid(134679))
assert(not valid(123894))
assert(not valid(111111))
assert(not valid(151178))
assert(valid("031278"))

accepted = [i for i in range(N) if valid(i)]
print(len(accepted))