O aprendizado de máquina pode decodificar os hashes SHA256?

Eu tenho um hash SHA256 de 64 caracteres.

Espero treinar um modelo que possa prever se o texto simples usado para gerar o hash começa com 1 ou não.

Independentemente de se isso for "Possível", qual algoritmo seria a melhor abordagem?

Meus pensamentos iniciais:

• Gere uma grande amostra de hashes que começam com 1 e uma grande amostra de hashes que não começam com 1
• Defina cada um dos 64 caracteres de um hash como parâmetro para algum tipo de modelo de regressão logística não supervisionada.
• Treine o modelo dizendo quando está certo / errado.
• Esperamos poder criar um modelo que possa prever se o texto simples começa com 1 ou não com uma precisão suficientemente alta (e com um kappa decente)

Esta não é realmente uma resposta estatística, mas:

Não , você não pode determinar o primeiro caractere do texto sem formatação a partir do hash, porque não existe "texto sem formatação" para um determinado hash.

SHA-256 é um algoritmo de hash. Independentemente do seu texto simples, você obtém uma assinatura de 32 bytes, geralmente expressa como uma sequência hexadecimal de 64 caracteres. Há muito mais textos simples possíveis do que seqüências hexadecimais de 64 caracteres - o mesmo hash pode ser gerado a partir de qualquer número de textos simples diferentes. Não há razão para acreditar que o primeiro caractere que é / não seja um '1' seja uniforme em todos os textos simples que produzem um determinado hash.

O SHA256 foi projetado para ser o mais aleatório possível, portanto, é improvável que você seja capaz de separar os hashes provenientes do texto simples com prefixo 1 daqueles que não são; simplesmente não deve haver nenhum recurso da cadeia de hash que denuncie essa informação.

Independentemente de se isso for "Possível", qual algoritmo seria a melhor abordagem?

Desculpe, mas essa é uma pergunta sem sentido. Se algo for impossível, não será possível procurar a melhor abordagem para o problema.

Nesse caso, isso definitivamente deve ser impossível porque o hash é uma função unidirecional: várias entradas (infinitas, de fato) podem produzir a mesma saída. Se o primeiro bit de entrada por si só influencia de alguma forma a probabilidade de um valor de hash específico, isso significa que o algoritmo de hash é completamente defeituoso.

Você certamente pode treinar uma rede neural, classificador linear, SVM e outros enfeites para tentar prever. E se você conseguir prever com segurança a entrada da saída de um determinado algoritmo de hash, isso provaria que esse algoritmo é inútil. Eu diria que, para um algoritmo amplamente usado como o SHA256, essa possibilidade é muito baixa. No entanto, é uma abordagem razoável descartar rapidamente novos algoritmos de hash não comprovados e não testados.

Enquanto não se pode provar um negativo com um exemplo. Ainda sinto que um exemplo seria sugestivo; e talvez útil. E mostra como alguém (tentaria) resolver problemas semelhantes.

No caso de eu querer fazer previsões binárias, usando recursos que são vetores binários , uma Floresta Aleatória é uma escolha sólida. Acho que esse tipo de resposta responde à segunda parte da sua pergunta: o que é um bom algoritmo.

Bem, queremos pré-processar as seqüências SHA256, em vetores binários (booleanos), pois cada bit é estatisticamente independente, portanto, cada bit é um bom recurso. Então, isso fará com que nossas entradas sejam 256 vetores booleanos.

Demo

Aqui está uma demonstração de como tudo pode ser feito usando a biblioteca Julia DecisionTree.jl .

Você pode copiar e colar o texto abaixo no prompt 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

Quando fiz isso, treinei 100.000 seqüências ASCII aleatórias de até 10.000. Aqui estão os resultados que eu vi:

Treine o 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

Precisão do conjunto de treinamento:

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

Precisão do conjunto de teste:

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

Discussão

Então isso é basicamente nada. Passamos de 95% no conjunto de treinamento para pouco mais de 50% no conjunto de teste. Alguém poderia aplicar testes de hipóteses adequados, para ver se podemos rejeitar a
hipótese nula , mas tenho certeza de que não podemos. É uma pequena melhoria em relação à taxa de estimativa.

Isso sugere que não pode ser aprendido. Se uma floresta aleatória, pode ir de bem ajustada a atingir apenas a taxa de estimativa. Florestas aleatórias são bastante capazes de aprender insumos difíceis. Se houvesse algo a aprender, eu esperaria pelo menos alguns por cento.

Você pode brincar com diferentes funções de hash alterando o código. O que poderia ser interessante: obtive basicamente os mesmos resultados ao usar a julia na hashfunção built-in (que não é um hsah criptograficamente seguro, mas ainda é um bom hash, portanto, de fato, é necessário enviar sequências semelhantes). Eu também obtive basicamente os mesmos resultados para CRC32c.

As funções de hash são (por design) extremamente adequadas para fazer qualquer aprendizado de máquina com elas.

ML é essencialmente uma família de métodos para modelar / estimar funções localmente contínuas . Ou seja, você está tentando descrever algum sistema físico que, embora possa ter certas descontinuidades, é, em certo sentido, na maior parte do espaço de parâmetros suave o suficiente para que apenas uma amostra dispersa de dados de teste possa ser usada para prever o resultado para outros entrada. Para fazer isso, os algoritmos de IA precisam de alguma forma decompor os dados em uma representação de base inteligente, para a qual o treinamento sugeriu que, por exemplo, se você vê essa e aquela forma (que parece correlacionar-se com o resultado de tal e tal convolução), então há uma boa chance de que o produto tenha na região correspondente tal e qual estrutura (que pode ser novamente descrita por uma convolução ou algo assim).

(Eu sei, muitas abordagens de ML não são como convolução, mas a idéia geral é sempre a mesma: você tem algum espaço de entrada com uma dimensão tão alta que é impossível amostrar exaustivamente, então você encontra uma decomposição inteligente que permite extrapolar resultados de uma amostra comparativamente escassa.)

A idéia por trás de uma função de hash criptográfico, porém, é que qualquer alteração no texto sem formatação deve resultar em um resumo completamente diferente. Portanto, não importa como você decompõe a função, os estimadores locais não permitem extrapolar como pequenas flutuações em torno dessa parte influenciam o resultado. A menos que você realmente processe todas as informações de um conjunto limitado, mas isso não seria chamado de aprendizado de máquina: você estaria apenas construindo uma tabela arco - íris .

Essa é uma pergunta interessante, porque levanta questões sobre o que conta como "aprendizado de máquina". Há certamente um algoritmo que irá , eventualmente, resolver este problema, se ele pode ser resolvido. É assim:

1. Escolha sua linguagem de programação favorita e decida uma codificação que mapeie cada sequência para um número inteiro (potencialmente muito grande).

2. Escolha um número aleatório e converta-o em uma string. Verifique se é um programa válido no seu idioma. Caso contrário, escolha outro número e tente novamente. Se estiver, inicie-o, faça uma pausa imediata e adicione-o a uma lista de programas em pausa.

3. Execute todos os programas pausados ​​por um tempo. Se algum deles parar sem produzir uma solução adequada, remova-o da lista. Se alguém produz uma solução adequada, está pronto! Caso contrário, retorne para 2 depois de permitir que todos corram um pouco.

Não há dúvida de que, se você tiver armazenamento infinito e tempo infinito, o algoritmo acima acabará encontrando uma boa solução. Mas provavelmente não é isso que você quer dizer com "aprendizado de máquina".

Aqui está o problema: se você considerar todos os problemas possíveis, nenhum algoritmo de aprendizado de máquina poderá se sair melhor em média! Isso é conhecido como o teorema do almoço grátis . Isso prova que, dentre todos os possíveis problemas que você pode colocar em qualquer algoritmo de aprendizado de máquina, o número que ele pode resolver rapidamente é muito pequeno.

Ele pode resolver esses problemas rapidamente apenas porque eles são governados por padrões que o algoritmo pode antecipar. Por exemplo, muitos algoritmos bem-sucedidos assumem o seguinte:

1. As soluções podem ser descritas por algumas séries complexas de multiplicações de matrizes e distorções não lineares, governadas por um conjunto de parâmetros.

2. Boas soluções serão agrupadas no espaço de parâmetros, de modo que tudo que você precisa fazer é escolher uma vizinhança de pesquisa, encontrar a melhor solução lá, mudar sua vizinhança de pesquisa para que a melhor solução esteja no centro e repetir.

Obviamente, nenhuma dessas suposições é válida em geral. O segundo é particularmente suspeito. E o almoço sem graça nos diz que essas suposições nem sequer são válidas na maioria das vezes. Na verdade, eles quase nunca se sustentam! É apenas nossa boa sorte que eles se valem de certos problemas que realmente importam.

O problema que você escolheu foi projetado desde o início para violar a suposição 2. As funções de hash são projetadas especificamente para que entradas semelhantes produzam saídas completamente diferentes.

Portanto, sua pergunta - qual é o melhor algoritmo de aprendizado de máquina para resolver esse problema? - provavelmente tem uma resposta muito direta: pesquisa aleatória.

É quase impossível. No entanto, as pessoas observaram alguns padrões em SHA256 que pode sugerir sua aleatoriedade Um diferenciador para SHA256 usando Bitcoin (mineração mais rápido ao longo do caminho) . O tldr deles:

"Para distinguir entre um hash de permutação aleatória ideal e o SHA256, hash uma grande quantidade (~ 2 ^ 80) de blocos candidatos de 1024 bits duas vezes, como feito no Bitcoin. Verifique se os bits dos blocos candidatos estão escassamente definidos (muito menos do que o 512 média esperada), de acordo com o protocolo Bitcoin, descartando blocos candidatos que não atendam ao padrão de "dificuldade" do Bitcoin (onde os hashes resultantes começam com um grande número de zeros). Com o conjunto restante de candidatos válidos (467369 quando essa análise foi feita), observe um conjunto específico de 32 bits no bloco de entrada (localizado onde o Bitcoin possui o nonce, bits de entrada 607-639). Observe que o número médio de bits definidos no campo nonce está inclinado para a esquerda, isto é, menor que o valor esperado do conjunto de 16 bits (média estimada 15.428). "

Veja uma discussão em lobste.rs . Uma explicação possível é um viés introduzido pelos mineiros.

Eu vou responder com um programa. Para reduzir os requisitos computacionais, usarei uma variante do sha256 que chamo de sha16, que são apenas os primeiros 16 bits do 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))

Isso produz a saída:

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
[...]

Vou deixar a prova completa como um exercício para o leitor, mas aceite minha palavra: existe uma entrada que começa com um "1" para cada resumo possível de 0000 a ffff.

Há também uma entrada que não começa com "1". E há um que começa com os trabalhos completos de Shakespeare também.

Isso vale para qualquer função hash razoavelmente boa, embora minha prova de força bruta possa se tornar computacionalmente inviável.

O que você descreve é ​​basicamente um ataque de pré-imagem. Você está tentando encontrar uma entrada de modo que, quando estiver com hash, a saída tenha alguma propriedade como "um 1 inicial". *

É um objetivo explícito dos hashes criptográficos para impedir ataques de pré-imagem. Se você puder fazer um ataque assim, tendemos a considerar esse algoritmo inseguro e paramos de usá-lo.

Portanto, embora isso signifique que não é impossível, significa que seu algoritmo de aprendizado de máquina precisaria superar, em simultâneo, uma grande fração dos matemáticos do mundo e de seus supercomputadores. É improvável que você o faça.

No entanto, se o fizesse, você seria conhecido como alguém que quebrou um grande algoritmo de hash criptográfico. Essa fama vale alguma coisa!

^{Tecnicamente, um "primeiro ataque de pré-imagem" tenta encontrar uma correspondência para um hash específico. No entanto, para mostrar que um algoritmo de hash tem resistência a ataques de pré-imagem primeiro, eles normalmente mostram que você não encontra nenhuma informação significativa sobre a entrada do hash.}

Quase todas as respostas aqui estão dizendo por que você não pode fazer isso, mas aqui está a resposta direta para:

Independentemente de se isso for "Possível", qual algoritmo seria a melhor abordagem?

Supondo que a entrada seja suficientemente grande:

1. Faça a contagem do conjunto de caracteres válidos.
2. Tome o inverso do número da etapa 1.

Essa é a probabilidade de que a sequência de entrada comece com '1'. Você nem precisa olhar para a entrada. Se você pode fazer melhor do que isso, isso significa que o hash está muito quebrado. Você pode economizar muitos ciclos de CPU ao tentar treinar um algoritmo para escolher números aleatórios.

Você pode treinar um algoritmo e ele pode ter uma resposta diferente por causa do ajuste excessivo. Isto é, a menos que haja algo realmente errado com o algoritmo de hash. O uso desse algoritmo está errado mais frequentemente do que se você simplesmente escolher um valor aleatório.

As funções de hash são projetadas propositadamente para serem difíceis de modelar; portanto (como já foi mencionado), isso provavelmente será muito difícil. No entanto, qualquer fraqueza na função de hash reduzirá sua entropia, tornando-a mais previsível.

Independentemente de se isso for "Possível", qual algoritmo seria a melhor abordagem?

Um exemplo útil é a função fisicamente não clonável , ou PUF - que é análoga a uma função de hash de hardware. Normalmente, as variações de fabricação são usadas propositadamente para dar a cada PUF uma resposta ligeiramente diferente, de modo que sua saída 'hash' seja diferente para uma determinada entrada. As fraquezas do projeto limitam a entropia, no entanto, e com pares suficientes de desafio-resposta, muitas vezes é possível construir um modelo de caixa preta do PUF, de modo que a resposta para um novo desafio anteriormente invisível possa ser prevista.

A regressão logística é a abordagem mais comumente usada para esses ataques de modelagem, como neste artigo de Rührmair .

Algoritmos genéticos (ou estratégias evolutivas em geral) podem ser uma abordagem alternativa, pois são aplicáveis ​​a problemas que não são diferenciáveis ​​e / ou linearmente separáveis. Eles também são discutidos no artigo acima.

Digamos que seu texto sem formatação / entrada tenha exatamente um bloco de comprimento (512 bits = 1 bloco para SHA256). O espaço de entrada para ele é e o espaço de hash é . Para simplificar, vamos levar em consideração as primeiras entradas. Agora você treina um algoritmo de aprendizado de máquina (qualquer algoritmo de sua escolha), com um conjunto de treinamento de tamanho , misturando todos os números de a (isso por si só levaria muito tempo e enorme quantidade de espaço para armazenar, mas vamos deixar isso de lado por um momento). Após o treinamento em um conjunto de treinamento tão grande, você esperaria que o modelo funcionasse com precisão, mas não. Os restantes$2^{512}$$2^{256}$$2^{256}$

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

$2^{256}-2^{64}$pares de hash de entrada podem ser mapeados emmaneiras. Dessas muitas maneiras de organizar, apenas um arranjo seria o nosso SHA256.$(2^{256}-2^{64})!$

Deixe- (número total de mapeamentos) e (Número de mapeamentos de correcção para uma precisão de 90%) A provavelmente para conseguir sequer 90% de precisão em nosso modelo seria (probabilidade de mapeamentos corretos) * (probabilidade de ( ) mapeamentos incorretos) = $S=(2^{256}-2^{64})$
$C=\frac{90}{100}*S$
$C$$S-C$

Conectando os valores, a probabilidade de nosso modelo atingir 90% de precisão é Tomando logaritmos e usando a aproximação de Sterling para fatoriais, a probabilidade é≈2-(2 263,9918466566 -2 260,6509677217 )≈2-10,1322237391*2

Ufa, isso é um número muito pequeno. E isso é uma superestimação, pois consideramos apenas as primeiras entradas em vez do total de . A probabilidade realmente será ainda menor. 2 $2^{256}$$2^{512}$

O problema é que o "aprendizado de máquina" não é inteligente. Apenas tenta encontrar padrões. No SHA-256, não há padrões. Não há nada para encontrar. O aprendizado de máquina não tem nenhuma chance melhor do que a força bruta.

Se você deseja decifrar o SHA-256 por computador, a única possibilidade é criar inteligência real e, como muitos humanos inteligentes não encontraram uma maneira de criar o SHA-256, é necessário criar inteligência artificial muito mais alta do que o de muitos humanos inteligentes. Nesse ponto, não sabemos se uma inteligência super-humana quebraria o SHA-256, provaria que não pode ser quebrada ou decidiria que não é inteligente o suficiente para fazê-lo (assim como os humanos). A quarta possibilidade é, obviamente, que uma inteligência artificial super-humana nem se incomodaria, mas pensaria em problemas que são mais importantes (para ela).