L'apprendimento automatico può decodificare gli hash SHA256?

Ho un hash SHA256 di 64 caratteri.

Spero di formare un modello in grado di prevedere se il testo in chiaro utilizzato per generare l'hash inizia con un 1 o meno.

Indipendentemente se questo è "Possibile", quale algoritmo sarebbe l'approccio migliore?

I miei pensieri iniziali:

• Genera un grande campione di hash che iniziano con un 1 e un grande campione di hash che non iniziano con un 1
• Impostare ciascuno dei 64 caratteri di un hash come parametro per una sorta di modello di regressione logistica non supervisionato.
• Allena il modello dicendogli quando è giusto / sbagliato.
• Spero di essere in grado di creare un modello in grado di prevedere se il testo in chiaro inizia con un 1 o meno con una precisione abbastanza elevata (e con un kappa decente)

Questa non è una risposta alle statistiche, ma:

No , non puoi determinare il primo carattere del testo in chiaro dall'hash, perché non esiste un "testo in chiaro" per un determinato hash.

SHA-256 è un algoritmo di hashing. Indipendentemente dal tuo testo in chiaro, ottieni una firma di 32 byte, spesso espressa come una stringa esadecimale di 64 caratteri. Esistono molti più possibili plaintexts di quanti siano possibili stringhe esadecimali di 64 caratteri - lo stesso hash può essere generato da qualsiasi numero di plaintexts diversi. Non c'è motivo di credere che il primo personaggio che sia / non sia un "1" sia uniforme in tutti i testi in chiaro producendo un determinato hash.

SHA256 è progettato per essere il più casuale possibile, quindi è improbabile che tu possa separare gli hash che provengono dal testo in chiaro con 1 prefisso da quelli che non lo fanno; semplicemente non dovrebbe esserci alcuna caratteristica della stringa hash che possa fornire tali informazioni.

Indipendentemente se questo è "Possibile", quale algoritmo sarebbe l'approccio migliore?

Ci dispiace, ma questa è una domanda senza senso. Se qualcosa è impossibile, non puoi cercare l'approccio migliore al problema.

In questo caso, ciò dovrebbe essere assolutamente impossibile perché l'hash è una funzione unidirezionale: diversi input (infiniti, in effetti) possono produrre lo stesso output. Se il primo bit di input da solo influenzasse in qualche modo la probabilità di un valore hash specifico, ciò significherebbe che l'algoritmo hash è completamente imperfetto.

Sicuramente puoi allenare una rete neurale, un classificatore lineare, SVM e quant'altro per tentare la previsione. E se sarai in grado di prevedere in modo affidabile l'input dall'output per un certo algoritmo di hashing, questo dimostrerebbe che questo algoritmo è inutile. Direi che per un algoritmo ampiamente usato come SHA256 una tale possibilità è incredibilmente bassa. Tuttavia, è un approccio ragionevole escludere rapidamente algoritmi di hashing nuovi, non dimostrati e non testati.

Mentre non si può dimostrare un negativo con un esempio. Tuttavia ritengo che un esempio sarebbe suggestivo; e forse utile. E mostra come si potrebbe (tentare di) risolvere problemi simili.

Nel caso in cui voglio fare previsioni binarie, usando funzionalità che sono vettori binari , una foresta casuale è una scelta solida. Immagino che questo tipo di risposte risponda alla seconda parte della tua domanda: cos'è un buon algoritmo.

Vogliamo preelaborare le stringhe SHA256 in vettori binari (booleani), poiché ogni bit è statisticamente indipendente, quindi ogni bit è una buona caratteristica. Ciò renderà i nostri input 256 elementi booleani.

dimostrazione

Ecco una dimostrazione di come tutto può essere fatto usando la libreria Julia DecisionTree.jl .

È possibile copiare incollare quanto segue nel prompt di 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)

risultati

Quando l'ho fatto, mi sono allenato su 100.000 stringhe ASCII casuali di lunghezza fino a 10.000. Ecco i risultati che ho visto:

Allena il modello

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

Precisione del set di allenamento:

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

Precisione del set di test:

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

Discussione

Quindi praticamente non è niente. Siamo passati dal 95% sul set di allenamento a poco più del 50% sul set di test. Qualcuno potrebbe applicare test di ipotesi adeguati, per vedere se possiamo respingere l'
ipotesi nulla , ma sono abbastanza certo che non possiamo. È un piccolo miglioramento rispetto al tasso di ipotesi.

Ciò suggerisce che non può essere appreso. Se una foresta casuale, può andare da ben equipaggiato a colpire solo il tasso di ipotesi. Le foreste casuali sono abbastanza capaci di imparare input difficili. Se ci fosse qualcosa da imparare, mi aspetterei almeno qualche percento.

Puoi giocare con diverse funzioni di hash cambiando il codice. Il che potrebbe essere interessante, ho praticamente ottenuto gli stessi risultati usando la funzione julia in built hash(che non è un hsah crittograficamente sicuro, ma è comunque un buon hash, quindi dovrei effettivamente separare stringhe simili). Ho anche ottenuto praticamente gli stessi risultati per CRC32c.

Le funzioni di hash sono (in base alla progettazione) estremamente inadatte per eseguire qualsiasi apprendimento automatico con esse.

ML è essenzialmente una famiglia di metodi per modellare / stimare funzioni continue localmente . Vale a dire, stai cercando di descrivere un sistema fisico che, sebbene possa avere alcune discontinuità, è in un certo senso nella maggior parte dello spazio dei parametri abbastanza fluido in modo che solo un campione sparso di dati di test possa essere utilizzato per prevedere il risultato per altri ingresso. Per fare ciò, gli algoritmi AI devono in qualche modo scomporre i dati in una rappresentazione di base intelligente, per la quale la formazione ha suggerito che, ad esempio, se vedi tale e tale forma (che sembra correlarsi con il risultato di tale e tale convoluzione), allora c'è una buona possibilità che l'output dovrebbe avere nella regione corrispondente tale e tale struttura (che può essere nuovamente descritta da una convoluzione o qualcosa del genere).

(Lo so, molti approcci ML non sono affatto come una convoluzione, ma l'idea generale è sempre la stessa: hai uno spazio di input di dimensioni così elevate che è impossibile campionare in modo esaustivo, quindi trovi una decomposizione intelligente che ti consente di estrapolare risultati da un campione relativamente scarso.)

L'idea alla base di una funzione hash crittografica è tuttavia che qualsiasi modifica al testo in chiaro dovrebbe comportare un digest completamente diverso. Quindi, indipendentemente da come si decompone la funzione, gli stimatori locali non ti permetteranno di estrapolare come piccole fluttuazioni attorno a quella parte influenzino il risultato. A meno che ovviamente non elabori effettivamente tutte le informazioni di un set limitato, ma questo non si chiamerebbe machine learning: costruiresti solo una tabella arcobaleno .

Questa è una domanda interessante perché solleva problemi su ciò che conta come "apprendimento automatico". Esiste sicuramente un algoritmo che alla fine risolverà questo problema se può essere risolto. Va così:

1. Scegli il tuo linguaggio di programmazione preferito e decidi una codifica che associ ogni stringa a un numero intero (potenzialmente molto grande).

2. Scegli un numero casuale e convertilo in una stringa. Controlla se è un programma valido nella tua lingua. In caso contrario, scegli un altro numero e riprova. In tal caso, avviarlo, metterlo immediatamente in pausa e aggiungerlo a un elenco di programmi in pausa.

3. Esegui tutti i programmi in pausa per un po '. Se qualcuno di essi si ferma senza produrre una soluzione adeguata, rimuoverli dall'elenco. Se uno produce una soluzione adeguata, il gioco è fatto! Altrimenti, torna a 2 dopo averli lasciati correre per un po '.

Non c'è dubbio che se si dispone di memoria infinita e tempo infinito, l'algoritmo sopra troverà alla fine una buona soluzione. Ma probabilmente non è quello che intendi per "apprendimento automatico".

Ecco il problema: se consideri tutti i possibili problemi, nessun algoritmo di apprendimento automatico può fare di meglio in media! Questo è noto come teorema del pranzo libero . Dimostra che tra tutti i possibili problemi che potresti lanciare a un dato algoritmo di machine learning, il numero che può risolvere rapidamente è sparitamente piccolo.

Può risolvere rapidamente questi problemi solo perché sono governati da schemi che l'algoritmo può prevedere. Ad esempio, molti algoritmi di successo presuppongono quanto segue:

1. Le soluzioni possono essere descritte da alcune serie complesse di moltiplicazioni di matrice e distorsioni non lineari, regolate da una serie di parametri.

2. Le buone soluzioni saranno raggruppate nello spazio dei parametri, in modo che tutto ciò che devi fare è scegliere un quartiere di ricerca, trovare la soluzione migliore lì, spostare il tuo quartiere di ricerca in modo che la soluzione migliore sia al centro e ripetere.

Ovviamente nessuna di queste ipotesi vale in generale. Il secondo è particolarmente sospetto. E il pranzo gratuito ci dice che queste ipotesi non valgono nemmeno per la maggior parte del tempo. In realtà non reggono quasi mai! È solo la nostra fortuna che contengano determinati problemi che contano davvero.

Il problema che hai scelto è stato progettato fin dall'inizio per violare il presupposto 2. Le funzioni di hash sono progettate specificatamente in modo che input simili producano output completamente diversi.

Quindi la tua domanda - qual è il miglior algoritmo di machine learning per risolvere questo problema? - ha probabilmente una risposta molto semplice: la ricerca casuale.

È quasi impossibile. Tuttavia, le persone hanno osservato alcuni modelli in SHA256 che potrebbero suggerire la sua non-casualità Una discriminante per SHA256 utilizzando Bitcoin (miniere più veloce lungo la strada) . Loro tldr:

"Per distinguere tra un hash di permutazione casuale ideale e SHA256, hash una grande quantità (~ 2 ^ 80) di blocchi candidati a 1024 bit due volte, come fatto in Bitcoin. Assicurati che i bit dei blocchi candidati siano scarsamente impostati (molto meno del 512 media prevista), secondo il protocollo Bitcoin, scartando i blocchi candidati che non soddisfano lo standard di "difficoltà" Bitcoin (in cui gli hash risultanti iniziano con un numero elevato di 0). Con il restante set di candidati di input validi (467369 quando questa analisi è stata eseguita), osservare un particolare set di 32 bit nel blocco di input (situato in cui Bitcoin ha il nonce, bit di input 607-639). Si noti che il numero medio di bit impostati nel campo nonce è inclinato a sinistra, cioè meno del valore atteso di 16 bit impostati (media stimata 15.428). "

Vedi una discussione su lobste.rs . Una possibile spiegazione è un pregiudizio introdotto dai minatori.

Risponderò con un programma. Per ridurre i requisiti computazionali userò una variante di sha256 che chiamo sha16, che è solo i primi 16 bit di 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))

Questo produce l'output:

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

Lascerò la prova completa come esercizio per il lettore, ma prenderò la mia parola per questo: c'è un input che inizia con un "1" per ogni possibile digest da 0000 a ffff.

C'è anche un input che non inizia con "1". E ce n'è uno che inizia anche con le opere complete di Shakespeare.

Questo vale per qualsiasi funzione di hash ragionevolmente buona, sebbene la mia prova della forza bruta possa diventare non calcolabile dal punto di vista computazionale.

Quello che descrivi è fondamentalmente un attacco pre-immagine. Stai cercando di trovare un input in modo tale che, quando viene eseguito l'hashing, l'output abbia delle proprietà come "un 1 iniziale". *

È un obiettivo esplicito degli hash crittografici prevenire tali attacchi pre-immagine. Se riesci a fare un simile attacco, tendiamo a considerare quell'algoritmo insicuro e smettere di usarlo.

Quindi, mentre ciò significa che non è impossibile, significa che il tuo algoritmo di apprendimento automatico dovrebbe simultaneamente superare una gran parte dei matematici nel mondo e dei loro supercomputer. È improbabile che tu lo faccia.

Tuttavia, se lo facessi, diventeresti noto come qualcuno che ha rotto un importante algoritmo hash crittografico. Quella fama vale qualcosa!

^{* Tecnicamente un "primo attacco preimage" cerca di trovare una corrispondenza per un hash specifico. Tuttavia, per dimostrare che un algoritmo di hash ha prima la resistenza di attacco di preimage, in genere mostrano che non è possibile trovare informazioni significative sull'input dall'hash.}

Quasi tutte le risposte qui ti dicono perché non puoi farlo, ma ecco la risposta diretta a:

Indipendentemente se questo è "Possibile", quale algoritmo sarebbe l'approccio migliore?

Supponendo che l'input sia sufficientemente grande:

1. Prendi il conteggio dell'insieme di caratteri validi.
2. Prendi il reciproco del numero dal passaggio 1.

Questa è la probabilità che la stringa di input inizi con '1'. Non hai nemmeno bisogno di guardare l'input. Se riesci a fare meglio di così, significherebbe che l'hash è molto rotto. Puoi salvare molti cicli della CPU nel tentativo di addestrare un algoritmo per selezionare numeri casuali.

Potresti allenare un algoritmo e potrebbe dare una risposta diversa a causa del sovradimensionamento. Questo a meno che non ci sia qualcosa di veramente sbagliato nell'algoritmo hash. L'uso di questo algoritmo è quindi sbagliato più spesso che se si sceglie semplicemente un valore casuale.

Le funzioni di hash sono progettate appositamente per essere difficili da modellare, quindi (come già sottolineato) è probabile che ciò sia molto difficile. Tuttavia, qualsiasi debolezza nella funzione di hashing ridurrà la sua entropia, rendendola più prevedibile.

Indipendentemente se questo è "Possibile", quale algoritmo sarebbe l'approccio migliore?

Un esempio utile è la funzione fisicamente non clonabile , o PUF, che è analoga a una funzione di hashing hardware. In genere, le variazioni di fabbricazione vengono utilizzate in modo mirato per dare a ogni PUF una risposta leggermente diversa, in modo che il loro output "con hash" sia diverso per un dato input. I punti deboli del design limitano l'entropia, tuttavia, e dato abbastanza coppie sfida-risposta è spesso possibile costruire un modello black-box del PUF in modo da poter prevedere la risposta per una nuova sfida mai vista prima.

La regressione logistica è l'approccio più comunemente usato per questi attacchi di modellazione, come in questo articolo di Rührmair .

Gli algoritmi genetici (o più in generale le strategie evolutive) possono essere un approccio alternativo, in quanto sono applicabili a problemi che non sono differenziabili e / o separabili linearmente. Sono anche discussi nel documento sopra.

$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}$

Il problema è che "l'apprendimento automatico" non è intelligente. Cerca solo di trovare schemi. In SHA-256, non ci sono schemi. Non c'è niente da trovare. L'apprendimento automatico non ha alcuna possibilità migliore della forza bruta.

Se vuoi decifrare SHA-256 al computer, l'unica possibilità è quella di creare una vera intelligenza e poiché molti umani intelligenti non hanno trovato il modo di creare SHA-256, devi creare un'intelligenza artificiale che è molto più alta di quello di molti umani intelligenti. A quel punto, non sappiamo se una tale intelligenza superumana spezzerebbe SHA-256, dimostrerebbe che non può essere violata, o deciderebbe che non è abbastanza intelligente da fare neanche (proprio come gli umani). La quarta possibilità è ovviamente che una tale intelligenza artificiale superumana non si preoccuperebbe nemmeno, ma penserebbe a problemi che sono più importanti (per esso).