ไม่มีใครรู้วิธีที่จะดุร้ายค่าแรงที่ออฟเซตเฉพาะในไฟล์หรือไม่? มันคือ 4 ไบต์ติดต่อกันซึ่งจะต้องมีการบังคับสัตว์เดรัจฉาน ฉันรู้ SHA-1 ที่ถูกต้องของไฟล์ที่เสียหาย ดังนั้นสิ่งที่ฉันต้องการทำคือเปรียบเทียบไฟล์ที่สมบูรณ์ SHA-1 ทุกครั้งที่เปลี่ยนค่าไบต์

ฉันรู้ว่าแน่นอน 4 ไบต์ซึ่งมีการเปลี่ยนแปลงเพราะไฟล์ถูกมอบให้ฉันโดยผู้เชี่ยวชาญด้านการกู้คืนข้อมูลซึ่งเป็นความท้าทายในการกู้คืน สำหรับผู้ที่มีความสนใจในการรู้ไฟล์ rar มี 4 ไบต์ซึ่งมีการเปลี่ยนแปลงโดยเจตนา ฉันถูกบอกว่าออฟเซ็ตของการเปลี่ยนแปลง 4 ไบต์และ SHA-1 ดั้งเดิม บุคคลนั้นกล่าวว่าเป็นไปไม่ได้ที่จะกู้คืนไฟล์ที่แน่นอนในไฟล์เก็บถาวรเมื่อมีการเปลี่ยนแปลง 4 ไบต์ แม้ว่าจะเป็นเพียงไม่กี่ไบต์และคุณก็รู้แน่ชัดว่าความเสียหายนั้นอยู่ที่ไหน เนื่องจากไม่มีบันทึกการกู้คืน ฉันพยายามที่จะดูว่ามีวิธีการที่ 4 ไบต์เหล่านั้นจะถูกกรอกอย่างถูกต้องเพื่อให้ไฟล์จะขยายตัวโดยไม่มีข้อผิดพลาด ขนาดไฟล์ประมาณ 5mb

ตัวอย่าง :

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

ตัวอย่างออฟเซ็ตที่ฉันเน้นคือ0x78รูปแรกแสดงค่าตามที่CA ฉันต้องการให้สคริปต์ใช้ค่าขึ้น 1 ดังนั้นมันจะกลายCBเป็นดังที่แสดงในรูปที่สอง ฉันต้องการให้เพิ่มค่าโดย1ตลอดแล้วเปรียบเทียบไฟล์ทั้งหมด SHA-1 ในแต่ละครั้ง ทำการเปลี่ยนแปลง 4 ไบต์เหล่านั้นที่ออฟเซ็ตที่ระบุเท่านั้น

มันจะลองCAC5C58Aและเปรียบเทียบ SHA-1 หากไม่ตรงกันก็จะลองจากCBC5C58Aนั้นเมื่อค่าแรกถึงFFแล้วจะไป00C6C58Aและอื่น ๆ โดยทั่วไปฉันต้องการให้สามารถไปจาก00000000-FFFFFFFFแต่ยังมีตัวเลือกให้เลือกว่าคุณต้องการเริ่มต้นและสิ้นสุด ฉันรู้ว่าอาจใช้เวลาพอสมควร แต่ฉันก็ยังอยากลอง โปรดทราบว่าฉันรู้ว่าออฟเซตของไบต์ที่เสียหาย ฉันแค่ต้องการค่าที่ถูกต้อง

หากคุณค้นหาใน Google: "วิธีแก้ไขไฟล์ที่เสียหายด้วยกำลังดุร้าย" มีบุคคลที่เขียนโปรแกรม Linux อย่างไรก็ตามจะใช้งานได้กับไฟล์ที่มาพร้อมกับโปรแกรมเท่านั้น ฉันกำลังมองหาวิธีที่จะใช้กระบวนการเดียวกันกับไฟล์ของฉัน

ต่อไปนี้เป็นโปรแกรม Python ขนาดเล็กที่ทำในสิ่งที่คุณอธิบาย

#!/usr/bin/env python3
from hashlib import sha1

with open('binaryfile', 'rb') as bin:
    binary = bin.read()

base = 0x0078
# ... is not valid Python; add more sequences, or take it out (or see below)
for seq in [[0xCA, 0xC5, 0xC5, 0x8A], [0xCB, 0xC5, 0xC5, 0x8A], ...]:
    copy = binary[0:base]
    copy += bytes(seq)
    copy += binary[base+len(seq):]
    if sha1(copy).hexdigest() == '9968733ce3ff0893bbb0a19e75faaf2fb0000e19':
        print('success with bytes {0}'.format(seq))
        break
else:
    print('no success')

องค์การสหประชาชาติทดสอบเพียงช่วงสั้น ๆ ; โปรด ping ฉันถ้าคุณพบความผิดพลาด

baseระบุตำแหน่งที่จะพยายามที่จะใช้สี่ไบต์และสายยาว'996873... เป็นตัวแทนของฐานสิบหก SHA1 ที่คาดหวัง บรรทัดfor seq in... กำหนดจำนวนไบต์ที่จะลอง; และแน่นอนแทนที่'binaryfile'ด้วยเส้นทางไปยังไฟล์ที่คุณต้องการพยายามกอบกู้

คุณสามารถแทนที่รายการตามตัวอักษร[[0xCA, 0xC5,... ]]ด้วยบางสิ่งบางอย่างเพื่อวนซ้ำค่าที่เป็นไปได้ทั้งหมด แต่โดยทั่วไปแล้วมันเป็นเพียงตัวยึดตำแหน่งสำหรับสิ่งที่มีประโยชน์มากกว่าเพราะฉันไม่แน่ใจว่าสิ่งที่คุณต้องการมีจริงๆ

บางสิ่งที่คล้ายกันfor seq in itertools.product(range(256), repeat=4)):จะวนซ้ำไปตามค่าที่เป็นไปได้ทั้งหมดตั้งแต่ 0 ถึง 2 ³² -1 (คุณจะต้องเพิ่มimport itertoolsใกล้ด้านบนสุดแล้ว) หรือบางทีคุณอาจเพิ่มการชดเชย อัปเดตสคริปต์เพื่อแทนที่ปัจจุบันfor seq inด้วยสิ่งต่อไปนี้ (โดยที่importความต้องการอีกครั้งก่อนโปรแกรมหลัก);

import struct

for n in range(2**32):
    val=(n+0x8AC5C5CA) % 2**32  # notice reverse order
    seq=list(reversed(struct.pack(">I", val)))
    copy = ...

ฉันกลับคำสั่งของไบต์เพื่อให้เพิ่มขึ้นตามธรรมชาติจาก 0x8AC5C5CA เป็น 0x8AC5C5CB แต่จากนั้นการเพิ่มขึ้นครั้งถัดไปจะเป็น 0x8AC5C5CC เป็นต้นstructเวทย์มนตร์คือแปลงเป็นลำดับไบต์ (ต้องค้นหาจากhttps: // stackoverflow) com / a / 26920983/874188 ) สิ่งนี้จะเริ่มต้นที่ 0x8AC5C5CA และไปที่ 0xFFFFFFFF แล้วล้อมรอบเป็น 0x00000000 และไต่กลับขึ้นไปเป็น 0x8AC5C5C9

หากคุณมีหลายช่วงผู้สมัครคุณต้องการตรวจสอบตามลำดับเฉพาะอาจเป็นเช่นนั้น

for rge in [(0x8AC5C5CA, 0x8AFFFFFF), (0x00C6C58A, 0x00FFFFFF),
        (0x00000000, 0x00C6C589), (0x01000000, 0x8AC5C5C9)]:
    for val in range(*rge):
        seq=list(reversed(struct.pack(">I", val)))
        copy = ...

แต่แล้วคุณจะต้องตรวจสอบให้แน่ใจว่าตัวเอง(เริ่มต้นสิ้นสุด)คู่ในrgeครอบคลุมทุกช่องว่างระหว่าง 0x00000000 0xFFFFFFFF และถ้าคุณอยากที่จะตรวจสอบทั้งหมดของมัน (และอีกครั้งโปรดสังเกตว่าช่วงจะเพิ่มไบต์สุดท้ายและseqใช้ไบต์ของค่าในสิ่งที่ตรงกันข้ามตามข้อกำหนดที่คุณระบุไว้)

หากคุณต้องการใช้ที่อยู่สองที่แตกต่างกันbaseคุณรีบวิ่งไปตามขีด จำกัด ของสิ่งที่เป็นไปได้ที่จะทำในชีวิตของคุณด้วยกำลังดุร้าย แต่ตัวอย่างเช่นคุณสามารถแบ่งจำนวน 4 ไบต์เป็นสองส่วน 2 ไบต์และนำไปใช้ในการออฟเซ็ตต่างกัน

base1 = 0x1234
base2 = 0x2345

for seq in range(whatever):
    copy = binary[0:base1]
    copy += bytes(seq[0:1])
    copy += binary[base1+2:base1+base2]
    copy += bytes(seq[2:3])
    copy += binary[base2+2:]

ไม่ไม่ไม่ไม่อีกแล้ว!

คำตอบที่คุณได้รับไม่ค่อยเป็นไปตามที่คุณคาดหวัง

บางคำถามสำหรับคุณ:

• เป็นไปได้หรือไม่ที่ผู้เชี่ยวชาญไม่ทราบว่าเป็นไปได้ที่จะบังคับให้สตริงเป็นไบต์และลอง SHA-1 ซ้ำ ๆ จนกว่ามันจะมาบรรจบกัน? ไม่
• เป็นไปได้ไหมที่เขาจะลืมมัน? ไม่
• เป็นไปได้หรือไม่ที่คุณไม่สามารถทำได้บนไฟล์ rar ไม่
• คือคำตอบอื่น ๆที่ไม่ถูกต้อง อย่างไม่มี

แล้วอะไรล่ะ ... เวลา

ประเด็นคือคุณต้องเปลี่ยนไม่กี่ไบต์ ... เพียง 4!

มันหมายความว่าอะไร? 256 ⁴นั่นคือความเป็นไปได้ 256x256x256x256 ซึ่งเป็นจำนวนที่มากจริงๆ
หากคอมพิวเตอร์ของคุณสามารถประมวลผล1 การทำงานต่อวินาที (การทดแทนในไฟล์ + sha1) ...
คุณควรรอมากกว่า 136 ปีหรือถ้าคุณต้องการมากกว่า 49710 วัน

คุณโชคดีพอที่มีไฟล์แคชล่วงหน้า 5MB (โหลดแล้วใน RAM และแคช) ถามเพียง 0.03 วินาที (ขั้นต่ำ 0.025 วินาที) บนคอมพิวเตอร์เครื่องเก่า นั่นจะทำให้เวลาที่คุณคาดหวังลดลงเหลือ 1242-1492 วัน (มากกว่า 3 ปี)

มันเป็นความจริง BTW ว่าสถิติคุณควรจะมีคำตอบในเชิงบวกในครึ่งหนึ่งของเวลา อย่างไรก็ตามคุณควรรอจนกว่าคุณจะได้ลองความเป็นไปได้ทั้งหมดเพื่อให้แน่ใจว่ามีการทดแทนเพียง 1 รายการที่จะให้ผลรวมตรวจสอบ SHA-1 เดียวกับคุณ ...

ตอนนี้ที่เป็นไปไม่ได้เสียงว่า "เป็นไปไม่ได้ในที่คุ้มค่าปริมาณของเวลา"

วิธีการดำเนินการ

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

• มันเป็นเพียงการระบุไว้ในความคิดเห็นในคำตอบอื่น ๆ ที่คุณไม่จำเป็นต้องคำนวณการตรวจสอบ sha1 ในส่วนก่อนที่ความเสียหาย คุณทำครั้งที่ 1 และคุณประหยัดเวลาสำหรับการวนซ้ำแต่ละครั้งอย่างต่อเนื่อง (อาจเป็นปัจจัยที่ 2 ขึ้นอยู่กับตำแหน่ง)

• สิ่งที่สามารถเปลี่ยนความไร้ค่าของความพยายามคือการเขียนรหัสขนานที่จะทำงานบน GPU หากคุณมีการ์ดกราฟิกที่ดีคุณอาจมีแกนประมวลผลประมาณ 1,000 แกนที่สามารถคำนวณให้คุณในแบบคู่ขนาน (ยิ่งกว่านั้น แต่มีความถี่ต่ำกว่าซีพียู แต่ยังมีจำนวนมาก) หากคุณสามารถลดเวลาจาก 1,400 เป็น 1.4 วันบางทีคุณสามารถทำได้

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

หมายเหตุสุดท้าย

หากพวกเขามีขนาด 6 ไบต์แทนที่จะเป็น 4 คุณจะออกจากเกมด้วยเทคโนโลยีปัจจุบัน