एक भ्रष्ट फ़ाइल को पुनर्प्राप्त करने के लिए कुछ बाइट्स को स्वचालित रूप से 'जानवर बल'

Question

वहाँ किसी को भी एक फ़ाइल में एक विशेष ऑफसेट पर बल मूल्यों को भंग करने का एक तरीका पता है? यह लगातार 4 बाइट्स हैं जिन्हें ब्रूट को मजबूर करने की आवश्यकता होगी। मैं भ्रष्ट फाइल का सही SHA-1 जानता हूं। इसलिए, मैं जो करना चाहता हूं, वह संपूर्ण फ़ाइल SHA-1 की तुलना करता है, हर बार यह बाइट मान बदलता है।

मुझे पता है कि सटीक 4 बाइट्स थे जिन्हें बदल दिया गया था, क्योंकि एक रिकवरी चुनौती के रूप में डेटा रिकवरी विशेषज्ञ द्वारा मुझे फाइल दी गई थी। उन लोगों के लिए जो जानने में रुचि रखते हैं, rar फ़ाइल में 4 बाइट्स हैं जो जानबूझकर बदले गए थे। मुझे परिवर्तित 4 बाइट्स और मूल SHA-1 के ऑफसेट के बारे में बताया गया था। 4 बाइट्स बदल जाने के बाद उस व्यक्ति ने कहा कि संग्रह में सटीक फ़ाइल को पुनर्प्राप्त करने के लिए यह महत्वपूर्ण है। भले ही यह केवल कुछ बाइट्स था और आपको पता था कि भ्रष्टाचार कहाँ था। चूंकि इसमें रिकवरी रिकॉर्ड नहीं है। मैं यह देखने की कोशिश कर रहा हूं कि क्या उन विशेष 4 बाइट्स को सही तरीके से भरने का कोई तरीका है ताकि फाइल बिना त्रुटि के विघटित हो जाए। फ़ाइल का आकार लगभग 5mb है।

उदाहरण :

मैंने तस्वीरें अपलोड की हैं इसलिए यह स्पष्ट रूप से परिभाषित है कि मैं क्या करने के लिए देख रहा हूं। मेरा मानना ​​है कि कोई और अधिक प्रतिनिधि के साथ मेरे लिए उन्हें यहां पोस्ट कर सकता है।

उदाहरण मैं जिस पर ध्यान केंद्रित कर रहा हूं, वह वह 0x78जगह है जहां पहली तस्वीर में मूल्य दिखाई देता है क्योंकि CA मैं चाहता हूं कि स्क्रिप्ट 1 से मूल्य ले ले, इसलिए यह CBदूसरी तस्वीर में दिखाया गया है। मैं चाहता हूं कि इसके द्वारा मूल्य में वृद्धि जारी रहे 1और फिर हर बार पूरी फ़ाइल SHA-1 की तुलना करें। केवल निर्दिष्ट ऑफसेट पर उन 4 बाइट्स में परिवर्तन कर रहा है।

यह CAC5C58ASHA-1 की कोशिश और तुलना करेगा । यदि यह मेल नहीं खाता है, तो यह कोशिश करेगा CBC5C58A। जब एक बार पहला मूल्य पहुंच FFजाएगा तो यह 00C6C58Aऔर इतने पर जाएगा। मूल रूप से, मैं चाहूंगा कि इसे जाने में सक्षम होने के लिए, 00000000-FFFFFFFFलेकिन यह भी चुनने का विकल्प होगा कि आप इसे कहां से शुरू और समाप्त करना चाहते हैं। मुझे पता है कि इसमें कुछ समय लग सकता है लेकिन मैं फिर भी इसे आजमाना चाहूंगा। ध्यान रखें मैं बाइट्स के सटीक ऑफसेट को जानता हूं जो भ्रष्ट हैं। मुझे सिर्फ सही मूल्यों की जरूरत है।

अगर आप Google पर खोज करते हैं: "कैसे एक भ्रष्ट फ़ाइल को जानवर बल से ठीक करना है" एक ऐसा व्यक्ति है जिसने लिनक्स प्रोग्राम लिखा है। हालांकि, यह केवल प्रोग्राम के साथ शामिल फाइलों के खिलाफ काम करता है। मैं अपनी फ़ाइल के साथ उसी प्रक्रिया का उपयोग करने के लिए किसी तरह की तलाश कर रहा हूं।

Comments

सुपर उपयोगकर्ता में आपका स्वागत है! मैंने एक कार्यक्रम के लिए अनुरोध को हटाने के लिए आपके प्रश्न को संपादित किया है, जो ऑफ़-टॉपिक होगा। क्या आप अपने कुछ उदाहरणों को शामिल करने के लिए अपने प्रश्न को संपादित कर सकते हैं ? यह अच्छा है कि आपने शोध किया है, लेकिन हमें वास्तव में यह दिखाते हुए कि कौन सा शोध उपयोगी होगा :)

— bertieb

क्या मैं पूछ सकता हूं कि आपने इस फ़ाइल को कैसे समाप्त किया और आप कैसे सुनिश्चित कर सकते हैं कि वे केवल 4 भ्रष्ट बाइट्स हैं?

— एडुआर्डो

क्या आप फ़ाइल प्रारूप जानते हैं? यदि आप ऐसा करते हैं, तो आप उन्हें सही मानने या सीमाओं को सीमित करने में सक्षम हो सकते हैं, बल्कि उन्हें बल देने की कोशिश कर रहे हैं। सामान्य रूप से, हालांकि, मेरा सुझाव है कि सुरक्षा कारणों से किसी भी दूषित फ़ाइल को डंप किया जाना चाहिए।

— स्टीफन जी

@ मैं वास्तव में आपके प्रश्न के दूसरे भाग में दिलचस्पी ले रहा हूं - वे 4 बाइट्स क्यों?

— क्रेग ओटिस

जिज्ञासा से बाहर, फ़ाइल दूषित कैसे हुई? और आप कैसे जानते हैं कि यह चार बाइट्स थे?

— जॉनी

Answer 1

यहाँ एक छोटा सा पायथन कार्यक्रम है जो आपको वर्णन करता प्रतीत होता है।

#!/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')

संयुक्त राष्ट्रकेवल संक्षेप में परीक्षण किया गया; यदि आप टाइपो पाते हैं तो कृपया मुझे पिंग करें।

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 = ...

लेकिन फिर आपको यह सुनिश्चित करने की आवश्यकता होगी कि 0x00000000 और 0xFFFFFFFF के बीच के अंतरिक्ष के सभी (प्रारंभ, अंत) जोड़े rgeयदि आप वास्तव में इसकी सभी जांच करना चाहते हैं। (और फिर, ध्यान दें कि सीमा अंतिम बाइट को बढ़ाती है और जो seqआपकी बताई गई आवश्यकताओं के अनुसार मूल्य के बाइट्स को रिवर्स में लागू करती है।)

यदि आप दो अलग-अलग baseपतों का उपयोग करना चाहते हैं , तो आप अपने जीवनकाल में पाशविक बल के साथ क्या करना संभव है, इसकी सीमाओं के खिलाफ तेजी से भागते हैं; लेकिन, उदाहरण के लिए, आप 4-बाइट नंबर को 2 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:]

Comments

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— जर्नीमैन गीक

Answer 2

नहीं, नहीं, नहीं और फिर से नहीं!

शायद ही कभी आपको जो उत्तर मिलता है वह वह नहीं होता जिसकी आप अपेक्षा करते हैं।

आपके लिए कुछ प्रश्न:

• क्या यह संभव है कि एक विशेषज्ञ यह नहीं जानता है कि बाइट्स के लिए स्ट्रिंग को बल देना संभव है और जब तक यह अभिसरण नहीं करता है तब तक एसएचए -1 को पुन: प्रयास करें? नहीं
• क्या यह संभव है कि वह इसे भूल जाए? नहीं
• क्या यह संभव है कि आप इसे rar फ़ाइल पर नहीं कर सकते? नहीं
• क्या दूसरा उत्तर गलत है? बिल्कुल नहीं

तो क्या? ... पहर।

मुद्दा यह है कि आपको कुछ बाइट्स को बदलना होगा ... केवल 4!

इसका क्या मतलब है? 256 ⁴ कि 256x256x256x256 संभावनाएं हैं, वास्तव में बड़ी संख्या।
यदि आपका कंप्यूटर प्रति सेकंड 1 ऑपरेशन (फ़ाइल + sha1 में प्रतिस्थापन) को संसाधित करने में सक्षम था ...
तो आपको अधिक इंतजार करना चाहिए 136 साल , या यदि आप अधिक पसंद करते हैं तो 49710 दिन।

आप पर्याप्त भाग्यशाली हैं, एक 5MB प्री-कैश्ड फ़ाइल (पहले से ही रैम और कैश में लोड) एक पुराने कंप्यूटर पर केवल 0.03 सेकंड (न्यूनतम 0.025 सेकंड) के बारे में पूछता है। यह आपके अपेक्षित समय को 1242-1492 दिन (कुछ अधिक तो 3 वर्ष) तक कम कर देता है।

यह सच है, BTW, कि सांख्यिकीय रूप से आपके पास आधे समय में सकारात्मक उत्तर होना चाहिए । फिर भी आपको तब तक इंतजार करना चाहिए जब तक आप सभी संभावनाओं को सुनिश्चित करने की कोशिश करेंगे कि केवल 1 प्रतिस्थापन है जो आपको समान SHA-1 चेकसम देगा ...

अब जब कि असंभव "के रूप में एक में संभव नहीं लगता है सार्थक समय की मात्रा"।

---

कैसे आगे बढ़ा जाए

आपके तकनीकी प्रश्न का अधिक उचित उत्तर: जब आप पाशविक बल के बारे में बात करते हैं तो इसके लिए आवश्यक नेत्रहीन बल नहीं होना चाहिए।

• यह केवल दूसरे उत्तर में एक टिप्पणी में कहा गया है कि आपको भ्रष्टाचार से पहले भाग पर sha1 चेकसम की गणना करने की आवश्यकता नहीं है। आप 1 बार करते हैं और आप प्रत्येक क्रमिक पुनरावृत्ति के लिए समय बचाते हैं (शायद एक कारक 2 यह स्थिति से निर्भर करता है)।

• कुछ ऐसा जो बेकार के प्रयास को बदल सकता है, वह है एक समानांतर कोड लिखना जो GPU पर चलेगा। यदि आपके पास एक अच्छा ग्राफिक कार्ड है तो आपके पास लगभग 1000 कोर हो सकते हैं जो समानांतर में आपके लिए गणना कर सकते हैं (और भी अधिक लेकिन उनके पास सीपीयू की तुलना में कम आवृत्ति है, लेकिन फिर भी वे बहुत सारे हैं)। यदि आप 1400 से 1.4 दिनों तक के समय को कम करने में सक्षम हैं तो शायद आप भी कर सकते हैं।

• एक अलग दृष्टिकोण आपको एक तेज़ समाधान तक ले जा सकता है।
  आपने कहा कि यह एक रार फाइल है। Rar फ़ाइल संरचना ब्लॉकों में बांटा गया है। यदि आप इसकी गणना करते हैं तो आप देख सकते हैं कि भ्रष्टाचार कहां गिरता है। यदि यह डेटा के हिस्से पर है, हेडर के हिस्से पर या दोनों पर। तब आप परिणामस्वरूप कार्य कर सकते हैं। सादगी के लिए मान लीजिए कि यह डेटा पर है:
  आप अपनी ऑफसेट की क्रूर शक्ति कर सकते हैं, उस ब्लॉक के प्रत्येक पॉजिटिव CRC के लिए जांच कर सकते हैं यदि यह पूरी फाइल पर SHA1 पॉजिटिव है। फिर से आप एक समानांतर कोड कर सकते हैं।

अंतिम नोट

यदि वे 4 के बजाय 6 बाइट्स थे, तो आप वर्तमान तकनीक के साथ खेल से बाहर थे।

Comments

शानदार उत्तर - किसी को भी पूरे स्थान को खाली करने की आवश्यकता नहीं होगी, क्योंकि इस उदाहरण में आरएआर आंतरिक जांचों के कारण अनकंप्रेस नहीं होगा, भले ही शा 1 डुप्लिकेट हैश के साथ काम किया हो। 4 बाइट्स को मारना जो sha1 को झूठा हल करता है और एक आंतरिक crc को झूठा होना बहुत संभावना नहीं है।

— रौज़ेना

@ श्रुअजा धन्यवाद बीटीडब्ल्यू न केवल (डबल चेक)। वास्तव में ब्लॉक कम होना चाहिए फिर भ्रष्ट बाइट्स से फ़ाइल के अंत तक का पूरा हिस्सा, और सीआरसी को गणना करने के लिए हल्का होना चाहिए फिर sha1 एल्गोरिथ्म ...

— Hastur

@rrauenza क्या आप जानते हैं कि मैं GPU पर चलने के लिए वास्तविक समानांतर कोड प्राप्त करने के बारे में कैसे जाऊंगा? मेरे पास एक अच्छा जीपीयू है। धन्यवाद।

— Sbt19

नहीं मैं नहीं। यद्यपि आप खोज स्थान को विभाजित करके कई cpus का उपयोग कर सकते हैं।

— रौज़ेना

@ Sbt19 उन्होंने जो कुछ भी आपके बारे में कहा था कि Google उपयोग करने के लिए इतना डरावना नहीं है ;-)। के लिए खोजें (यदि एनवीडिया) Cuda, brute force, sha1और आपके पास बहुत सारे संकेत होंगे, जैसे स्रोत कोड । क्योंकि BTW आपका ध्यान उच्च रखने कि गूगल पथ से ब्राउज़िंग, ओह मेरे बच्चे, आप नेट के अंधेरे पक्षों में से एक पर नेतृत्व कर सकते हैं ... :-)। (जीथुब पर नहीं ... अन्य साइट में जो आप इस तरह के शोधों से मिल सकते हैं)। PS> संबंधित विषयों पर बहुत सारे वैज्ञानिक कागज हैं, जैसे यह एक ...

— Hastur