การเรียนรู้ของเครื่องสามารถถอดรหัสแฮช SHA256 ได้หรือไม่

ฉันมีแฮช SHA256 64 ตัว

ฉันหวังว่าจะฝึกแบบจำลองที่สามารถทำนายได้ว่าข้อความธรรมดาที่ใช้สร้างแฮชเริ่มต้นด้วย 1 หรือไม่

ไม่ว่าจะเป็น "เป็นไปได้" อัลกอริทึมแบบใดที่จะเป็นแนวทางที่ดีที่สุด

ความคิดเริ่มต้นของฉัน:

• สร้างตัวอย่างแฮชขนาดใหญ่ที่เริ่มต้นด้วย 1 และตัวอย่างแฮชขนาดใหญ่ที่ไม่ได้ขึ้นต้นด้วย 1
• ตั้งค่าอักขระแฮช 64 ตัวแต่ละตัวเป็นพารามิเตอร์สำหรับโมเดลการถดถอยโลจิสติกที่ไม่ได้รับการดูแลบางประเภท
• ฝึกโมเดลโดยบอกเมื่อถูก / ผิด
• หวังว่าจะสามารถสร้างแบบจำลองที่สามารถทำนายได้ว่าข้อความธรรมดาเริ่มต้นด้วย 1 หรือไม่ที่มีความแม่นยำสูงพอ (และด้วยคัปปาที่ดี)

นี่ไม่ใช่คำตอบสถิติจริง ๆ แต่:

ไม่คุณไม่สามารถระบุตัวอักษรแรกของข้อความธรรมดาจากแฮชได้เนื่องจากไม่มีสิ่งเช่น "ข้อความธรรมดา" สำหรับแฮชที่ให้

SHA-256 เป็นอัลกอริทึมการแปลงแป้นพิมพ์ ไม่ว่าข้อความธรรมดาของคุณจะเป็นอะไรคุณจะได้รับลายเซ็นขนาด 32 ไบต์ซึ่งมักจะแสดงเป็นสตริงเลขฐานสิบหก 64 ตัว มี plaintexts ที่เป็นไปได้มากกว่าที่เป็นไปได้ที่มีสตริง hex แบบอักขระ 64 ตัว - แฮชเดียวกันสามารถสร้างได้จาก plaintexts ที่แตกต่างกันจำนวนเท่าใดก็ได้ ไม่มีเหตุผลที่จะเชื่อว่าตัวละครตัวแรกที่ถูก / ไม่ได้เป็น '1' นั้นเหมือนกันในทุกรูปแบบที่ทำให้เกิดการแฮช

SHA256 ได้รับการออกแบบให้สุ่มที่สุดเท่าที่จะเป็นไปได้ดังนั้นจึงไม่น่าเป็นไปได้ที่คุณจะสามารถแยกแฮชที่มาจากข้อความธรรมดาที่มีคำนำหน้า 1 จากที่ไม่มี ไม่ควรมีคุณสมบัติของสตริงแฮชที่จะให้ข้อมูลนั้น

ไม่ว่าจะเป็น "เป็นไปได้" อัลกอริทึมแบบใดที่จะเป็นแนวทางที่ดีที่สุด

ขออภัย แต่นั่นเป็นคำถามที่ไร้สาระ หากสิ่งที่เป็นไปไม่ได้คุณจะไม่สามารถค้นหาวิธีที่ดีที่สุดในการแก้ไขปัญหา

ในกรณีนี้สิ่งนี้ควรเป็นไปไม่ได้อย่างแน่นอนเพราะการแฮ็กเป็นฟังก์ชั่นทางเดียว: อินพุตหลายตัว (ไม่มีที่สิ้นสุดจริง) สามารถสร้างเอาต์พุตเดียวกัน หากบิตแรกของอินพุตด้วยตัวเองจะมีผลต่อความน่าจะเป็นของค่าแฮชที่เฉพาะเจาะจงนั่นหมายความว่าอัลกอริทึมแฮชนั้นมีข้อบกพร่องอย่างสมบูรณ์

คุณสามารถฝึกฝนโครงข่ายประสาทเทียมตัวจําแนกเชิงเส้น SVM และอะไรก็ได้ที่จะพยายามทำนาย และถ้าคุณสามารถทำนายอินพุตจากเอาต์พุตสำหรับอัลกอริทึมการแฮชได้อย่างน่าเชื่อถือนี่จะพิสูจน์ได้ว่าอัลกอริทึมนี้ไม่มีค่า ฉันจะบอกว่าสำหรับอัลกอริทึมที่ใช้กันอย่างแพร่หลายเช่น SHA256 ความเป็นไปได้นั้นลดลง อย่างไรก็ตามเป็นวิธีการที่เหมาะสมในการแยกแยะอัลกอริทึมการแฮชใหม่ที่ไม่ผ่านการพิสูจน์และยังไม่ทดลองอย่างรวดเร็ว

ในขณะที่หนึ่งไม่สามารถพิสูจน์การลบด้วยตัวอย่าง แต่ถึงกระนั้นฉันก็รู้สึกว่าตัวอย่างจะมีการชี้นำ; และอาจมีประโยชน์ และมันแสดงให้เห็นว่าคน ๆ หนึ่งจะพยายามแก้ปัญหาที่คล้ายกันอย่างไร

ในกรณีที่ ฉันต้องการทำนายแบบไบนารี่โดยใช้คุณสมบัติที่เป็นเวกเตอร์ไบนารี่ Random Forest เป็นตัวเลือกที่ดี ฉันเดาคำตอบแบบนี้ในส่วนที่สองของคำถามของคุณ: อัลกอริทึมที่ดีคืออะไร

เราต้องการประมวลผลสตริง SHA256 ล่วงหน้าเป็นเวกเตอร์ไบนารี (บูลีน) เนื่องจากแต่ละบิตมีความเป็นอิสระทางสถิติดังนั้นแต่ละบิตจึงเป็นคุณสมบัติที่ดี นั่นจะทำให้อินพุตของเราเป็น 256 องค์ประกอบบูลีนเวกเตอร์

การสาธิต

นี่คือการสาธิตว่าสามารถทำสิ่งทั้งหมดได้อย่างไรโดยใช้ห้องสมุดJulia DecisionTree.jl

คุณสามารถคัดลอกวางด้านล่างลงในพรอมต์ 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)

ผล

เมื่อฉันทำสิ่งนี้การฝึกอบรมกับสตริง ASCII แบบสุ่มที่มีความยาวสูงสุด 10,000 รายการขึ้นไป นี่คือผลลัพธ์ที่ฉันเห็น:

ฝึกโมเดล

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

ชุดฝึกอบรมความแม่นยำ:

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

ชุดทดสอบความแม่นยำ:

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

อภิปรายผล

ดังนั้นโดยพื้นฐานแล้วก็ไม่มีอะไร เราไปจาก 95% ในชุดการฝึกอบรมไปจนถึงเกือบ 50% ในชุดทดสอบ บางคนสามารถใช้การทดสอบสมมติฐานที่เหมาะสมเพื่อดูว่าเราสามารถปฏิเสธ
สมมติฐานว่างได้หรือไม่ แต่ฉันค่อนข้างมั่นใจว่าเราไม่สามารถทำได้ มันเป็นการปรับปรุงเล็กน้อยในเรื่องอัตราการคาดเดา

นั่นแสดงว่าไม่สามารถเรียนรู้ได้ หากสุ่มป่าสามารถไปได้ดีจากอัตราการคาดเดา ป่าสุ่มมีความสามารถในการเรียนรู้อินพุตยาก หากมีสิ่งที่ต้องเรียนรู้ฉันคาดหวังอย่างน้อยสองสามเปอร์เซ็นต์

คุณสามารถเล่นกับฟังก์ชั่นแฮชที่แตกต่างกันโดยการเปลี่ยนรหัส ซึ่งอาจเป็นที่น่าสนใจฉันได้ผลลัพธ์เดียวกันโดยทั่วไปเมื่อใช้ julia ในhashฟังก์ชันที่สร้างขึ้น(ซึ่งไม่ใช่ hsah ที่ปลอดภัยแบบเข้ารหัส แต่ยังคงเป็นแฮชที่ดีดังนั้นควรส่งสตริงที่คล้ายกันออกไปอย่างแน่นอน) CRC32cฉันยังมีพื้นผลเดียวกัน

ฟังก์ชันแฮช (โดยการออกแบบ) เหมาะสมอย่างยิ่งสำหรับการเรียนรู้ด้วยเครื่อง

ML เป็นตระกูลของวิธีการสำหรับการสร้างแบบจำลอง / การประเมินฟังก์ชั่นต่อเนื่องในพื้นที่ นั่นคือคุณกำลังพยายามอธิบายระบบทางกายภาพบางอย่างที่ในขณะที่มันอาจมีความไม่ต่อเนื่องบางอย่างในพื้นที่ส่วนใหญ่ของพารามิเตอร์จะราบรื่นพอที่จะให้มีเพียงตัวอย่างข้อมูลการทดสอบที่กระจัดกระจายเท่านั้นที่สามารถใช้ในการทำนายผลสำหรับคนอื่น ๆ อินพุต ในการทำเช่นนั้นอัลกอริทึม AI จะต้องทำการย่อยสลายข้อมูลอย่างชาญฉลาดซึ่งการฝึกอบรมได้แนะนำว่าถ้าคุณเห็นเช่นนั้นและรูปร่างดังกล่าว (ซึ่งดูเหมือนจะสัมพันธ์กับผลลัพธ์ของการโน้มน้าวเช่นนั้น) เป็นโอกาสที่ดีที่ผลลัพธ์ควรมีในภูมิภาคที่เกี่ยวข้องเช่นนั้นและโครงสร้างดังกล่าว (ซึ่งสามารถอธิบายได้อีกครั้งโดยการสังวัตนา

(ฉันรู้ว่าวิธีการ ML หลายวิธีนั้นไม่เหมือนการโน้มน้าวใจเลย แต่ความคิดโดยทั่วไปนั้นเหมือนกันเสมอ: คุณมีพื้นที่อินพุตบางส่วนที่มีมิติสูงมากเป็นไปไม่ได้ที่จะสุ่มตัวอย่างอย่างละเอียดดังนั้นคุณจึงพบการสลายตัวที่ชาญฉลาด ผลลัพธ์จากตัวอย่างที่ค่อนข้างเบาบาง)

คิดที่อยู่เบื้องหลังกัญชาฟังก์ชันการเข้ารหัสลับ แต่เป็นที่ใด ๆการเปลี่ยนแปลง plaintext ควรส่งผลให้สมบูรณ์ย่อยที่แตกต่างกัน ดังนั้นไม่ว่าคุณจะย่อยสลายฟังก์ชันอย่างไรตัวประมาณในท้องถิ่นจะไม่อนุญาตให้คุณคาดการณ์ว่าความผันผวนเล็ก ๆ รอบส่วนนั้นมีผลต่อผลลัพธ์อย่างไร เว้นแต่ของหลักสูตรที่คุณจริงดำเนินการทั้งหมดของข้อมูลของชุด จำกัด แต่นี้จะไม่ถูกเรียกว่าการเรียนรู้เครื่อง: คุณต้องการเพียงแค่ได้รับการสร้างตารางรุ้ง

นี่เป็นคำถามที่น่าสนใจเพราะมันทำให้เกิดปัญหาเกี่ยวกับสิ่งที่นับว่าเป็น "การเรียนรู้ของเครื่อง" แน่นอนว่ามีอัลกอริทึมที่จะแก้ปัญหานี้ได้ในที่สุดหากสามารถแก้ไขได้ มันจะเป็นเช่นนี้:

1. เลือกภาษาการเขียนโปรแกรมที่คุณชื่นชอบและตัดสินใจเกี่ยวกับการเข้ารหัสที่แมปสตริงทั้งหมดเป็นจำนวนเต็ม (อาจมีขนาดใหญ่มาก)

2. เลือกตัวเลขสุ่มและแปลงเป็นสตริง ตรวจสอบว่าเป็นโปรแกรมที่ถูกต้องในภาษาของคุณหรือไม่ หากไม่ใช่ให้เลือกหมายเลขอื่นแล้วลองอีกครั้ง หากเป็นเช่นนั้นให้เริ่มต้นหยุดทันทีแล้วเพิ่มลงในรายการโปรแกรมที่หยุดชั่วคราว

3. รันโปรแกรมที่หยุดชั่วคราวทั้งหมดสักครู่ หากใด ๆ ของพวกเขาหยุดโดยไม่มีวิธีการแก้ปัญหาที่เพียงพอให้ลบออกจากรายการ หากใครผลิตโซลูชันที่เพียงพอคุณก็เสร็จแล้ว! มิฉะนั้นให้กลับไปที่ 2 หลังจากให้พวกเขาทำงานทั้งหมดสักครู่

ไม่มีคำถามว่าถ้าคุณมีพื้นที่เก็บข้อมูลไม่ จำกัด และเวลาไม่มีที่สิ้นสุดในที่สุดอัลกอริทึมดังกล่าวจะหาทางออกที่ดีที่สุด แต่นั่นอาจไม่ใช่สิ่งที่คุณหมายถึงโดย "การเรียนรู้ของเครื่อง"

นี่คือการถู: ถ้าคุณพิจารณาปัญหาที่เป็นไปได้ทั้งหมดไม่มีอัลกอริทึมการเรียนรู้ของเครื่องสามารถทำได้ดีกว่าโดยเฉลี่ย! นี้เป็นที่รู้จักกันทฤษฎีบทอาหารกลางวันฟรีไม่มี มันพิสูจน์ให้เห็นว่าในบรรดาปัญหาที่เป็นไปได้ทั้งหมดที่คุณสามารถใช้กับอัลกอริทึมการเรียนรู้ของเครื่องใด ๆ จำนวนที่สามารถแก้ไขได้อย่างรวดเร็วนั้นมีขนาดเล็กหายไป

สามารถแก้ไขปัญหาเหล่านั้นได้อย่างรวดเร็วเพียงเพราะถูกควบคุมโดยรูปแบบที่อัลกอริทึมสามารถคาดการณ์ได้ ตัวอย่างเช่นอัลกอริธึมที่ประสบความสำเร็จจำนวนมากถือว่าสิ่งต่อไปนี้:

1. การแก้ปัญหาสามารถอธิบายได้ด้วยอนุกรมจำนวนเชิงซ้อนของการคูณเมทริกซ์และการบิดเบือนแบบไม่เชิงเส้นภายใต้ชุดพารามิเตอร์

2. โซลูชันที่ดีจะถูกรวมเข้าด้วยกันในพื้นที่พารามิเตอร์ดังนั้นสิ่งที่คุณต้องทำคือเลือกย่านการค้นหาค้นหาทางออกที่ดีที่สุดที่นั่นเปลี่ยนย่านการค้นหาของคุณเพื่อให้โซลูชันที่ดีที่สุดอยู่ตรงกลางและทำซ้ำ

เห็นได้ชัดว่าไม่มีการตั้งสมมติฐานเหล่านี้โดยทั่วไป ประการที่สองคือผู้ต้องสงสัยโดยเฉพาะอย่างยิ่ง และอาหารกลางวันฟรีไม่มีบอกเราว่าสมมติฐานเหล่านี้ไม่ได้ถือเวลาส่วนใหญ่ ในความเป็นจริงพวกเขาแทบจะไม่เคยถือ! เป็นเพียงโชคดีของเราที่พวกเขามีปัญหาบางอย่างที่สำคัญจริงๆ

ปัญหาที่คุณเลือกได้รับการออกแบบมาตั้งแต่ต้นจนถึงการละเมิดสมมติฐานที่ 2 ฟังก์ชันแฮชได้รับการออกแบบมาโดยเฉพาะเพื่อให้อินพุตที่คล้ายกันให้เอาต์พุตที่แตกต่างกันโดยสิ้นเชิง

ดังนั้นคำถามของคุณ - อัลกอริทึมการเรียนรู้ของเครื่องที่ดีที่สุดสำหรับการแก้ปัญหานี้คืออะไร - อาจมีคำตอบที่ตรงไปตรงมามาก: การค้นหาแบบสุ่ม

มันเป็นไปไม่ได้ แต่คนสังเกตเห็นรูปแบบบางอย่างใน SHA256 ซึ่งอาจแนะนำไม่ใช่แบบแผนของdistinguisher สำหรับ SHA256 ใช้ Bitcoin (การทำเหมืองแร่ได้เร็วขึ้นไปพร้อมกัน) tldr ของพวกเขา:

"เพื่อแยกความแตกต่างระหว่างแฮชสับเปลี่ยนแบบสุ่มในอุดมคติกับ SHA256 แฮชจำนวนมาก (~ 2 ^ 80) ของผู้สมัคร 1024 บิตบล็อกสองเท่าตามที่ทำใน Bitcoin ตรวจสอบให้แน่ใจว่าบิตของบล็อกผู้สมัครถูกตั้งอย่างกระจัดกระจาย คาดหวัง 512 ค่าเฉลี่ย) ตามโพรโทคอล Bitcoin การละทิ้งบล็อกผู้สมัครที่ไม่ตรงกับมาตรฐาน "ความยากลำบาก" ของ Bitcoin (ซึ่งแฮชที่เป็นผลลัพธ์เริ่มต้นด้วยจำนวน 0 จำนวนมาก) ด้วยชุดของอินพุตที่ถูกต้องที่เหลืออยู่ (467369) การวิเคราะห์นี้เสร็จสิ้น) สังเกตชุดของ 32 บิตในบล็อกอินพุต (อยู่ที่ Bitcoin มี nonce, input bits 607-639) โปรดทราบว่าจำนวนบิตเฉลี่ยที่ตั้งในฟิลด์ nonce นั้นเอียงไปทางซ้าย คือน้อยกว่าค่าที่คาดไว้ของชุด 16 บิต (ค่าเฉลี่ยประมาณ 15.428) "

ดูการอภิปรายเกี่ยวกับ lobste.rs คำอธิบายหนึ่งที่เป็นไปได้คืออคติที่นักขุดได้แนะนำ

ฉันจะตอบด้วยโปรแกรม เพื่อลดข้อกำหนดในการคำนวณฉันจะใช้ตัวแปรของ sha256 ฉันเรียก sha16 ซึ่งเป็นเพียง 16 บิตแรกของ 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))

สิ่งนี้สร้างผลลัพธ์:

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

ฉันจะออกหลักฐานเต็มรูปแบบเป็นแบบฝึกหัดสำหรับผู้อ่าน แต่เอาคำพูดของฉันมันมีอินพุตที่เริ่มต้นด้วย "1" สำหรับแต่ละการย่อยที่เป็นไปได้จาก 0000 ถึง ffff

นอกจากนี้ยังมีอินพุตที่ไม่ได้ขึ้นต้นด้วย "1" และมีสิ่งหนึ่งที่เริ่มต้นด้วยผลงานที่สมบูรณ์ของเช็คสเปียร์ด้วย

นี่ถือเป็นฟังก์ชั่นแฮชที่ดีพอสมควรแม้ว่าการพิสูจน์แรงเดรัจฉานของฉันอาจกลายเป็นสิ่งที่ไม่สามารถคำนวณได้

สิ่งที่คุณอธิบายนั้นเป็นการโจมตีรูปก่อน คุณกำลังพยายามหาอินพุตเช่นเมื่อถูกแฮชเอาท์พุทจะมีคุณสมบัติบางอย่างเช่น "ชั้นนำ 1" *

มันเป็นเป้าหมายที่ชัดเจนของแฮ็คการเข้ารหัสเพื่อป้องกันการโจมตีของภาพก่อน หากคุณสามารถทำการโจมตีดังกล่าวเรามักจะพิจารณาว่าอัลกอริทึมนั้นไม่ปลอดภัยและหยุดใช้งาน

ดังนั้นในขณะที่หมายความว่ามันเป็นไปไม่ได้ แต่หมายความว่าอัลกอริทึมการเรียนรู้ด้วยเครื่องของคุณจะต้องมีนักคณิตศาสตร์จำนวนมากในโลกพร้อมกันและซุปเปอร์คอมพิวเตอร์ ไม่น่าเป็นไปได้ที่คุณจะทำเช่นนั้น

อย่างไรก็ตามหากคุณทำเช่นนั้นคุณจะกลายเป็นที่รู้จักในฐานะคนที่ทำลายอัลกอริธึมแฮชการเข้ารหัสที่สำคัญ ชื่อเสียงนั้นมีค่าอะไร!

^{* เทคนิคการ "โจมตี preimage แรก" พยายามค้นหาการจับคู่สำหรับแฮชที่เฉพาะเจาะจง อย่างไรก็ตามเพื่อแสดงให้เห็นว่าอัลกอริทึมแฮชมีการต้านทานการโจมตีก่อนเกิดพวกเขามักจะแสดงให้เห็นว่าคุณไม่สามารถหาข้อมูลที่มีความหมายเกี่ยวกับอินพุตจากแฮชได้}

คำตอบทั้งหมดที่นี่ส่วนใหญ่จะบอกคุณว่าทำไมคุณไม่สามารถทำได้ แต่นี่คือคำตอบโดยตรงไปที่:

ไม่ว่าจะเป็น "เป็นไปได้" อัลกอริทึมแบบใดที่จะเป็นแนวทางที่ดีที่สุด

สมมติว่าอินพุตมีขนาดใหญ่พอ:

1. นับจำนวนชุดอักขระที่ใช้ได้
2. รับส่วนกลับของจำนวนจากขั้นตอนที่ 1

นั่นเป็นความน่าจะเป็นที่สตริงอินพุตเริ่มต้นด้วย '1' คุณไม่จำเป็นต้องดูอินพุต หากคุณสามารถทำได้ดีกว่านั้นก็หมายความว่าแฮชเสียมาก คุณสามารถบันทึกรอบ CPU จำนวนมากโดยพยายามฝึกอัลกอริทึมเพื่อเลือกตัวเลขแบบสุ่ม

คุณสามารถฝึกอัลกอริทึมและอาจมีคำตอบที่แตกต่างออกไป นั่นคือนอกเสียจากว่ามีบางอย่างผิดปกติกับอัลกอริทึมแฮช การใช้อัลกอริทึมนี้จะผิดพลาดบ่อยกว่าถ้าคุณเพียงแค่เลือกค่าแบบสุ่ม

ฟังก์ชันแฮชได้รับการออกแบบมาโดยมีจุดประสงค์เพื่อให้ยากต่อการทำโมเดลดังนั้น (ตามที่ได้กล่าวไว้แล้ว) นี่อาจเป็นเรื่องยากมาก อย่างไรก็ตามจุดอ่อนใด ๆ ในฟังก์ชั่นการแปลงแป้นพิมพ์จะลดปริมาณเอนโทรปีทำให้สามารถคาดเดาได้มากขึ้น

ไม่ว่าจะเป็น "เป็นไปได้" อัลกอริทึมแบบใดที่จะเป็นแนวทางที่ดีที่สุด

ตัวอย่างที่มีประโยชน์คือฟังก์ชัน Unclonable ทางร่างกายหรือ PUF ซึ่งคล้ายกับฟังก์ชันการแฮชของฮาร์ดแวร์ โดยทั่วไปแล้วรูปแบบการผลิตจะถูกใช้อย่างมีจุดประสงค์เพื่อให้แต่ละ PUF ตอบสนองที่แตกต่างกันเล็กน้อยเพื่อให้ผลลัพธ์ 'แฮช' ของพวกเขาแตกต่างกันสำหรับอินพุตที่กำหนด จุดอ่อนในการออกแบบนั้น จำกัด เอนโทรปีอย่างไรก็ตามและให้คู่ตอบสนองต่อความท้าทายมากพอที่จะสร้างแบบจำลองกล่องดำของ PUF เพื่อให้สามารถคาดการณ์การตอบสนองต่อสิ่งท้าทายที่ไม่เคยเห็นมาก่อนได้

การถดถอยโลจิสติกเป็นวิธีที่ใช้กันมากที่สุดสำหรับการสร้างแบบจำลองการโจมตีเหล่านี้เช่นในบทความนี้โดยRührmair

อัลกอริธึมทางพันธุกรรม (หรือโดยทั่วไปกลยุทธ์การวิวัฒนาการ) อาจเป็นทางเลือกอื่นเนื่องจากมันสามารถใช้ได้กับปัญหาที่ไม่แตกต่างกันและ / หรือแยกกันเป็นเส้นตรง พวกเขายังกล่าวถึงในกระดาษข้างต้น

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

ปัญหาคือว่า "การเรียนรู้ของเครื่อง" ไม่ฉลาด มันแค่พยายามหารูปแบบ ใน SHA-256 ไม่มีรูปแบบ ไม่มีอะไรให้ค้นหา การเรียนรู้ของเครื่องไม่ได้มีโอกาสที่ดีกว่ากำลังดุร้าย

หากคุณต้องการถอดรหัส SHA-256 ด้วยคอมพิวเตอร์ความเป็นไปได้เพียงอย่างเดียวคือการสร้างปัญญาที่แท้จริงและเนื่องจากมนุษย์ที่ฉลาดจำนวนมากไม่พบวิธีสร้าง SHA-256 คุณต้องสร้างปัญญาประดิษฐ์ที่สูงกว่า ว่าของมนุษย์ที่ฉลาดมาก ณ จุดนั้นเราไม่ทราบว่าหน่วยสืบราชการลับสุดยอดมนุษย์จะแตก SHA-256 พิสูจน์ว่ามันไม่สามารถแตกได้หรือจะตัดสินใจว่ามันไม่ฉลาดพอที่จะทำอย่างใดอย่างหนึ่ง (เช่นเดียวกับมนุษย์) ความเป็นไปได้ที่สี่นั้นแน่นอนว่าปัญญาประดิษฐ์ที่ยอดเยี่ยมของมนุษย์จะไม่รบกวน แต่คิดเกี่ยวกับปัญหาที่สำคัญกว่า