Anders Bergh diseñó a la inversa el OS X Password Assistant y escribió una utilidad de línea de comandos que hace el mismo trabajo. Desde su fuente puede descubrir que toda la generación de contraseñas se realiza mediante una función de biblioteca no documentada patentada SFPWAPasswordSuggest() del marco de SecurityFoundation .

Aunque la función es propietaria y no existe documentación oficial de Apple, puede jugar con la función en sí o con la utilidad de línea de comandos que la rodea para averiguar qué está produciendo. Allister Banks ya lo hizo en 2015 , asumiendo que para OS X Yosemite, y surgió un fragmento de código que produce prácticamente los mismos resultados (excepto algunos las preferencias de los extraños autores, como limitar el rango de números aleatorios disponibles).

En pocas palabras, SFPWAPasswordSuggest() escoge dos palabras al azar de un vocabulario e inserta un número aleatorio y un carácter especial (en ese orden) entre ellas. La longitud del número aleatorio es tal que la longitud total de la cadena será exactamente la requerida, y siempre habrá un único carácter especial. Con respecto al vocabulario, OS X de Yosemite a High Sierra usa /System/Library/Frameworks/SecurityInterface.framework/Resources/pwa_dict_en.gz , 287 kb en tamaño y con 83935 palabras en inglés de longitud entre 2 y 24, para eso:

$ gzcat pwa_dict_en.gz | python2 -c 'import sys
> sys.stdin.read(512)
> word_counts = dict()
> for num_of_letters_index in range(64):
>     value = int(sys.stdin.read(8).strip(), 16)
>     if value:
>         word_counts[num_of_letters_index] = value
> print "Distribution:", word_counts'
Distribution: {1: 26, 2: 191, 3: 1229, 4: 3170, 5: 5591, 6: 8913, 7: 12452, 8: 13462, 9: 12163, 10: 9820, 11: 7007, 12: 4516, 13: 2704, 14: 1429, 15: 691, 16: 329, 17: 150, 18: 61, 19: 21, 20: 5, 21: 3, 22: 1, 24: 1}
$

Aquí se explica cómo puede analizar el archivo . En otras versiones de OS X, la función puede diseñarse de manera algo diferente; usa dtruss ./sf-pwgen para calcularlo.

Tenga en cuenta que la GUI limita la longitud de su contraseña generada con el número 31. Por lo que puedo ver, la función no produce un error para solicitudes más largas, pero no se garantiza que funcione con contraseñas de más de 31 caracteres. En realidad, para contraseñas de más de 67 caracteres, es casi seguro que falle; como se puede ver arriba, el vocabulario no presenta suficientes palabras de suficiente longitud, y el algoritmo de generación no maneja bien este caso, simplemente devuelve una breve frase de contraseña que consta de solo números y un carácter especial:

$ ./sf-pwgen -c 1 -l 68
2814154076!
$

EDIT 24.01.2018: en nombre de Alex Recuenco :

Cálculo de la entropía

Siguiendo la solución @ximaera.

import math

x = {1: 26, 2: 191, 3: 1229, 4: 3170, 5: 5591, 6: 8913, 7: 12452, 8: 13462, 9: 12163, 10: 9820, 11: 7007, 12: 4516, 13: 2704, 14: 1429, 15: 691, 16: 329, 17: 150, 18: 61, 19: 21, 20: 5, 21: 3, 22: 1, 24: 1}

def entropy(pass_length, n_symbols = 30):
    combinations = 0
    for key, value in x.items():
        for key2, value2 in x.items():
            if (key + key2) < (pass_length - 1):
                combinations += value * value2 * n_symbols * (10 ** (pass_length - key - key2 - 1))
                # last value

    return {'combinations': combinations, 'entropy': math.log2(combinations)}

print(entropy(31))

Que cuando lo ejecutas:

> {'combinations': 1124445877165765109161692550890600, 'entropy': 109.79284135298234}

110 bits de entropía, máximo ... Pensé que sería mejor por alguna razón. La entropía de una contraseña de solo caracteres numéricos de longitud 30 es aproximadamente 100

Estimación de la entropía con zxcvbn

Una forma razonable de estimar un límite superior en la entropía de una contraseña cuyo método de generación no conoce es alimentarlo a el medidor de fuerza de contraseña zxcvbn , que tiene una demostración en línea (que acabo de vincular) y es razonablemente sofisticado. Para pick3"enigma obtenemos:

password:              pick3"enigma
guesses_log10:         8.28991
score:                 3 / 4
function runtime (ms): 1

guess times:
100 / hour:            centuries (throttled online attack)
10  / second:          7 months (unthrottled online attack)
10k / second:          5 hours (offline attack, slow hash, many cores)
10B / second:          less than a second (offline attack, fast hash, many cores)

match sequence:

'pick'
pattern:              dictionary    
guesses_log10:        2.56585   
dictionary_name:      us_tv_and_film    
rank:                 368   
reversed:             false 
base-guesses:         368   
uppercase-variations: 1 
l33t-variations:      1

'3"'    
pattern:              bruteforce    
guesses_log10:        2

'enigma'
pattern:              dictionary
guesses_log10:        2.63347
dictionary_name:      passwords
rank:                 430   
reversed:             false
base-guesses:         430
uppercase-variations: 1
l33t-variations:      1

El campo guesses_log10 se puede usar para calcular la entropía convirtiendo a base 2 (multiplicar por 3.3) y agregando uno. Por lo tanto, la contraseña no debe tener mucho más de 28.5 bits de entropía. Como el volcado de salida se muestra arriba, la palabra pick es # 368 en el diccionario us_tv_and_film de zxcvbn, y enigma es # 430 en su diccionario passwords (de contraseñas comunes), por lo que un atacante sin conexión puede adivinar la contraseña una cantidad de tiempo bastante breve sin tener un conocimiento muy íntimo de los elementos internos de la generación de contraseñas, solo un conocimiento general sobre cómo las personas suelen elegir contraseñas.

Estimación de la entropía a partir del tamaño del diccionario y el algoritmo

Otro enfoque: la respuesta de @ximaera dice que la contraseña se genera de esta manera, utilizando un diccionario de 83,935 palabras:

  

En pocas palabras, SFPWAPasswordSuggest () selecciona dos palabras aleatorias de un vocabulario e inserta un número aleatorio y un carácter especial (en ese orden) entre ellas.

Una palabra aleatoria de un conjunto de 83,935 es un poco más de 16 bits de entropía. Un dígito de 0-9 es alrededor de 3.3 bits. Un carácter no alfanumérico ASCII (de 33) es de aproximadamente 5 bits. Así que eso nos daría unos 41 bits si esa fuera la explicación completa del algoritmo del generador.

Pero como @ximaera señala que no es toda la historia, porque el generador también tiene lógica para limitar la longitud del carácter de la contraseña, aparentemente al rechazar las contraseñas candidatas no es igual a la longitud solicitada por el usuario. Así que en realidad es bastante complicado calcular la entropía precisa. Diría que es demasiado complicado para molestarlo, porque el cálculo más simple de arriba ya nos dice que debe ser de menos de 41 bits, y probablemente un poco menos. Este no es un número preciso de ninguna manera, pero es ampliamente consistente con la estimación de zxcvbn de 28.5 bits.

Conclusión

Las contraseñas generadas no son muy fuertes, al menos no de esa longitud. Si consideramos que los 64 bits (por ejemplo, Diceware frases de contraseña de cinco palabras) son la fuerza de contraseña mínima que deberíamos utilizar, entonces este generador de Apple se queda muy corto. Un atacante sofisticado ni siquiera necesita saber exactamente cómo funciona el algoritmo, como lo demuestra zxcvbn.