एक बूँद पर SHA-1 टकराव को कैसे हैंडल करेगा?

Question

यह शायद वास्तविक दुनिया में अभी तक कभी नहीं हुआ, और कभी नहीं हो सकता है, लेकिन चलो इस पर विचार करें: मान लें कि आपके पास एक गिट रिपॉजिटरी है, एक कमिट करें, और बहुत अशुभ प्राप्त करें: एक बूँदें एक ही SHA-1 होने पर समाप्त होती हैं दूसरे के रूप में जो पहले से ही आपके भंडार में है। सवाल यह है कि Git इससे कैसे निपटेगा? बस असफल? दो बूँद को जोड़ने और जाँच करने का तरीका खोजें कि संदर्भ के अनुसार किसकी आवश्यकता है?

एक वास्तविक समस्या की तुलना में अधिक मस्तिष्क-टीज़र, लेकिन मैंने इस मुद्दे को दिलचस्प पाया।

Comments

एक बार एक मस्तिष्क टीज़र, अब संभावित रूप से एक वास्तविक समस्या ।

— टॉबी

@ टॉबी यह सवाल एक पूर्व-छवि हमले के बारे में था ; Google ने जो प्रदर्शन किया वह टक्कर का हमला है - समान लेकिन थोड़ा अलग। आप यहां अंतर के बारे में अधिक पढ़ सकते हैं ।

— शहीद

@Saheed मैं देख रहा हूँ कि क्या इस सवाल का हिस्सा है, विशेष रूप से एक पूर्व छवि हमले के बारे में है के रूप में सवाल उठाया बस के बारे में है एक एक Git भंडार में टक्कर, नहीं यह शोषण के बारे में।

— टोबी

@ टॉबी मूल मस्तिष्क टीज़र एक हमले (न तो पूर्व-छवि और न ही टकराव) के बारे में था, लेकिन एक आकस्मिक टकराव के बारे में जो इतना अयोग्य है कि यह विचार करने योग्य नहीं है। मुझे लगता है कि साहेब सही ढंग से यह कहना चाह रहे थे कि यह अभी भी वास्तविक समस्या नहीं है। हालाँकि, आप सही कह रहे हैं कि Google टकराव के हमले ने संभावित रूप से एक सुरक्षा समस्या पैदा कर दी है कि कैसे Git का उपयोग किया जाता है।

— एंड्रयू डब्ल्यू फिलिप्स

यहां एक दूसरी टक्कर है जो केवल 320 बाइट्स गोपनीयता है ।loglogotot.com

— विलियम एंट्रीकेन

Answer 1

मैंने यह पता लगाने के लिए एक प्रयोग किया कि इस मामले में Git कैसे व्यवहार करेगा। यह संस्करण 2.7.9 ~ rc0 + next.20151210 (डेबियन संस्करण) के साथ है। मैंने मूल रूप से सिर्फ हैश का आकार 160-बिट से घटाकर 4-बिट कर दिया है, जो निम्नलिखित अंतर और पुनर्निर्माण पुनर्निर्माण को लागू करता है:

--- git-2.7.0~rc0+next.20151210.orig/block-sha1/sha1.c
+++ git-2.7.0~rc0+next.20151210/block-sha1/sha1.c
@@ -246,6 +246,8 @@ void blk_SHA1_Final(unsigned char hashou
    blk_SHA1_Update(ctx, padlen, 8);

    /* Output hash */
-   for (i = 0; i < 5; i++)
-       put_be32(hashout + i * 4, ctx->H[i]);
+   for (i = 0; i < 1; i++)
+       put_be32(hashout + i * 4, (ctx->H[i] & 0xf000000));
+   for (i = 1; i < 5; i++)
+       put_be32(hashout + i * 4, 0);
 }

फिर मैंने कुछ कमिट किया और निम्नलिखित पर ध्यान दिया।

1. यदि एक ही हैश के साथ एक बूँद पहले से मौजूद है, तो आपको कोई चेतावनी नहीं मिलेगी। सब कुछ ठीक लग रहा है, लेकिन जब आप धक्का देते हैं, तो कोई क्लोन, या आप वापस लौटते हैं, तो आप नवीनतम संस्करण खो देंगे (ऊपर बताए गए तरीके के अनुरूप)।
2. यदि कोई ट्री ऑब्जेक्ट पहले से मौजूद है और आप उसी हैश के साथ एक बूँद बनाते हैं: सब कुछ सामान्य लगेगा, जब तक कि आप या तो किसी को धक्का देने की कोशिश नहीं करते हैं या कोई आपकी रिपॉजिटरी को क्लोन नहीं करता है। तब आप देखेंगे कि रेपो भ्रष्ट है।
3. यदि कोई प्रतिबद्ध वस्तु पहले से मौजूद है और आप उसी हैश के साथ एक बूँद बनाते हैं: # 2 के समान - भ्रष्ट
4. यदि एक बूँद पहले से ही मौजूद है और आप उसी हैश के साथ कमिट ऑब्जेक्ट बनाते हैं, तो यह "रेफ" को अपडेट करते समय विफल हो जाएगा।
5. यदि एक बूँद पहले से मौजूद है और आप उसी हैश के साथ एक पेड़ वस्तु बनाते हैं। यह प्रतिबद्ध बनाते समय विफल हो जाएगा।
6. यदि कोई ट्री ऑब्जेक्ट पहले से मौजूद है और आप उसी हैश के साथ कमिट ऑब्जेक्ट बनाते हैं, तो यह "Ref" को अपडेट करते समय विफल हो जाएगा।
7. यदि एक ट्री ऑब्जेक्ट पहले से मौजूद है और आप उसी हैश के साथ ट्री ऑब्जेक्ट बनाते हैं, तो सब कुछ ठीक लगेगा। लेकिन जब आप प्रतिबद्ध होते हैं, तो सभी भंडार गलत पेड़ का संदर्भ देंगे।
8. यदि कोई प्रतिबद्ध ऑब्जेक्ट पहले से मौजूद है और आप उसी हैश के साथ कमिट ऑब्जेक्ट बनाते हैं, तो सब कुछ ठीक लगेगा। लेकिन जब आप प्रतिबद्ध होते हैं, तो कमिट कभी नहीं बनाई जाएगी, और HEAD पॉइंटर को एक पुरानी कमिट में ले जाया जाएगा।
9. यदि कोई प्रतिबद्ध ऑब्जेक्ट पहले से मौजूद है और आप उसी हैश के साथ ट्री ऑब्जेक्ट बनाते हैं, तो यह प्रतिबद्ध बनाते समय विफल हो जाएगा।

# 2 के लिए आपको आमतौर पर इस तरह की त्रुटि मिलेगी जब आप "गिट पुश" चलाते हैं:

error: object 0400000000000000000000000000000000000000 is a tree, not a blob
fatal: bad blob object
error: failed to push some refs to origin

या:

error: unable to read sha1 file of file.txt (0400000000000000000000000000000000000000)

यदि आप फ़ाइल को हटाते हैं और फिर "git checkout file.txt" चलाते हैं।

# 4 और # 6 के लिए, आपको आमतौर पर इस तरह की त्रुटि मिलेगी:

error: Trying to write non-commit object
f000000000000000000000000000000000000000 to branch refs/heads/master
fatal: cannot update HEAD ref

जब "कमिट कमिट" चल रहा हो। इस मामले में आप आम तौर पर फिर से "गिट कमिट" टाइप कर सकते हैं क्योंकि यह एक नया हैश (बदले हुए टाइमस्टैम्प के कारण) बनाएगा

# 5 और # 9 के लिए, आपको आमतौर पर इस तरह की त्रुटि मिलेगी:

fatal: 1000000000000000000000000000000000000000 is not a valid 'tree' object

जब "कमिट कमिट" चल रहा हो

यदि कोई आपके भ्रष्ट भंडार को क्लोन करने की कोशिश करता है, तो वे आम तौर पर कुछ ऐसा देखेंगे:

git clone (one repo with collided blob,
d000000000000000000000000000000000000000 is commit,
f000000000000000000000000000000000000000 is tree)

Cloning into 'clonedversion'...
done.
error: unable to read sha1 file of s (d000000000000000000000000000000000000000)
error: unable to read sha1 file of tullebukk
(f000000000000000000000000000000000000000)
fatal: unable to checkout working tree
warning: Clone succeeded, but checkout failed.
You can inspect what was checked out with 'git status'
and retry the checkout with 'git checkout -f HEAD'

मुझे क्या "चिंता" है कि दो मामलों (2,3) में रिपॉजिटरी बिना किसी चेतावनी के भ्रष्ट हो जाती है, और 3 मामलों (1,7,8) में, सब कुछ ठीक लगता है, लेकिन रिपॉजिटरी की सामग्री आपकी अपेक्षा से भिन्न है होने के लिए। क्लोनिंग या पुलिंग करने वाले लोगों के पास आपके पास की तुलना में एक अलग सामग्री होगी। मामले 4,5,6 और 9 ठीक हैं, क्योंकि यह एक त्रुटि के साथ बंद हो जाएगा। मुझे लगता है कि यह कम से कम सभी मामलों में एक त्रुटि के साथ विफल हो तो बेहतर होगा।

Comments

बहुत बढ़िया जवाब - यह देखने के लिए हैश के आकार को कम करना कि यह वास्तव में कैसा व्यवहार करता है एक महान विचार है।

— गन्नुरू

@Gnurou मैं सहमत हूँ और उस समय उस उत्तर को जारी रखा। क्या उन मामलों का उल्लेख मेलिंग सूची में किया गया था?

— वॉनसी

यह कैसे संभव है कि यह वास्तव में घटे हुए हैश आकार के बिना होता है?

— मथियास बदर

इसके अलावा, यदि कोई अन्य हैशिंग एल्गोरिथ्म में जाने के लिए योजनाएं क्या हैं।

— पीट

जरुर पढ़े - Linus Torval की व्याख्याएँ: plus.google.com/+LinusTorvalds/posts/7tp2gYWQugL

— phil_lgr

Answer 2

मूल उत्तर (2012) ( shattered.ioनीचे 2017 SHA1 टक्कर देखें)

लिनुस का वह पुराना (2006) उत्तर अभी भी प्रासंगिक हो सकता है:

नहीं। यदि उसके पास समान SHA1 है, तो इसका मतलब है कि जब हम दूसरे छोर से वस्तु प्राप्त करते हैं, तो हम पहले से मौजूद वस्तु को अधिलेखित नहीं करेंगे ।

तो क्या होता है कि यदि हम कभी टकराव देखते हैं, तो किसी विशेष रिपॉजिटरी में "पहले" ऑब्जेक्ट हमेशा ओवरराइडिंग को समाप्त करेगा। लेकिन ध्यान दें कि "पहले" स्पष्ट रूप से प्रति-रिपॉजिटरी है, इस अर्थ में कि गिट ऑब्जेक्ट नेटवर्क एक डीएजी उत्पन्न करता है जो पूरी तरह से ऑर्डर नहीं किया जाता है, इसलिए जबकि विभिन्न रिपॉजिटरी प्रत्यक्ष वंश के मामले में "पहले" के बारे में सहमत होंगे, यदि ऑब्जेक्ट अलग-अलग और सीधे संबंधित शाखाओं के माध्यम से नहीं आया, दो अलग-अलग रिपोज़ ने स्पष्ट रूप से दो वस्तुओं को अलग-अलग क्रम में प्राप्त किया हो सकता है।

हालांकि, "पहले ओवरराइड" बहुत ज्यादा होता है जो आप एक सुरक्षा दृष्टिकोण से चाहते हैं: याद रखें कि गिट मॉडल यह है कि आपको मुख्य रूप से केवल अपने स्वयं के भंडार पर भरोसा करना चाहिए ।
इसलिए यदि आप एक " git pull" करते हैं, तो नई आने वाली वस्तुएं आपके पास पहले से मौजूद वस्तुओं की तुलना में कम भरोसेमंद हैं, और जैसे कि किसी पुरानी वस्तु को बदलने के लिए एक नई वस्तु की अनुमति देना गलत होगा।

तो आपके पास टक्कर के दो मामले हैं:

• अनजाने तरह है, जहां आप किसी भी तरह बहुत बहुत अशुभ हैं, और दो फ़ाइलें एक ही SHA1 होने अंत।
  उस बिंदु पर, क्या होता है कि जब आप उस फ़ाइल को कमिट करते हैं (या git-update-indexइसे इंडेक्स में ले जाने के लिए " " करते हैं, लेकिन अभी तक प्रतिबद्ध नहीं हैं), नई सामग्री के SHA1 की गणना की जाएगी, लेकिन चूंकि यह एक पुरानी वस्तु से मेल खाता है, एक नई वस्तु नहीं बनाई जाएगी, और कमिट-या-इंडेक्स पुरानी वस्तु की ओर इशारा करता है ।
  आप तुरंत नोटिस नहीं करेंगे (चूंकि इंडेक्स पुरानी वस्तु SHA1 से मेल खाएगा, और इसका मतलब है कि कुछ " git diff" चेक-आउट कॉपी का उपयोग करेगा), लेकिन अगर आप कभी ट्री-लेवल डिफरेंस करते हैं (या आप एक क्लोन करते हैं या पुलआउट, या चेकआउट के लिए बाध्य करें) आप अचानक ध्यान देंगे कि फ़ाइल कुछ बदल गई हैआपकी अपेक्षा से पूरी तरह अलग।
  तो आप आमतौर पर इस तरह के टकराव को काफी जल्दी नोटिस करेंगे।
  संबंधित समाचार में, सवाल यह है कि अनजाने टकराव के बारे में क्या करना है ..
  सबसे पहले, मुझे लोगों को याद दिलाना चाहिए कि अनजाने में हुई टक्कर वास्तव में वास्तव में बहुत कम संभावना नहीं है, इसलिए हम पूरी इतिहास में इसे कभी नहीं देख पाएंगे। ब्रह्माण्ड का।
  लेकिन अगर ऐसा होता है, तो यह दुनिया का अंत नहीं है: आपको जो सबसे अधिक संभावना है, वह है बस उस फ़ाइल को बदलना है जो थोड़ा टकरा गया है, और बस नई सामग्री को परिवर्तित सामग्री के साथ बाध्य करें (" /* This line added to avoid collision */" कहकर टिप्पणी जोड़ें )) फिर जादू SHA1 के बारे में सिखाएं जो खतरनाक दिखाया गया है।
  तो कुछ मिलियन वर्षों में, शायद हमें एक या दो "जहर" SHA1 मूल्यों को जोड़ना होगा। यह एक रखरखाव समस्या होने की संभावना नहीं है;)

• टक्कर के हमलावर तरह क्योंकि किसी को तोड़ दिया (या जानवर-मजबूर) SHA1।
  यह एक अनजाने प्रकार की तुलना में स्पष्ट रूप से बहुत अधिक संभावना है, लेकिन परिभाषा के अनुसार यह हमेशा एक "दूरस्थ" भंडार है। यदि हमलावर के पास स्थानीय रिपॉजिटरी तक पहुंच होती है, तो उसके पास आपके पेंच कसने के बहुत आसान तरीके होंगे।
  तो इस मामले में, टकराव पूरी तरह से एक गैर-मुद्दा है : आपको "खराब" रिपॉजिटरी मिलेगी जो कि हमलावर के इरादे से अलग है, लेकिन चूंकि आप वास्तव में कभी भी अपनी टकराने वाली वस्तु का उपयोग नहीं करेंगे, यह वस्तुतः कोई अलग नहीं है हमलावर को बिल्कुल टक्कर नहीं मिली, लेकिन सिर्फ आपके पास पहले से मौजूद वस्तु का उपयोग करना (यानी यह समान SHA1 उत्पन्न करने वाली समान फ़ाइल की "तुच्छ" टक्कर के बराबर 100% है)।

SHA-256 के उपयोग का प्रश्न नियमित रूप से उल्लिखित है, लेकिन अभी (2012) के लिए कार्य नहीं करता है।
नोट: 2018 और Git 2.19 से शुरू होकर , SHA-256 का उपयोग करने के लिए कोड को फिर से शुरू किया जा रहा है।

---

नोट (हास्य): आप एक विशेष SHA1 उपसर्ग के लिए प्रतिबद्ध कर सकते हैं , ब्रैड फिट्ज़पैट्रिक ( ) से परियोजना गिटब्र्यूट के साथ ।bradfitz

gitbrute brute-Force की एक जोड़ी लेखक + कमिटर टाइमस्टैम्प्स जैसे कि परिणामी git कमिट में आपका वांछित उपसर्ग है।

उदाहरण: https://github.com/bradfitz/deadbeef

---

डैनियल Dinnyes बताते टिप्पणी में करने के लिए 7.1 Git उपकरण - संशोधन चयन , जिसमें शामिल है:

एक उच्च संभावना मौजूद है कि आपकी प्रोग्रामिंग टीम के प्रत्येक सदस्य को उसी रात असंबंधित घटनाओं में भेड़ियों द्वारा हमला और मार दिया जाएगा।

---

और भी हाल ही में (फरवरी 2017) shattered.ioने SHA1 टक्कर के लिए फोर्जिंग की संभावना का प्रदर्शन किया:
(मेरे अलग उत्तर में बहुत अधिक देखें , जिसमें लिनुस टॉर्वाल्ड्स Google+ पोस्ट शामिल हैं)

• a / अभी भी 9,223,372,036,854,775,808 SHA1 अभिकलन की आवश्यकता है। इसने 6,500 वर्षों के एकल-सीपीयू संगणनाओं और 110 वर्षों के एकल-जीपीयू संगणनाओं के बराबर प्रसंस्करण शक्ति ली।
• b / फोर्ज एक फाइल ( एक ही SHA1 के साथ), लेकिन अतिरिक्त बाधा के साथ इसकी सामग्री और आकार समान SHA1 (अकेले सामग्री पर टकराव पर्याप्त नहीं है) का उत्पादन करेगा: देखें " git हैश की गणना कैसे की जाती है? ") : सामग्री और आकार के आधार पर एक बूँद SHA1 की गणना की जाती है ।

अधिक के लिए वैलेरी अनीता अरोरा से " क्रिप्टोग्राफ़िक हैश फ़ंक्शन के जीवनकाल " देखें । उस पृष्ठ में, वह नोट करती है:

Google ने सुरक्षा महत्वपूर्ण अनुप्रयोगों के लिए SHA-1 का उपयोग करने से रोकने के लिए सभी को समझाने के लिए 6500 CPU वर्ष और 110 GPU वर्ष बिताए।
यह भी क्योंकि यह अच्छा था

नीचे मेरे अलग उत्तर में और देखें ।

Comments

मोड़: अभी भी जोड़ने के बाद एक ही हैश करता है /* This line added to avoid collision */: D आप दो बार लॉटरी जीत सकते हैं: P

— Janus Troelsen

@JanusTroelsen यकीन है, लेकिन यह अभी भी एक लॉटरी है, है ना? ;) (के रूप में SHA1 के बारे में इस छोटे नोट में उल्लेख किया गया है )

— VonC

उस संदर्भ के बारे में @VonC : एक वैश्विक वेयरवोल्फ महामारी का प्रकोप है - जिसने सारी मानवता को मिटा दिया और परिणामस्वरूप उसी रात मेरे सभी डेवलपर्स की भीषण मौत हो गई, भले ही वे भौगोलिक रूप से वितरित किए गए थे - एक असंबंधित घटना ?? बेशक, यह मानते हुए कि यह एक पूर्णिमा पर हुआ था, जाहिर है। अब, ऐसा परिदृश्य चीजों को बदल देगा। इसके बारे में सोचना भी पागलपन है! यह संभावना के एक पूरे अलग पैमाने पर है! इसका मतलब यह होगा कि हमें ... STOP USING GIT! अभी!!! हर कोई RUUUUUN !!!!!!!

— डेनियल डिनिएस

ध्यान दें कि gitbrute किसी विशेष SHA1 को बाध्य नहीं करता है, बल्कि केवल एक उपसर्ग (यानी पूरे SHA1 का एक उप भाग) है। एक संपूर्ण SHA1 (यानी कुंजी की पूरी लंबाई के एक उपसर्ग के साथ) को मजबूर करना शायद "बहुत लंबा" होगा।

— mb14

@JanusTroelsen तब आप जोड़ेंगे:/* This line added to avoid collision of the avoid collision line */

— smg

Answer 3

प्रो गिट के अनुसार :

यदि आप किसी ऐसी वस्तु को करने के लिए करते हैं, जो आपके भंडार में पिछले ऑब्जेक्ट के समान SHA-1 मान के लिए हैश करती है, तो Git आपके Git डेटाबेस में पहले से मौजूद ऑब्जेक्ट को देखेगा और यह मान लेगा कि यह पहले से ही लिखा गया था। यदि आप किसी बिंदु पर उस वस्तु को फिर से देखने की कोशिश करते हैं, तो आपको हमेशा पहली वस्तु का डेटा मिलेगा।

तो यह विफल नहीं होगा, लेकिन यह आपकी नई वस्तु को भी नहीं बचाएगा।
मुझे नहीं पता कि यह कमांड लाइन पर कैसे दिखेगा, लेकिन यह निश्चित रूप से भ्रमित करने वाला होगा।

थोड़ा और नीचे, यही संदर्भ इस तरह के टकराव की संभावना को स्पष्ट करने का प्रयास करता है:

यहां एक उदाहरण दिया गया है जिससे आपको अंदाजा हो सकता है कि SHA-1 टक्कर लेने में क्या होगा। यदि पृथ्वी पर सभी 6.5 बिलियन मानव प्रोग्रामिंग कर रहे थे, और हर दूसरे, प्रत्येक एक कोड का उत्पादन कर रहा था जो पूरे लिनक्स कर्नेल इतिहास (1 मिलियन गिट ऑब्जेक्ट) के बराबर था और इसे एक विशाल गिट रिपॉजिटरी में धकेल दिया, तो 5 साल तक लगेंगे उस भंडार में एक SHA-1 ऑब्जेक्ट के टकराव की 50% संभावना होने के लिए पर्याप्त वस्तुएं थीं। एक उच्च संभावना मौजूद है कि आपकी प्रोग्रामिंग टीम के प्रत्येक सदस्य को उसी रात असंबंधित घटनाओं में भेड़ियों द्वारा हमला और मार दिया जाएगा।

Comments

मैं आखिरी वाक्य पर संख्याओं के लिए स्रोत देखना चाहता हूं ;-)

— जोकिम सॉयर

@ जैस्पर: वह लिंक अच्छा दस्तावेज है, लेकिन इसमें उसी रात असंबंधित घटनाओं में भेड़ियों द्वारा हमला किए जाने और मारे जाने की टीम के प्रत्येक सदस्य की संभावना पर आंकड़े शामिल नहीं हैं।

— जोआचिम सॉरे

@ जैस्पर: ठीक है, जिस तरह से मैंने इसे पढ़ा, पाठ का शाब्दिक दावा है कि एक ही रात में भेड़ियों द्वारा मारे जाने वाले 6.5 बिलियन टीम के सदस्यों की संभावना 50% से अधिक है। लेकिन मेरे अपने बयान के लिए मुख्य आपत्ति यह है कि इस तरह की घटना होती है है के लिए एक विश्वव्यापी घटना हो; यह अविश्वसनीय है कि असंबंधित घटनाओं के कारण ऐसा हो सकता है । ;)

— कीथ रॉबर्टसन

@KeithRobertson मुझे पूरा यकीन है कि यह पोस्ट आपकी सभी वास्तविक टीम के सदस्यों को हैश टक्कर की संभावना की तुलना में खाए जाने की संभावना के बारे में बात कर रही है, अगर दुनिया में हर कोई कोड की पागल मात्रा का उत्पादन कर रहा था, समय के साथ उन परिस्थितियों में ले जाता है टक्कर का 50% मौका पाने के लिए (यानी भेड़ियों की घटना में पूरी दुनिया शामिल नहीं थी और 50% भेड़ियों से अलग थी)। हालांकि आपको यह मुद्दा मिल गया है, अगर इस तरह की घटना समझ से बाहर है, तो एक हिट हैश टकराव होना चाहिए। (बेशक, एक (लगभग) विशुद्ध रूप से मौका आधारित है और दूसरा नहीं है, लेकिन अभी भी है।)

— जैस्पर

आज रात भेड़ियों के लिए बाहर देखो

— टॉबी

Answer 4

2012 से मेरे पिछले उत्तर को जोड़ने के लिए , अब (फ़रवरी 2017, पांच साल बाद), वास्तविक SHA-1 का एक उदाहरण टूटकर बिखर गया है । जहाँ आप दो टकराने वाली पीडीएफ फाइलों को तैयार कर सकते हैं: वह है SHA- पहली पीडीएफ फाइल पर 1 डिजिटल हस्ताक्षर जिसे दूसरी पीडीएफ फाइल पर वैध हस्ताक्षर के रूप में भी दुरुपयोग किया जा सकता है।
यह भी देखें कि " वर्षों से मृत्यु के दरवाजे पर, व्यापक रूप से इस्तेमाल किया जाने वाला SHA1 फ़ंक्शन अब मर चुका है ", और यह दृष्टांत है ।

26 फरवरी का अपडेट: लाइनस ने Google+ पोस्ट में निम्नलिखित बिंदुओं की पुष्टि की :

(१) पहला उतर - आकाश नहीं गिर रहा है। सुरक्षा हस्ताक्षर जैसी चीजों के लिए एक क्रिप्टोग्राफिक हैश का उपयोग करने और गिट जैसी सामग्री-पता योग्य प्रणाली के लिए "सामग्री पहचानकर्ता" बनाने के लिए एक का उपयोग करने के बीच एक बड़ा अंतर है।

(२) दूसरी बात, इस विशेष SHA1 हमले की प्रकृति का अर्थ है कि वास्तव में इसके खिलाफ शमन करना बहुत आसान है, और उस शमन के लिए पहले से ही पैच के दो सेट हैं।

(३) और अंत में, वास्तव में कुछ अन्य हैश के लिए एक बहुत ही सीधा संक्रमण है जो दुनिया को नहीं तोड़ेगा - या यहां तक ​​कि पुराने गिट रिपॉजिटरी को भी।

उस संक्रमण के बारे में, Q1 2018 Git 2.16 को हैश एल्गोरिथ्म का प्रतिनिधित्व करते हुए एक संरचना जोड़कर देखें। उस संक्रमण का कार्यान्वयन शुरू हो गया है।

Git 2.19 (Q3 2018) को शुरू करते हुए , Git ने SHA-256 को NewHash के रूप में चुना है , और इसे कोड को एकीकृत करने की प्रक्रिया में है (इसका अर्थ है कि SHA1 अभी भी डिफ़ॉल्ट है (Q2 2019, Git 2.21), लेकिन SHA2 उत्तराधिकारी होगा)

---

मूल उत्तर (25 फरवरी) लेकिन:

• यह एक बूँद बनाने की अनुमति देता है, हालाँकि पेड़ का SHA-1 तब भी बदलता रहेगा क्योंकि जाली बूँद का आकार मूल एक जैसा नहीं हो सकता है: " git हैश की गणना कैसे की जाती है? " एक बूँद SHA1 सामग्री और आकार के आधार पर गणना की जाती है ।
  यह हालांकि के लिए कुछ मुद्दा हैgit-svn । या खुद svn के साथ , जैसा कि यहां देखा गया है ।
• जैसा कि मैंने अपने मूल उत्तर में उल्लेख किया है , इस तरह के एक प्रयास की लागत अभी भी (6,500 सीपीयू वर्ष और 100 जीपीयू वर्ष) के लिए निषेधात्मक है " वेल्लिप अनीता फ़ंक्शंस के जीवनकाल " में वैलेरी अनीता अरोरा भी देखें ।
• जैसा कि पहले टिप्पणी की गई थी, यह सुरक्षा या विश्वास के बारे में नहीं है , लेकिन डेटा अखंडता (डी-डुप्लीकेशन और त्रुटि का पता लगाने) जो कि आसानी से पता लगाया जा सकता है git fsck, जैसा कि लिनुस टॉर्वाल्ड्स ने आज उल्लेख किया है। git fsckएक के बाद छिपे हुए अपारदर्शी डेटा के साथ एक प्रतिबद्ध संदेश के बारे में चेतावनी देगा NUL(हालांकि NULयह हमेशा एक कपटपूर्ण फ़ाइल में मौजूद नहीं है )।
  हर कोई चालू नहीं करता है transfer.fsck, लेकिन गिटहब करता है: किसी भी विकृत वस्तु या टूटी हुई कड़ी के मामले में किसी भी तरह का धक्का होगा। हालाँकि ... एक कारण है कि यह डिफ़ॉल्ट रूप से सक्रिय नहीं है ।
• एक पीडीएफ फाइल में बाइनरी डेटा हो सकता है जिसे आप जाली एसएचए -1 उत्पन्न करने के लिए बदल सकते हैं, जैसा कि जाली स्रोत कोड के रूप में विरोध किया जाता है।
  एक ही हेड कमिट हैश और विभिन्न सामग्रियों के साथ दो गिट रिपोजिटरी बनाने में वास्तविक मुद्दा। और फिर भी, हमले को जटिल बना हुआ है ।
• लाइनस कहते हैं :

  एक SCM की पूरी बात यह है कि यह एक बार की घटना के बारे में नहीं है, बल्कि निरंतर इतिहास के बारे में है। यह भी मौलिक रूप से इसका मतलब है कि एक सफल हमले को समय के साथ काम करने की आवश्यकता है, और पता लगाने योग्य नहीं है।
  यदि आप एक SCM को एक बार बेवकूफ बना सकते हैं, तो अपना कोड डालें, और यह अगले सप्ताह पता लगाया जाता है, आपने वास्तव में कुछ भी उपयोगी नहीं किया। आपने ही अपने को जलाया।

जॉय हेस उन pdf को एक Git रेपो में आज़माता है और उसने पाया :

इसमें एक ही SHA और आकार के साथ दो फाइलें शामिल हैं, जो सामग्री के लिए हेडर को प्रीपेन्ड करने के तरीके के लिए अलग-अलग ब्लब्स प्राप्त करते हैं।

joey@darkstar:~/tmp/supercollider>sha1sum  bad.pdf good.pdf 
d00bbe65d80f6d53d5c15da7c6b4f0a655c5a86a  bad.pdf
d00bbe65d80f6d53d5c15da7c6b4f0a655c5a86a  good.pdf
joey@darkstar:~/tmp/supercollider>git ls-tree HEAD
100644 blob ca44e9913faf08d625346205e228e2265dd12b65    bad.pdf
100644 blob 5f90b67523865ad5b1391cb4a1c010d541c816c1    good.pdf

इन टकराने वाली फ़ाइलों के समान डेटा को लागू करते समय, अन्य टकराव उत्पन्न होते हैं, डेटा को प्रस्तुत नहीं करता है।

तो हमले का मुख्य वेक्टर (कमिट करने के लिए) होगा :

• एक नियमित प्रतिबद्ध वस्तु उत्पन्न करें;
• चुने हुए उपसर्ग के रूप में संपूर्ण प्रतिबद्ध ऑब्जेक्ट + NUL का उपयोग करें, और
• टकराने वाली अच्छी / बुरी वस्तुओं को उत्पन्न करने के लिए समान-उपसर्ग टकराव के हमले का उपयोग करें।
• ... और यह बेकार है क्योंकि अच्छी और बुरी प्रतिबद्ध वस्तुएं अभी भी उसी पेड़ की ओर इशारा करती हैं!

इसके अलावा, आप पहले से ही प्रत्येक फ़ाइल में मौजूद SHA-1 के खिलाफ क्रिप्टोनालिटिक टकराव के हमलों का पता लगा सकते हैं cr-marcstevens/sha1collisiondetection

जीआईटी में इसी तरह के चेक को जोड़ने से कुछ गणना लागत आ जाएगी ।

हैश बदलने पर, लिनक्स टिप्पणियाँ :

हैश के आकार और हैश एल्गोरिथम की पसंद स्वतंत्र मुद्दे हैं।
संभवतः आप जो करते हैं वह 256-बिट हैश पर स्विच करता है, उस आंतरिक और देशी git डेटाबेस में उपयोग करें, और फिर डिफ़ॉल्ट रूप से केवल 40-वर्ण हेक्स स्ट्रिंग के रूप में हैश दिखाते हैं (इस तरह की कैसे हम पहले से ही चीजों को संक्षिप्त करते हैं कई स्थितियां)।
इस तरह git के आस-पास के उपकरण भी तब तक बदलाव नहीं देखते हैं जब तक कि कुछ विशेष " --full-hash" तर्क (या " --abbrev=64" या जो कुछ भी - डिफ़ॉल्ट रूप से पारित नहीं हो जाता है जिसे हम 40 में संक्षिप्त करते हैं)।

फिर भी, एक संक्रमण योजना (SHA1 से दूसरे हैश फ़ंक्शन तक) अभी भी जटिल होगी , लेकिन सक्रिय रूप से अध्ययन किया जाएगा।
एक convert-to-object_idअभियान है प्रगति पर :

---

20 मार्च को अपडेट करें: GitHub एक संभावित हमले और इसकी सुरक्षा का विवरण देता है :

SHA-1 नामों को विभिन्न तंत्रों के माध्यम से विश्वास सौंपा जा सकता है। उदाहरण के लिए, Git आपको क्रिप्टोग्राफिक रूप से एक प्रतिबद्ध या टैग पर हस्ताक्षर करने की अनुमति देता है। ऐसा करना केवल कमिट या टैग ऑब्जेक्ट पर ही हस्ताक्षर करता है, जो बदले में अन्य ऑब्जेक्ट्स में उनके SHA-1 नामों का उपयोग करके वास्तविक फ़ाइल डेटा को इंगित करता है। उन वस्तुओं में टकराव एक हस्ताक्षर का उत्पादन कर सकता है जो वैध प्रतीत होता है, लेकिन जो कि हस्ताक्षरकर्ता की तुलना में अलग-अलग डेटा को इंगित करता है। इस तरह के एक हमले में हस्ताक्षरकर्ता केवल आधे हिस्से को देखता है, और पीड़ित दूसरे को आधा देखता है।

सुरक्षा:

हालिया हमला SHA-1 एल्गोरिथ्म में कमजोरियों का फायदा उठाने के लिए विशेष तकनीकों का उपयोग करता है जो बहुत कम समय में टकराव का पता लगाते हैं। ये तकनीक बाइट्स में एक पैटर्न छोड़ती हैं, जो एक टकराने वाले जोड़े के आधे के SHA-1 की गणना करते समय पता लगाया जा सकता है।

GitHub.com अब प्रत्येक SHA-1 के लिए यह पता लगाता है कि यह गणना करता है, और यदि ऑपरेशन इस बात का सबूत है कि वस्तु एक टकराने वाली जोड़ी का आधा हिस्सा है, तो उसे रोक देती है। यह हमलावरों को गिटहब का इस्तेमाल करने से रोकने के लिए एक परियोजना को समझाने के लिए "निर्दोष" को उनकी टक्कर का आधा हिस्सा मानने से रोकता है, साथ ही उन्हें दुर्भावनापूर्ण आधे की मेजबानी करने से रोकता है।

देख "sha1collisiondetectionमार्क स्टीवंस द्वारा "

---

फिर से, Q1 2018 Git 2.16 के साथ एक संरचना हैश एल्गोरिदम का प्रतिनिधित्व करते हुए, एक नए हैश में संक्रमण का कार्यान्वयन शुरू हो गया है।
जैसा कि ऊपर उल्लेख किया गया है, नया समर्थित हैश SHA-256 होगा ।

Comments

टकराव: 1. संयोग बनाने की कोशिश थी, संयोग से नहीं। 2. ते पीडीएफ रिपोर्ट से: कुल में खर्च किए गए कम्प्यूटेशनल प्रयास 2 ^ 63.1 SHA-1 कंप्रेशन के बराबर है और लगभग 6,500 CPU वर्ष और 100 GPU वर्ष लगे । 3. यद्यपि हमें MD5 से आगे बढ़ना चाहिए और SHA-1 फ़ाइल के अद्वितीय उपयोग के लिए सामान्य रूप से ठीक हैं।

— ज़फ

यह ध्यान देने योग्य है कि WebKit ने एक परीक्षण के लिए टकराए गए PDF में जाँच की। इसने उनके git-svn दर्पण बुनियादी ढांचे को तोड़ दिया: Bugs.webkit.org/show_bug.cgi?id=168774#c24

— dahlbyk

@dahlbyk यह वास्तव में ध्यान देने योग्य है ... इसमें मैंने इसे उत्तर में उल्लेख किया है ("इसके पीछे का लिंक git-svnहालांकि इसके लिए कुछ मुद्दा है ", इसका उल्लेख अप्रत्यक्ष रूप से करता है)

— VonC

@Mr_and_Mrs_D नहीं यह अभी तक एक त्रुटि के साथ विफल नहीं होता है। एक बड़ा पैच प्रगति पर है जो तब टकराव का पता लगाने में मदद करेगा: marc.info/?l=git&m=148987267504882&w=2

— VonC

@Mr_and_Mrs_D SEe 4 को stackoverflow.com/posts/42450327/revisions में संपादित करें : यह अब विफल हो जाता है, कम से कम जब GitHub तक बढ़ा दिया जाता है।

— वॉन मार्क

Answer 5

मुझे लगता है कि क्रिप्टोग्राफर जश्न मनाएंगे।

SHA-1 पर विकिपीडिया लेख का उद्धरण :

फरवरी 2005 में, Xiaoyun Wang, Yiqun Lisa Yin, और Hongbo Yu द्वारा हमले की घोषणा की गई। हमलों को SHA-1 के पूर्ण संस्करण में टकराव मिल सकता है, 2 ^ 69 से कम संचालन की आवश्यकता होती है। (एक क्रूर बल खोज के लिए 2 ^ 80 परिचालनों की आवश्यकता होगी।)

Comments

मुद्दा यह है कि SHA1 में एक दोष पाया गया है और यह उस समय के बारे में था जब गिट पेश किया जा रहा था। इसके अलावा, संभावना गैर-रैखिक है। सिर्फ इसलिए कि आप पचास साल के लिए लॉटरी खेलते हैं इसका मतलब यह नहीं है कि आपके पास जीतने की अधिक संभावना है। आपके पास हर बार एक ही मौका है। पहली बार खेलने वाला व्यक्ति अभी भी जीत सकता है।

— 0xC0000022L

यह केवल हमला है जो टकराव का पता लगाता है, जिसका अर्थ है कि आप yऐसे h(x) == एच (y) ` को ढूँढ सकते हैं जो एसएसएल प्रमाण पत्र जैसे डेटा के लिए गंभीर खतरा है, लेकिन इससे गिट प्रभावित नहीं होता है जो दूसरे पूर्व-छवि हमले के लिए असुरक्षित होगा, जिसका अर्थ है संदेश होने xआप संदेश के साथ संशोधित कर सकते हैं x'कि h(x) == h(x')। इसलिए यह हमला Git को कमजोर नहीं करता है। इसके अलावा Git ने सुरक्षा कारणों से SHA-1 को नहीं चुना है।

— होलेथ

अब एक टक्कर मिल गई है - सिर्फ एक ही नहीं जो सीधे तौर पर परेशान करती है। stackoverflow.com/questions/42433126/…

— विलेम हेंगवेल्ड

2 ^ 69 लगभग 600 एक्सा-ऑपरेशन है। आठ साल बाद, एनवीडिया का सैटर्नवी सुपर कंप्यूटर जो उनके ए 100 के साथ अपग्रेड किया गया है, 4.6 एक्साओपीएस कर सकता है, इसलिए यह संभावित रूप से 2 मिनट में इसे हल कर सकता है, या कुछ दिनों में एक क्रूर बल हमला कर सकता है।

— शाम

Answer 6

SHA-1 जैसे हैश के लिए कई अलग-अलग हमले के मॉडल हैं, लेकिन आमतौर पर चर्चा की गई टक्कर खोज है, जिसमें मार्क स्टीवंस का हैशक्लैश टूल भी शामिल है।

"2012 तक, SHA-1 के खिलाफ सबसे कुशल हमले को मार्क स्टीवंस [34] ने $ 2.77M की अनुमानित लागत के साथ क्लाउड सर्वर से सीपीयू पावर को किराए पर लेने के लिए एक हैश मूल्य तोड़ने के लिए माना है।"

जैसा कि लोगों ने बताया, आप गिट के साथ एक हैश टकराव को मजबूर कर सकते हैं, लेकिन ऐसा करने से मौजूदा वस्तुओं को किसी अन्य भंडार में अधिलेखित नहीं किया जाएगा। मैं भी कल्पना करूँगाgit push -f --no-thin मौजूदा वस्तुओं को अधिलेखित नहीं किया जाएगा, लेकिन 100% निश्चित नहीं है।

उस ने कहा, यदि आप एक रिमोट रिपॉजिटरी में हैक करते हैं, तो आप अपनी झूठी वस्तु को वहां पुराना बना सकते हैं , संभवतः हैक किए गए कोड को जिथब या इसी तरह के ओपन सोर्स प्रोजेक्ट में एम्बेड कर सकते हैं। यदि आप सावधान थे, तो शायद आप एक हैक किया गया संस्करण पेश कर सकते हैं जिसे नए उपयोगकर्ताओं ने डाउनलोड किया है।

मुझे हालांकि इस बात पर संदेह है कि परियोजना के डेवलपर्स कई चीजें कर सकते हैं जो या तो आपके मल्टी-मिलियन डॉलर हैक को गलत तरीके से उजागर या नष्ट कर सकते हैं। विशेष रूप से, यदि किसी डेवलपर ने, जिसे आपने हैक नहीं किया है, तो नाली के नीचे बहुत पैसा है git push --no-thin, कभी-कभी बिना प्रभावित हुए फ़ाइलों को संशोधित करने के बाद भी, उपरोक्त फ़ाइलों को संशोधित --no-thinकरता है।