¿Puede el aprendizaje automático decodificar los hash SHA256?

Tengo un hash SHA256 de 64 caracteres.

Espero entrenar un modelo que pueda predecir si el texto sin formato utilizado para generar el hash comienza con 1 o no.

Independientemente de si esto es "posible", ¿qué algoritmo sería el mejor enfoque?

Mis pensamientos iniciales:

• Genere una gran muestra de hashes que comience con un 1 y una gran muestra de hashes que no comience con un 1
• Establezca cada uno de los 64 caracteres de un hash como parámetro para algún tipo de modelo de regresión logística sin supervisión.
• Entrene al modelo diciéndole cuándo está bien / mal.
• Esperemos poder crear un modelo que pueda predecir si el texto sin formato comienza con un 1 o no con una precisión lo suficientemente alta (y con un kappa decente)

Esto no es realmente una respuesta estadística, pero:

No , no puede determinar el primer carácter del texto sin formato del hash, porque no existe el "texto sin formato" para un hash dado.

SHA-256 es un algoritmo hash. No importa cuál sea su texto sin formato, obtendrá una firma de 32 bytes, a menudo expresada como una cadena hexadecimal de 64 caracteres. Hay muchos más textos claros posibles que posibles cadenas hexadecimales de 64 caracteres: se puede generar el mismo hash a partir de cualquier número de textos claros diferentes. No hay razón para creer que el primer personaje sea / no sea un '1' es uniforme en todos los textos simples que producen un hash dado.

SHA256 está diseñado para ser lo más aleatorio posible, por lo que es poco probable que pueda separar los hashes que provienen de texto sin formato con prefijo 1 de aquellos que no lo hacen; simplemente no debería haber ninguna característica de la cadena hash que revelara esa información.

Independientemente de si esto es "posible", ¿qué algoritmo sería el mejor enfoque?

Lo siento, pero esa es una pregunta sin sentido. Si algo es imposible, entonces no puede buscar el mejor enfoque para el problema.

En este caso, esto definitivamente debería ser imposible porque el hashing es una función unidireccional: varias entradas (infinitas, de hecho) pueden producir la misma salida. Si el primer bit de entrada por sí solo influye de alguna manera en la probabilidad de un valor hash específico, esto significaría que el algoritmo hash es completamente defectuoso.

Ciertamente puede entrenar una red neuronal, un clasificador lineal, SVM y otras cosas para intentar la predicción. Y si podrá predecir de manera confiable la entrada de la salida para un cierto algoritmo de hash, esto demostraría que este algoritmo no tiene valor. Yo diría que para un algoritmo ampliamente utilizado como SHA256, esa posibilidad es muy baja. Sin embargo, es un enfoque razonable descartar rápidamente algoritmos de hashing nuevos, no probados y no probados.

Si bien uno no puede probar un negativo con un ejemplo. Todavía siento que un ejemplo sería sugestivo; y quizás útil. Y muestra cómo uno (intentaría) resolver problemas similares.

En el caso de que quiera hacer predicciones binarias, utilizando características que son vectores binarios , un bosque aleatorio es una opción sólida. Supongo que este tipo de respuestas responde a la segunda parte de su pregunta: ¿qué es un buen algoritmo?

Queremos preprocesar las cadenas SHA256 en vectores binarios (booleanos), ya que cada bit es estadísticamente independiente, por lo que cada bit es una buena característica. Entonces eso hará que nuestras entradas sean 256 elementos booleanos.

Manifestación

Aquí hay una demostración de cómo se puede hacer todo usando la biblioteca Julia DecisionTree.jl .

Puede copiar pegar el siguiente en el indicador de julia.

using SHA
using DecisionTree
using Statistics: mean
using Random: randstring

const maxlen=10_000 # longest string (document) to be hashed.

gen_plaintext(x) = gen_plaintext(Val{x}())
gen_plaintext(::Val{true}) = "1" * randstring(rand(0:maxlen-1))
gen_plaintext(::Val{false}) = randstring(rand(1:maxlen))


bitvector(x) = BitVector(digits(x, base=2, pad=8sizeof(x)))
bitvector(x::AbstractVector) = reduce(vcat, bitvector.(x))

function gen_observation(class)
    plaintext = gen_plaintext(class)
    obs = bitvector(sha256(plaintext))
    obs
end

function feature_mat(obs)
    convert(Array, reduce(hcat, obs)')
end

########################################

const train_labels = rand(Bool, 100_000)
const train_obs = gen_observation.(train_labels)
const train_feature_mat = feature_mat(train_obs)

const test_labels = rand(Bool, 100_000)
const test_obs = gen_observation.(test_labels)
const test_feature_mat = feature_mat(test_obs)


# Train the model
const model = build_forest(train_labels, train_feature_mat)
@show model


#Training Set accuracy:
@show mean(apply_forest(model, train_feature_mat) .== train_labels)

#Test Set accuracy:
@show mean(apply_forest(model, test_feature_mat) .== test_labels)

Resultados

Cuando hice esto, me entrené en 100,000 cadenas ASCII aleatorias de hasta 10,000. Aquí están los resultados que vi:

Entrenar a la modelo

julia> const model = build_forest(train_labels, train_feature_mat)
Ensemble of Decision Trees
Trees:      10
Avg Leaves: 16124.7
Avg Depth:  17.9

Precisión del conjunto de entrenamiento:

julia> mean(apply_forest(model, train_feature_mat) .== train_labels)
0.95162

Exactitud del conjunto de prueba:

julia> mean(apply_forest(model, test_feature_mat) .== test_labels)
0.5016

Discusión

Entonces eso es básicamente nada. Pasamos del 95% en el conjunto de entrenamiento, a apenas más del 50% en el conjunto de prueba. Alguien podría aplicar pruebas de hipótesis adecuadas, para ver si podemos rechazar la
hipótesis nula , pero estoy bastante seguro de que no podemos. Es una pequeña mejora sobre la tasa de conjetura.

Eso sugiere que no se puede aprender. Si se trata de un bosque aleatorio, puede pasar de estar bien ajustado a golpear solo la tasa de conjetura. Los bosques aleatorios son bastante capaces de aprender entradas difíciles. Si hubiera algo que aprender, esperaría al menos un pequeño porcentaje.

Puedes jugar con diferentes funciones hash cambiando el código. Lo que podría ser interesante, obtuve básicamente los mismos resultados cuando utilicé el julia en la hashfunción incorporada (que no es una hsah criptográficamente segura, pero aún así es un buen hash, por lo que debería enviar cadenas similares). También obtuve básicamente los mismos resultados para CRC32c.

Las funciones de hash son (por diseño) extremadamente adecuadas para hacer cualquier cosa de aprendizaje automático con ellas.

ML es esencialmente una familia de métodos para modelar / estimar funciones localmente continuas . Es decir, está tratando de describir algún sistema físico que, si bien puede tener ciertas discontinuidades, en cierto sentido, es en la mayoría del espacio de parámetros lo suficientemente suave como para que solo se pueda usar una muestra dispersa de datos de prueba para predecir el resultado para otros entrada. Para hacer eso, los algoritmos de IA necesitan descomponer de alguna manera los datos en una representación de base inteligente, para lo cual el entrenamiento ha sugerido que, por ejemplo, si ves tal y tal forma (que parece correlacionarse con el resultado de tal y tal convolución), entonces hay una buena posibilidad de que la salida debería tener en la región correspondiente tal o cual estructura (que puede ser nuevamente descrita por una convolución o algo así).

(Lo sé, muchos enfoques de ML no son para nada una convolución, pero la idea general es siempre la misma: tiene un espacio de entrada que es tan alto que es imposible muestrear exhaustivamente, por lo que encuentra una descomposición inteligente que le permite extrapolar resultados de una muestra comparativamente escasa).

Sin embargo, la idea detrás de una función de cifrado hash es que cualquier cambio en el texto sin formato debería dar como resultado un resumen completamente diferente. Entonces, no importa cómo descomponga la función, los estimadores locales no le permitirán extrapolar cómo las pequeñas fluctuaciones alrededor de esa parte influyen en el resultado. A menos, por supuesto, que procese toda la información de un conjunto limitado, pero esto no se llamaría aprendizaje automático: solo estaría construyendo una tabla de arcoíris .

Esta es una pregunta interesante porque plantea problemas sobre lo que se considera "aprendizaje automático". Ciertamente hay un algoritmo que eventualmente resolverá este problema si se puede resolver. Dice así:

1. Elija su lenguaje de programación favorito y decida una codificación que asigne cada cadena a un entero (potencialmente muy grande).

2. Elija un número aleatorio y conviértalo en una cadena. Verifique si es un programa válido en su idioma. Si no es así, elija otro número e intente nuevamente. Si es así, inícielo, pause inmediatamente y agréguelo a una lista de programas pausados.

3. Ejecute todos los programas pausados ​​por un tiempo. Si alguno de ellos se detiene sin producir una solución adecuada, elimínelos de la lista. Si uno produce una solución adecuada, ¡ya está! De lo contrario, regrese a 2 después de dejar que todos corran un poco.

No hay duda de que si tiene almacenamiento infinito y tiempo infinito, el algoritmo anterior eventualmente encontrará una buena solución. Pero eso probablemente no sea lo que quiere decir con "aprendizaje automático".

Aquí está el problema: si considera todos los problemas posibles, ¡ningún algoritmo de aprendizaje automático puede mejorar en promedio! Esto se conoce como el teorema de no almuerzo gratis . Demuestra que, entre todos los posibles problemas que podría arrojar a cualquier algoritmo de aprendizaje automático, el número que puede resolver rápidamente es muy pequeño.

Puede resolver esos problemas rápidamente solo porque se rigen por patrones que el algoritmo puede anticipar. Por ejemplo, muchos algoritmos exitosos asumen lo siguiente:

1. Las soluciones pueden describirse mediante algunas series complejas de multiplicaciones matriciales y distorsiones no lineales, regidas por un conjunto de parámetros.

2. Las buenas soluciones se agruparán en el espacio de parámetros, de modo que todo lo que tiene que hacer es elegir un vecindario de búsqueda, encontrar la mejor solución allí, cambiar su vecindario de búsqueda para que la mejor solución esté en el centro y repetir.

Obviamente, ninguno de estos supuestos es válido en general. El segundo es particularmente sospechoso. Y el almuerzo sin almuerzo nos dice que estas suposiciones ni siquiera son válidas la mayor parte del tiempo. De hecho, ¡casi nunca aguantan! Es solo nuestra buena suerte que se mantengan para ciertos problemas que realmente importan.

El problema que ha elegido está diseñado desde el principio para violar el supuesto 2. Las funciones hash están específicamente diseñadas para que entradas similares den salidas completamente diferentes.

Entonces, su pregunta, ¿cuál es el mejor algoritmo de aprendizaje automático para resolver este problema? Probablemente tenga una respuesta muy directa: búsqueda aleatoria.

Es casi imposible. Sin embargo, las personas observaron algunos patrones en SHA256 que podrían sugerir su distinción no aleatoria A para SHA256 usando Bitcoin (minería más rápida en el camino) . Su tldr:

"Para distinguir entre un hash de permutación aleatorio ideal y SHA256, haga un hash con una gran cantidad (~ 2 ^ 80) de bloques de 1024 bits candidatos dos veces, como se hace en Bitcoin. Asegúrese de que los bits de los bloques candidatos estén escasamente configurados (mucho menos que el 512 promedio esperado), de acuerdo con el protocolo de Bitcoin, descartar bloques candidatos que no cumplan con el estándar de "dificultad" de Bitcoin (donde los hashes resultantes comienzan con un gran número de 0) .Con el conjunto restante de candidatos de entrada válidos (467369 cuando este análisis se realizó), observe un conjunto particular de 32 bits en el bloque de entrada (ubicado donde Bitcoin tiene el nonce, bits de entrada 607-639). Observe que el número medio de bits establecido en el campo nonce está sesgado a la izquierda, es decir, menos del valor esperado de 16 bits establecido (media estimada 15.428) ".

Ver una discusión en lobste.rs . Una posible explicación es un sesgo introducido por los mineros.

Contestaré con un programa. Para reducir los requisitos computacionales, usaré una variante de sha256 que llamo sha16, que son solo los primeros 16 bits de sha256.

#!/usr/bin/python3

import hashlib
from itertools import count

def sha16(plaintext):
    h = hashlib.sha256()
    h.update(plaintext)
    return h.hexdigest()[:4]

def has_plaintext_start_with_1(digest):
    """Return True if and only if the given digest can be generated from a
    plaintext starting with "1" first bit."""
    return True

def plaintext_starting_with_1(digest):
    """Return a plaintext starting with '1' matching the given digest."""
    for c in count():
        plaintext = (b'\x80' + str(c).encode('ascii'))
        d = sha16(plaintext)
        if d == digest:
            return plaintext

for digest in range(0x10000):
    digest = "%04x" % (digest,)
    plain = plaintext_starting_with_1(digest)
    print("%s hashes to %s" % (plain, digest))

Esto produce la salida:

b'\x8094207' hashes to 0000
b'\x8047770' hashes to 0001
b'\x8078597' hashes to 0002
b'\x8025129' hashes to 0003
b'\x8055307' hashes to 0004
b'\x80120019' hashes to 0005
b'\x8062700' hashes to 0006
b'\x8036411' hashes to 0007
b'\x80135953' hashes to 0008
b'\x8044091' hashes to 0009
b'\x808968' hashes to 000a
b'\x8039318' hashes to 000b
[...]

Dejaré la prueba completa como un ejercicio para el lector, pero confíe en mi palabra: hay una entrada que comienza con un "1" para cada posible resumen de 0000 a ffff.

También hay una entrada que no comienza con "1". Y hay uno que comienza con las obras completas de Shakespeare, también.

Esto es válido para cualquier función hash razonablemente buena, aunque mi prueba de fuerza bruta puede volverse computacionalmente inviable.

Lo que describe es básicamente un ataque previo a la imagen. Está tratando de encontrar una entrada tal que, cuando está en hash, la salida tenga alguna propiedad como "un 1 inicial". *

Es un objetivo explícito de los hashes criptográficos para prevenir tales ataques previos a la imagen. Si puede realizar un ataque de este tipo, tendemos a considerar que ese algoritmo es inseguro y dejamos de usarlo.

Entonces, si bien eso significa que no es imposible, significa que su algoritmo de aprendizaje automático tendría que burlar simultáneamente a una gran fracción de los matemáticos del mundo y sus súper computadoras. Es poco probable que lo hagas.

Sin embargo, si lo hiciera, sería conocido como alguien que rompió un algoritmo criptográfico hash importante. ¡Esa fama vale algo!

^{* Técnicamente, un "primer ataque de preimagen" intenta encontrar una coincidencia para un hash específico. Sin embargo, para mostrar que un algoritmo hash tiene primero la resistencia al ataque de preimagen, generalmente muestran que no se puede encontrar ninguna información significativa sobre la entrada del hash.}

La mayoría de las respuestas aquí le dicen por qué no puede hacer esto, pero aquí está la respuesta directa a:

Independientemente de si esto es "posible", ¿qué algoritmo sería el mejor enfoque?

Asumiendo que la entrada es suficientemente grande:

1. Tome el recuento del conjunto de caracteres válidos.
2. Tome el recíproco del número del paso 1.

Esa es la probabilidad de que la cadena de entrada comience con '1'. Ni siquiera necesita mirar la entrada. Si puede hacerlo mejor que eso, significaría que el hash está muy roto. Puede ahorrar muchos ciclos de CPU al intentar entrenar un algoritmo para elegir números aleatorios.

Podría entrenar un algoritmo y podría tener una respuesta diferente debido al sobreajuste. Eso es a menos que haya algo realmente mal con el algoritmo hash. El uso de este algoritmo va mal más a menudo que si simplemente selecciona un valor aleatorio.

Las funciones de hash están diseñadas a propósito para que sean difíciles de modelar, por lo que (como ya se señaló) es probable que esto sea muy difícil. Sin embargo, cualquier debilidad en la función de hashing reducirá su entropía, haciéndola más predecible.

Independientemente de si esto es "posible", ¿qué algoritmo sería el mejor enfoque?

Un ejemplo útil es la función físicamente inaceptable , o PUF, que es análoga a una función de hashing de hardware. Por lo general, las variaciones de fabricación se utilizan a propósito para dar a cada PUF una respuesta ligeramente diferente para que su salida 'hash' sea diferente para una entrada dada. Sin embargo, las debilidades de diseño limitan la entropía, y dados suficientes pares de desafío-respuesta, a menudo es posible construir un modelo de caja negra de la PUF para que se pueda predecir la respuesta a un nuevo desafío nunca antes visto.

La regresión logística es el enfoque más utilizado para estos ataques de modelado, como en este artículo de Rührmair .

Los algoritmos genéticos (o estrategias más generalmente evolutivas) pueden ser un enfoque alternativo, ya que son aplicables a problemas que no son diferenciables y / o linealmente separables. También se discuten en el documento anterior.

$2^{512}$$2^{256}$$2^{256}$

$2^{64}$$0$$2^{64}-1$

$2^{256}-2^{64}$$(2^{256}-2^{64})!$

$S=(2^{256}-2^{64})$
$C=\frac{90}{100}*S$
$C$$S-C$

$2^{256}$$2^{512}$

El problema es que el "aprendizaje automático" no es inteligente. Solo trata de encontrar patrones. En SHA-256, no hay patrones. No hay nada que encontrar. El aprendizaje automático no tiene ninguna posibilidad mejor que la fuerza bruta.

Si desea descifrar SHA-256 por computadora, la única posibilidad es crear inteligencia real , y dado que muchos humanos inteligentes no han encontrado una manera de crear SHA-256, necesita crear inteligencia artificial que sea mucho más alta que la de muchos humanos inteligentes. En ese momento, no sabemos si una inteligencia tan sobrehumana rompería SHA-256, probaría que no se puede descifrar o decidiría que tampoco es lo suficientemente inteligente (como los humanos). La cuarta posibilidad es, por supuesto, que tal inteligencia artificial sobrehumana ni siquiera se moleste, sino que piense en problemas que son más importantes (para él).