Dapatkah pembelajaran mesin memecahkan kode hash SHA256?

Saya memiliki hash SHA256 64 karakter.

Saya berharap untuk melatih model yang dapat memprediksi jika plaintext yang digunakan untuk menghasilkan hash dimulai dengan 1 atau tidak.

Terlepas dari apakah ini "Kemungkinan", algoritma apa yang akan menjadi pendekatan terbaik?

Pikiran awal saya:

• Hasilkan sampel besar hash yang dimulai dengan 1 dan sampel besar hash yang tidak dimulai dengan 1
• Tetapkan masing-masing 64 karakter hash sebagai parameter untuk beberapa model regresi logistik tanpa pengawasan.
• Latih model dengan mengatakan kapan itu benar / salah.
• Semoga dapat membuat model yang dapat memprediksi jika plaintext dimulai dengan 1 atau tidak dengan akurasi yang cukup tinggi (dan dengan kappa yang layak)

Ini bukan jawaban statistik, tetapi:

Tidak , Anda tidak dapat menentukan karakter pertama dari plaintext dari hash, karena tidak ada yang namanya "the plaintext" untuk hash yang diberikan.

SHA-256 adalah algoritma hashing. Tidak peduli apa plaintext Anda, Anda mendapatkan tanda tangan 32-byte, sering dinyatakan sebagai string hex 64-karakter. Ada lebih banyak plaintext yang mungkin dari pada string hex karakter 64 yang mungkin - hash yang sama dapat dihasilkan dari sejumlah plaintext yang berbeda. Tidak ada alasan untuk percaya bahwa karakter pertama menjadi / tidak menjadi '1' adalah seragam di semua plaintext yang menghasilkan hash tertentu.

SHA256 dirancang untuk menjadi acak mungkin, sehingga tidak mungkin Anda akan dapat memisahkan hash yang berasal dari plaintext 1-awalan dari yang tidak; seharusnya tidak ada fitur string hash yang akan memberikan informasi itu.

Terlepas dari apakah ini "Kemungkinan", algoritma apa yang akan menjadi pendekatan terbaik?

Maaf, tapi itu pertanyaan yang tidak masuk akal. Jika ada yang tidak mungkin, maka Anda tidak dapat mencari pendekatan terbaik untuk masalah tersebut.

Dalam hal ini, ini pastinya tidak mungkin karena hashing adalah fungsi satu arah: beberapa input (tak terhingga, sebenarnya) dapat menghasilkan output yang sama. Jika bit input pertama sendiri akan mempengaruhi probabilitas nilai hash tertentu, ini berarti bahwa algoritma hash sepenuhnya cacat.

Anda tentu dapat melatih jaringan saraf, classifier linier, SVM dan yang lainnya untuk mencoba prediksi. Dan jika Anda akan dapat memprediksi input dari output dengan andal untuk algoritma hashing tertentu, ini akan membuktikan bahwa algoritma ini tidak berharga. Saya akan mengatakan bahwa untuk algoritma yang banyak digunakan seperti SHA256 kemungkinan seperti itu semakin rendah. Namun, ini merupakan pendekatan yang masuk akal untuk dengan cepat mengesampingkan algoritma hashing baru, belum terbukti dan belum teruji.

Sementara seseorang tidak dapat membuktikan negatif dengan sebuah contoh. Namun saya merasa sebuah contoh akan memberi kesan; dan mungkin bermanfaat. Dan itu menunjukkan bagaimana seseorang akan (berusaha) memecahkan masalah yang sama.

Dalam kasus saya ingin membuat prediksi biner, menggunakan fitur yang merupakan vektor biner , Hutan Acak adalah pilihan yang solid. Saya kira jawaban semacam ini bagian kedua dari pertanyaan Anda: apa itu algoritma yang baik.

Kami juga ingin memproses ulang string SHA256, menjadi vektor biner (Boolean), karena setiap bit secara statistik independen, sehingga setiap bit adalah fitur yang baik. Sehingga akan membuat input kita 256 elemen boolean vektor.

Demo

Berikut ini adalah demonstrasi tentang bagaimana semuanya dapat dilakukan menggunakan perpustakaan Julia DecisionTree.jl .

Anda dapat menyalin tempel di bawah ini ke dalam julia prompt.

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)

Hasil

Ketika saya melakukan ini, melatih 100.000 string ASCII acak hingga 10.000. Inilah hasil yang saya lihat:

Latih modelnya

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

Ketepatan Pelatihan Set:

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

Akurasi Set Tes:

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

Diskusi

Jadi pada dasarnya itu bukan apa-apa. Kami naik dari 95% pada set pelatihan, menjadi hampir tidak lebih dari 50% pada set tes. Seseorang dapat menerapkan tes hipotesis yang tepat, untuk melihat apakah kita dapat menolak
hipotesis nol , tetapi saya cukup yakin kita tidak bisa. Ini adalah peningkatan kecil dari tingkat perkiraan.

Itu menunjukkan bahwa itu tidak dapat dipelajari. Jika Acak Hutan, bisa berubah dari pas untuk memukul hanya tingkat tebakan. Hutan Acak cukup mampu mempelajari input yang sulit. Jika ada sesuatu untuk dipelajari, saya harapkan setidaknya beberapa persen.

Anda dapat bermain-main dengan berbagai fungsi hash dengan mengubah kode. Yang bisa menarik, pada dasarnya saya mendapatkan hasil yang sama ketika menggunakan julia dalam hashfungsi bawaan (yang bukan hsah yang aman secara kriptografis, tetapi masih merupakan hash yang baik sehingga memang harus mengirim string yang sama terpisah). Saya juga mendapat hasil yang sama pada dasarnya CRC32c.

Fungsi hash (menurut desain) sangat tidak cocok untuk melakukan pembelajaran mesin apa pun dengannya.

ML pada dasarnya adalah keluarga metode untuk pemodelan / memperkirakan fungsi kontinu lokal . Yaitu, Anda mencoba menggambarkan beberapa sistem fisik yang, walaupun mungkin memiliki diskontinuitas tertentu, dalam arti tertentu dalam sebagian besar ruang parameter cukup halus sehingga hanya sampel data uji yang tersebar yang dapat digunakan untuk memprediksi hasil untuk yang lain memasukkan. Untuk melakukan itu, algoritma AI perlu menguraikan data menjadi representasi dasar yang cerdas, yang mana pelatihan telah menyarankan bahwa misalnya jika Anda melihat bentuk ini dan itu (yang tampaknya berkorelasi dengan hasil konvolusi ini dan itu) maka ada kemungkinan besar bahwa output harus ada di wilayah yang sesuai struktur ini dan itu (yang lagi-lagi dapat digambarkan dengan konvolusi atau sesuatu).

(Saya tahu, banyak pendekatan ML sama sekali tidak seperti konvolusi, tetapi ide umumnya selalu sama: Anda memiliki beberapa ruang input yang berdimensi sangat tinggi sehingga tidak mungkin untuk dicoba secara mendalam, sehingga Anda menemukan dekomposisi pintar yang memungkinkan Anda untuk mengekstrapolasi hasil dari sampel yang relatif jarang.)

Gagasan di balik fungsi hash kriptografis adalah bahwa setiap perubahan pada plaintext akan menghasilkan intisari yang sama sekali berbeda. Jadi, tidak masalah bagaimana Anda mendekomposisi fungsi, estimator lokal tidak akan memungkinkan Anda memperkirakan seberapa kecil fluktuasi di sekitar bagian itu mempengaruhi hasil. Kecuali tentu saja Anda benar-benar memproses semua informasi dari set terbatas, tetapi ini tidak akan disebut pembelajaran mesin: Anda hanya akan membangun meja pelangi .

Ini adalah pertanyaan yang menarik karena menimbulkan masalah tentang apa yang dianggap sebagai "pembelajaran mesin." Tentu saja ada algoritma yang pada akhirnya akan menyelesaikan masalah ini jika bisa diselesaikan. Bunyinya seperti ini:

1. Pilih bahasa pemrograman favorit Anda, dan putuskan pengodean yang memetakan setiap string ke integer (berpotensi sangat besar).

2. Pilih nomor acak dan ubah menjadi string. Periksa untuk melihat apakah itu program yang valid dalam bahasa Anda. Jika tidak, pilih nomor lain dan coba lagi. Jika ya, mulai saja, segera jeda, dan tambahkan ke daftar program yang dijeda.

3. Jalankan semua program yang dijeda sebentar. Jika salah satu dari mereka berhenti tanpa menghasilkan solusi yang memadai, keluarkan mereka dari daftar. Jika seseorang menghasilkan solusi yang memadai, Anda selesai! Jika tidak, kembalilah ke 2 setelah membiarkan semuanya berjalan sedikit.

Tidak ada pertanyaan bahwa jika Anda memiliki penyimpanan tak terbatas dan waktu tak terbatas, algoritma di atas pada akhirnya akan menemukan solusi yang baik. Tapi itu mungkin bukan yang Anda maksud dengan "pembelajaran mesin."

Inilah masalahnya: jika Anda mempertimbangkan semua masalah yang mungkin terjadi, rata-rata tidak ada algoritma pembelajaran mesin yang bisa melakukan lebih baik! Ini dikenal sebagai teorema makan siang tidak gratis . Ini membuktikan bahwa di antara semua kemungkinan masalah yang bisa Anda lontarkan pada algoritma pembelajaran mesin apa pun yang diberikan, jumlah yang dapat dipecahkan dengan cepat adalah semakin kecil.

Itu dapat memecahkan masalah-masalah itu dengan cepat hanya karena mereka diatur oleh pola yang dapat diantisipasi oleh algoritma. Sebagai contoh, banyak algoritma yang berhasil mengasumsikan sebagai berikut:

1. Solusi dapat dideskripsikan oleh beberapa seri perkalian matriks yang kompleks dan distorsi nonlinear, diatur oleh serangkaian parameter.

2. Solusi yang baik akan dikelompokkan bersama dalam ruang parameter, sehingga yang harus Anda lakukan adalah memilih lingkungan pencarian, menemukan solusi terbaik di sana, menggeser lingkungan pencarian Anda sehingga solusi terbaik ada di tengah, dan ulangi.

Jelas tak satu pun dari asumsi ini berlaku secara umum. Yang kedua adalah tersangka. Dan makan siang gratis tidak memberi tahu kita bahwa asumsi ini bahkan tidak memegang sebagian besar waktu. Bahkan mereka hampir tidak pernah memegang! Hanya nasib baik kita bahwa mereka memegang untuk masalah tertentu yang sebenarnya penting.

Masalah yang Anda pilih dirancang dari awal hingga melanggar asumsi 2. Fungsi hash dirancang khusus sehingga input serupa memberikan output yang sama sekali berbeda.

Jadi pertanyaan Anda — apa algoritma pembelajaran mesin terbaik untuk mengatasi masalah ini? —Mungkin memiliki jawaban yang sangat mudah: pencarian acak.

Ini hampir mustahil. Namun, orang mengamati beberapa pola dalam SHA256 yang mungkin menyarankan non-randomness A SHing256 menggunakan Bitcoin (menambang lebih cepat di sepanjang jalan) . Tldr mereka:

"Untuk membedakan antara hash permutasi acak yang ideal dan SHA256, hash sejumlah besar (~ 2 ^ 80) dari kandidat 1024 bit blok dua kali, seperti yang dilakukan dalam Bitcoin. Pastikan bahwa bit dari kandidat blok diatur secara jarang (jauh lebih sedikit daripada 512 berarti yang diharapkan), menurut protokol Bitcoin, membuang kandidat blok yang tidak memenuhi standar "kesulitan" Bitcoin (di mana hash yang dihasilkan mulai dengan sejumlah besar 0) .Selain sisa sisa kandidat input yang valid (467369 saat analisis ini dilakukan), amati set 32 ​​bit tertentu di blok input (terletak di mana Bitcoin memiliki angka, bit input 607-639). Perhatikan bahwa jumlah rata-rata bit yang ditetapkan dalam bidang nonce condong ke kiri, yaitu kurang dari nilai yang diharapkan dari 16 bit yang ditetapkan (perkiraan rata-rata 15.428). "

Lihat diskusi tentang lobste.rs . Salah satu penjelasan yang mungkin adalah bias yang diperkenalkan oleh para penambang.

Saya akan menjawab dengan sebuah program. Untuk mengurangi persyaratan komputasi saya akan menggunakan varian sha256 yang saya sebut sha16, yang hanya 16 bit pertama dari 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))

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

Saya akan meninggalkan bukti lengkap sebagai latihan untuk pembaca, tetapi ambil kata-kata saya untuk itu: ada input yang dimulai dengan "1" untuk setiap kemungkinan penggalian mulai dari 0000 hingga ffff.

Ada juga input yang tidak dimulai dengan "1". Dan ada satu yang dimulai dengan karya lengkap Shakespeare juga.

Ini berlaku untuk fungsi hash yang cukup baik, meskipun bukti brute force saya mungkin menjadi tidak layak secara komputasi.

Apa yang Anda gambarkan pada dasarnya adalah serangan pra-gambar. Anda mencoba menemukan input sedemikian rupa sehingga, ketika di-hash, outputnya memiliki beberapa properti seperti "1 terkemuka". *

Ini adalah tujuan eksplisit hash kriptografi untuk mencegah serangan pra-gambar tersebut. Jika Anda dapat melakukan serangan seperti itu, kami cenderung menganggap algoritma itu tidak aman dan berhenti menggunakannya.

Jadi sementara itu berarti itu bukan tidak mungkin, itu berarti algoritma pembelajaran mesin Anda harus secara simultan mengecoh sebagian besar ahli matematika di dunia, dan komputer super mereka. Tidak mungkin Anda melakukannya.

Namun, jika Anda melakukannya, Anda akan dikenal sebagai seseorang yang melanggar algoritma hash kriptografi utama. Ketenaran itu bernilai sesuatu!

^{* Secara teknis "serangan preimage pertama" mencoba menemukan kecocokan untuk hash tertentu. Namun, untuk menunjukkan bahwa algoritma hash memiliki resistensi serangan preimage pertama, mereka biasanya menunjukkan bahwa Anda tidak dapat menemukan informasi yang bermakna tentang input dari hash.}

Sebagian besar jawaban di sini memberi tahu Anda mengapa Anda tidak bisa melakukan ini, tetapi inilah jawaban langsung untuk:

Terlepas dari apakah ini "Kemungkinan", algoritma apa yang akan menjadi pendekatan terbaik?

Asumsikan inputnya cukup besar:

1. Ambil hitungan himpunan karakter yang valid.
2. Ambil kebalikan dari nomor dari langkah 1.

Itu probabilitas bahwa string input dimulai dengan '1'. Anda bahkan tidak perlu melihat input. Jika Anda dapat melakukan lebih baik dari itu, itu berarti hash sangat rusak. Anda dapat menyimpan banyak siklus CPU saat mencoba melatih algoritma untuk memilih angka acak.

Anda dapat melatih suatu algoritma dan mungkin muncul dengan jawaban yang berbeda karena overfitting. Itu kecuali ada sesuatu yang salah dengan algoritma hash. Menggunakan algoritma ini kemudian salah lebih sering daripada jika Anda hanya memilih nilai acak.

Fungsi hash sengaja dirancang untuk menjadi sulit untuk dimodelkan, jadi (seperti yang sudah disebutkan) ini sepertinya sangat sulit. Namun demikian, setiap kelemahan dalam fungsi hashing akan mengurangi entropinya, membuatnya lebih dapat diprediksi.

Terlepas dari apakah ini "Kemungkinan", algoritma apa yang akan menjadi pendekatan terbaik?

Contoh yang berguna adalah Fungsi Secara Fisik Tidak Dapat Dibatasi , atau PUF - yang analog dengan fungsi hashing perangkat keras. Biasanya, variasi pembuatan sengaja digunakan untuk memberikan masing-masing PUF respon yang sedikit berbeda sehingga output 'hash' mereka berbeda untuk input yang diberikan. Kelemahan desain membatasi entropi, dan memberikan pasangan tantangan-respons yang cukup, sering kali mungkin untuk membangun model kotak-hitam PUF sehingga respons untuk tantangan baru yang sebelumnya tidak terlihat dapat diprediksi.

Regresi logistik adalah pendekatan yang paling umum digunakan untuk serangan pemodelan ini, seperti dalam makalah ini oleh Rührmair .

Algoritma genetika (atau strategi evolusi yang lebih umum) dapat menjadi pendekatan alternatif, karena mereka berlaku untuk masalah yang tidak dapat dibedakan dan / atau terpisah secara linear. Mereka juga dibahas dalam makalah di atas.

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

Masalahnya adalah bahwa "pembelajaran mesin" tidak cerdas. Itu hanya mencoba menemukan pola. Di SHA-256, tidak ada pola. Tidak ada yang bisa ditemukan. Pembelajaran mesin tidak memiliki peluang yang lebih baik daripada kekerasan.

Jika Anda ingin memecahkan SHA-256 dengan komputer, satu-satunya kemungkinan adalah membuat kecerdasan nyata , dan karena banyak manusia pintar belum menemukan cara untuk membuat SHA-256, Anda perlu membuat kecerdasan buatan yang jauh lebih tinggi daripada bahwa banyak manusia pintar. Pada titik itu, kita tidak tahu apakah kecerdasan super-manusia seperti itu akan memecahkan SHA-256, membuktikan bahwa itu tidak dapat retak, atau akan memutuskan bahwa kecerdasannya tidak cukup pintar untuk melakukan keduanya (seperti halnya manusia). Kemungkinan keempat tentu saja bahwa kecerdasan buatan yang super-manusiawi itu bahkan tidak akan mengganggu tetapi memikirkan masalah yang lebih penting (untuk itu).