A "senha mais forte"

Eu tenho um aplicativo protegido por um PIN de quatro dígitos e o usuário teve cinco tentativas de fazer login antes de a conta ser bloqueada.

Agora, um dos meus clientes deseja "fortalecer" a segurança e advogar por outra solução:

• PIN de seis dígitos
• NÃO "mesmo dígito um ao lado do outro": por exemplo: 11 3945 ou 39 55 94
• NÃO "números de três dígitos": por exemplo: 123 654 ou 53 789 3

Agora, à pergunta: qual solução é a mais forte?

Posso calcular os quatro dígitos com bastante facilidade, mas como faço para calcular o outro?

Obrigado!

Atualizar

Você obtém o que pede - especialmente quando trabalha com matemática :)

Então, o que eu estava pedindo era o número de combinações para as duas seqüências numéricas.

Lendo as respostas e comentários, ficou claro para mim que isso realmente não importa. Se você tem cinco palpites, não importa se você tem 10.000 ou ~ 800.000 para escolher. Mais importante é descartar 1234 e dia do nascimento. Na minha situação, na verdade, tenho o dia do nascimento dos usuários, portanto, tenho algo para verificar.

Obrigado por uma ótima discussão!

Você solicitou ajuda a um fórum de estatísticos sobre esta questão, por isso fornecerei uma resposta baseada em estatística. Portanto, é razoável supor que você esteja interessado na probabilidade de adivinhar um PIN aleatoriamente (para alguma definição de aleatório), mas isso está lendo mais a questão do que é fornecido.

Minha abordagem será enumerar todas as opções possíveis sem restringir e subtrair as opções nulas. Isso tem um canto agudo, chamado de princípio de inclusão-exclusão, que corresponde à idéia intuitiva de que você não deseja subtrair a mesma coisa de um conjunto duas vezes!

Em um PIN de seis dígitos sem restrições e em um sistema de número decimal, existem combinações possíveis, de a cada dígito tem 10 opções.$10^6$$000 000$$999 999:$

Considere a aparência de "dois dígitos adjacentes e idênticos": , onde as posições rotuladas como são iguais e pode ser qualquer dígito decimal. Agora considere quantas outras maneiras a sequência pode ser organizada em seis dígitos: , , e . Portanto, para qualquer pedido em particular (uma dessas opções), há pelo menos combinações, pois há dígitos sem restrição. Agora, quantas opções de existem? Estamos trabalhando com dígitos decimais, portanto deve haver 10. Portanto, existem$AAXXXX$$A$$X$$AA$$XAAXXX$$XXAAXX$$XXXAAX$$XXXXAA$$10^4$$10^4$$A$$10^5$opções para um pedido específico. Existem cinco ordens desse tipo; portanto, existem arranjos que atendem a essa definição. (O que isso significa em termos de segurança pode ser medido em termos de uma medida teórica da informação de quanto isso reduz a entropia do espaço do PIN.)$5\times10^5$

Agora considere como são os números consecutivos. Na cadeia , se conhecemos A, também conhecemos B e C *: se A é 5, B é 6 e C é 7. Portanto, podemos enumerar essas opções:$ABCXXX$

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

e, neste momento, não está claro se há um "envolvimento". Se houver, também incluímos

• 890XXX
• 901XXX

Cada solução possui combinações associadas, pelo mesmo raciocínio que acima. Portanto, conte quantas soluções devem existir. Lembre-se de contar pedidos alternativos, como$10^3$$XABCXX.$

Agora chegamos ao canto agudo, que é o princípio de inclusão-exclusão. Transformamos o conjunto de todos os PINs de seis dígitos em três conjuntos:

A. PINs permitidos B. PINs inválidos devido a "dígitos adjacentes" C. PINs inválidos devido a "dígitos sequenciais"

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

Existem várias maneiras de isso ocorrer:

• $AABCXX$
• $ABCXDD$

Abordagens um pouco mais avançadas tirariam proveito dos resultados combinatórios básicos e do teorema fundamental da contagem, mas eu escolhi essa avenida, pois coloca a menor carga técnica no leitor.

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

As rugas de "cinco até o bloqueio" são decididamente a melhor proteção contra o acesso não autorizado, pois no esquema de 4 ou 6 dígitos, há um número muito grande de opções e até cinco suposições aleatórias diferentes têm um baixo probabilidade de sucesso. Para uma pergunta de probabilidade bem posta, é possível calcular a probabilidade de um ataque desse tipo ter sucesso.

Mas outros fatores além da probabilidade de sequências de números podem influenciar a segurança do mecanismo de PIN. Principalmente, as pessoas tendem a não escolher PINs aleatoriamente! Por exemplo, algumas pessoas usam sua data de nascimento, data de nascimento dos filhos ou algum número similarmente relacionado pessoal como um PIN. Se um invasor conhece o DOB ​​do usuário, provavelmente estará entre as primeiras coisas que tentar. Portanto, para um usuário específico, algumas combinações podem ser mais prováveis ​​que outras.

* As seqüências listadas estão aumentando estritamente e não está claro se elas aumentam e diminuem quando você diz "número de três corridas".

A obtenção de uma fórmula fechada parece complexa. No entanto, é bastante fácil enumerá-los. Existem 568 916códigos possíveis para a segunda solução. Maior que o número de soluções com um código PIN de quatro dígitos. O código para enumerá-los está abaixo. Embora não seja otimizado, leva apenas alguns segundos para ser executado.

Nota. Presumi que a sequência tivesse que estar em ordem crescente (que pode ser facilmente modificada 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))