Git bir damla üzerinde SHA-1 çarpışmasını nasıl ele alır?

Bu muhtemelen gerçek dünyada hiç olmadı ve asla gerçekleşmeyebilir, ama şunu düşünelim: git deponuz var, bir taahhütte bulunun ve çok şanssız olun: Lekelerden biri aynı SHA-1'e sahip zaten deponuzda olan bir başkası olarak. Soru şudur: Git bunu nasıl hallederdi? Sadece başarısız mı? İki blob'u bağlamanın bir yolunu bulun ve bağlama göre hangisinin gerekli olduğunu kontrol edin?

Gerçek bir problemden daha çok zeka oyunu, ama konuyu ilginç buldum.

Git'in bu durumda tam olarak nasıl davranacağını öğrenmek için bir deney yaptım. Bu sürüm 2.7.9 ~ rc0 + next.20151210 (Debian sürümü) ile. Temelde sadece aşağıdaki diff uygulayarak ve yeniden git git karma boyutunu 160-bit 4-bit için azalttı:

--- 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);
 }

Sonra birkaç taahhütte bulundum ve aşağıdakileri fark ettim.

1. Aynı karmaya sahip bir damla zaten varsa, hiçbir uyarı almazsınız. Her şey yolunda gibi görünüyor, ama birisini klonladığınızda veya geri döndüğünüzde, en son sürümü kaybedeceksiniz (yukarıda açıklananlara uygun olarak).
2. Bir ağaç nesnesi zaten varsa ve aynı karma ile bir damla oluşturursanız: Siz itmeye çalışana veya birileri deponuzu klonlayana kadar her şey normal görünecektir. O zaman repo bozuk olduğunu göreceksiniz.
3. Bir taahhüt nesnesi zaten varsa ve aynı karma ile bir damla oluşturursanız: # 2 ile aynı - bozuk
4. Bir blob zaten varsa ve aynı karma ile bir taahhüt nesnesi yaparsanız, "ref" güncellenirken başarısız olur.
5. Bir damla zaten varsa ve aynı karma ile bir ağaç nesnesi yaparsanız. Taahhüt oluşturulurken başarısız olur.
6. Bir ağaç nesnesi zaten varsa ve aynı karmaya sahip bir taahhüt nesnesi yaparsanız, "ref" güncellenirken başarısız olur.
7. Bir ağaç nesnesi zaten varsa ve aynı karmaya sahip bir ağaç nesnesi yaparsanız, her şey yolunda görünecektir. Ancak taahhütte bulunduğunuzda, tüm havuz yanlış ağaca atıfta bulunacaktır.
8. Bir taahhüt nesnesi zaten varsa ve aynı karma ile bir taahhüt nesnesi yaparsanız, her şey yolunda görünecektir. Ancak taahhütte bulunduğunuzda, taahhüt asla oluşturulmayacak ve HEAD işaretçisi eski bir taahhüde taşınacaktır.
9. Bir tamamlama nesnesi zaten varsa ve aynı hash değerine sahip bir ağaç nesnesi oluşturursanız, tamamlama oluşturulurken başarısız olur.

# 2 için "git push" komutunu çalıştırdığınızda genellikle böyle bir hata alırsınız:

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

veya:

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

dosyayı silip "git checkout file.txt" dosyasını çalıştırırsanız.

# 4 ve # 6 için, genellikle böyle bir hata alırsınız:

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

çalıştırırken. Bu durumda, yeni bir karma oluşturacağından (değişen zaman damgası nedeniyle) genellikle "git commit" yazabilirsiniz.

# 5 ve # 9 için genellikle böyle bir hata alırsınız:

fatal: 1000000000000000000000000000000000000000 is not a valid 'tree' object

"git commit" çalıştırırken

Birisi bozuk deponuzu klonlamaya çalışırsa, genellikle şöyle bir şey görür:

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'

Beni "endişelendiren", iki durumda (2,3) havuzun herhangi bir uyarı yapılmadan bozulmasına neden olması ve 3 durumda (1,7,8) her şeyin yolunda görünmesi, ancak depo içeriğinin beklediğinizden farklı olmasıdır. olmak. Klonlayan veya çeken kişiler, sahip olduğunuzdan farklı bir içeriğe sahip olacaktır. 4,5,6 ve 9 vakaları iyi, çünkü bir hata ile duracak. En azından her durumda bir hata ile başarısız olsaydı daha iyi olacağını düşünüyorum.

Orijinal cevap (2012) (aşağıdaki shattered.io2017 SHA1 çarpışmasına bakın)

Linus'un bu eski (2006) cevabı hala alakalı olabilir:

Hayır! Aynı SHA1 varsa, diğer ucundan nesneyi aldığınızda, biz anlamına gelir değil zaten elimizde nesneyi üzerine.

Öyleyse, bir çarpışma görürsek, herhangi bir depodaki "önceki" nesne her zaman geçersiz kılınır. Ancak git nesnesi ağının tam olarak sipariş edilmemiş bir DAG ürettiği anlamında "daha erken" veri havuzunun açık bir şekilde depolandığına dikkat edin, bu nedenle farklı depolar doğrudan soy varsa, nesne ayrı ayrı geldi ve doğrudan ilişkili olmayan dallar, iki farklı depo açık bir şekilde iki nesne farklı sırayla almış olabilir.

Ancak, "daha önce geçersiz kılar" güvenlik açısından istediğiniz şeydir: git modelinin öncelikle yalnızca kendi havuzunuza güvenmeniz gerektiğidir .
Dolayısıyla, bir " git pull" yaparsanız , yeni gelen nesneler tanım gereği zaten sahip olduğunuz nesnelerden daha az güvenilirdir ve bu nedenle yeni bir nesnenin eskisinin yerini almasına izin vermek yanlış olur.

Yani iki çarpışma vakanız var:

• bir şekilde çok çok şanssız olduğunuz istenmeyen tür ve iki dosya aynı SHA1'e sahip.
  Bu noktada, bu dosyayı taahhüt ettiğinizde (veya git-update-indexdizine taşımak için bir " " yaptığınızda, ancak henüz kaydedilmediğinde), yeni içeriğin SHA1'i hesaplanacak, ancak eski bir nesneyle eşleştiği için, yeni bir nesne oluşturulmaz ve kesinleştirme veya dizin eski nesneyi gösterir .
  Hemen fark etmeyeceksiniz (endeks eski SHA1 nesnesiyle eşleşeceğinden ve bu " git diff" gibi bir şeyin kullanıma alınmış kopyayı kullanacağı anlamına gelir ), ancak ağaç düzeyinde bir fark (veya bir klon yaparsanız) veya çek veya çekmeye zorla) aniden o dosyanın bir şeye dönüştüğünü fark edersinizbeklediğinizden tamamen farklı.
  Yani genellikle bu tür bir çarpışmayı oldukça hızlı fark edersiniz.
  İlgili haberlerde, soru yanlışlıkla çarpışma hakkında ne yapılması gerektiğidir ..
  Öncelikle, insanlara yanlışlıkla çarpışma türünün gerçekten çok olası olmadığını hatırlatmama izin verin , bu yüzden bunu asla tam tarihte görmeyeceğiz evrenin.
  Ama eğer o olur, bu dünyanın sonu değil: büyük olasılıkla sadece hafifçe çarpıştı dosyayı değiştirmek ve sadece yeni değiştirilen içeriği ile işlemek zorlamak yapmanız gereken yapardım (a comment "diyerek eklemek /* This line added to avoid collision */") ve sonra git'e tehlikeli olduğu gösterilen sihirli SHA1'i öğretin.
  Yani birkaç milyon yıl içinde, belki git'e bir veya iki "zehirli" SHA1 değeri eklememiz gerekecek. Bir bakım problemi olması pek olası değildir;)

• Çarpışma saldırganın tür birileri (veya hayvanla-zorla) SHA1 kırdı çünkü.
  Bu , yanlışlıkla türden çok daha muhtemeldir, ancak tanım gereği her zaman "uzak" bir havuzdur. Saldırganın yerel veri havuzuna erişimi olsaydı, seni mahvetmek için çok daha kolay yolları olurdu.
  Yani bu durumda, çarpışma tamamen olmayan bir konudur Eğer saldırganın istediği her şeyi farklı bir "kötü" depo alırsınız ama: aslında onun çarpışan nesneyi kullanmak asla beri, bu kadar anlamıyla farksızdır Saldırgan sadece bir çarpışma bulamadıancak yalnızca önceden sahip olduğunuz nesneyi kullanarak (yani, aynı SHA1'i oluşturan özdeş dosyanın "önemsiz" çarpışmasına% 100 eşdeğerdir).

SHA-256 kullanarak sorunu düzenli sözü, ama şimdi (2012) için üzerine hareket değildir.
Not: 2018 ve Git 2.19'dan başlayarak kod SHA-256 kullanmak için yeniden düzenleniyor.

Not (Mizah): Bir belirli bir SHA1 taahhüt zorlayabilir öneki projesi ile, gitbrute dan (Brad Fitzpatrick bradfitz) .

gitbrute brute, bir çift yazar + geçiş zaman damgasını zorlar, böylece ortaya çıkan git kesinliği istediğiniz öneklere sahip olur.

Örnek: https://github.com/bradfitz/deadbeef

Daniel Dinnyes işaret yorumlarda için 7.1 Git Araçları - Revizyon Seçimi içerir:

Programlama ekibinizin her üyesinin, aynı gece ilgisiz olaylarda kurtlar tarafından saldırıya uğrama ve öldürülme olasılığı daha yüksektir.

Daha yakın zamanda (Şubat 2017) bile shattered.iobir SHA1 çarpışması oluşturma olasılığını gösterdi:
( Linus Torvalds'ın Google+ yayını da dahil olmak üzere ayrı cevabımda daha fazlasını görün )

• a / hala 9,223,372,036,854,775,808 SHA1 hesaplamaları gerektirir. Bu, eşdeğer işlem gücünü 6.500 yıllık tek CPU hesaplamaları ve 110 yıllık tek GPU hesaplamaları olarak aldı.
• b / bir dosyayı taklit eder (aynı SHA1 ile), ancak ek kısıtlamayla içeriği ve boyutu aynı SHA1'i üretecektir (yalnızca içerik üzerinde bir çarpışma yeterli değildir): bkz. " Git karması nasıl hesaplanır? ") : bir damla SHA1 içeriğe ve boyuta göre hesaplanır .

Daha fazla bilgi için Valerie Anita Aurora'nın " Şifreleme karma işlevlerinin yaşamları " konusuna bakın . Bu sayfada şunları not eder:

Google, güvenlik açısından kritik uygulamalar için SHA-1'i kullanmayı bırakmamız gereken herkesi ikna etmek için 6500 CPU yılı ve 110 GPU yılı harcadı.
Ayrıca havalı olduğu için

Aşağıdaki ayrı cevabımda daha fazlasını görün .

Pro Git'e göre :

Deponuzda önceki bir nesneyle aynı SHA-1 değerine sahip bir nesneyi yürütürseniz, Git zaten Git veritabanınızda bulunan önceki nesneyi görür ve zaten yazılmış olduğunu varsayar. Bir noktada o nesneyi tekrar kontrol etmeye çalışırsanız, her zaman ilk nesnenin verilerini alırsınız.

Bu yüzden başarısız olmaz, ancak yeni nesnenizi de kaydetmez.
Bunun komut satırında nasıl görüneceğini bilmiyorum, ama bu kesinlikle kafa karıştırıcı olurdu.

Biraz daha aşağıda, aynı referans böyle bir çarpışmanın olasılığını göstermeye çalışır:

İşte size bir SHA-1 çarpışması için ne yapılması gerektiğine dair bir fikir vermek için bir örnek. Dünyadaki 6,5 milyar insanın tümü programlıysa ve her saniye, her biri tüm Linux çekirdek geçmişinin (1 milyon Git nesnesi) eşdeğeri olan bir kod üretiyordu ve onu muazzam bir Git deposuna itiyordu, 5 yıl sürecekti havuzun tek bir SHA-1 nesne çarpışması olasılığının% 50'sine sahip olmak için yeterli nesne içermesi. Programlama ekibinizin her üyesinin, aynı gece ilgisiz olaylarda kurtlar tarafından saldırıya uğrama ve öldürülme olasılığı daha yüksektir.

2012'den önceki cevabımı eklemek için şimdi (Şubat 2017, beş yıl sonra), shattered.io ile gerçek SHA-1 çarpışmasının bir örneği var , burada iki çarpışan PDF dosyası oluşturabilirsiniz: bu bir SHA- elde etmek Birinci PDF dosyasında, ikinci PDF dosyasında geçerli bir imza olarak da kullanılabilen 1 dijital imza.
Ayrıca bkz. " Yıllarca ölümün kapısında, yaygın olarak kullanılan SHA1 işlevi artık öldü " ve bu resme bakın .

26 Şubat Güncellemesi: Linus bir Google+ yayınında aşağıdaki noktaları doğruladı :

(1) Öncelikle - gökyüzü düşmüyor. Güvenlik imzalama gibi şeyler için kriptografik bir karma kullanma ve git gibi içeriğe yönelik adreslenebilir bir sistem için "içerik tanımlayıcı" oluşturmak için bir tane kullanma arasında büyük bir fark vardır.

İkincisi, bu özel SHA1 saldırısının doğası, hafifletilmesinin aslında oldukça kolay olduğu ve bu hafifletme için zaten iki grup yaması olduğu anlamına gelir.

Ve son olarak, dünyayı - hatta eski git depolarını bile bozmayacak olan başka bir hash'a makul ölçüde basit bir geçiş var.

Bu geçişle ilgili olarak, karma algoritmayı temsil eden bir yapı ekleyerek Q1 2018 Git 2.16'ya bakın . Bu geçişin uygulanmasına başlandı.

Git 2.19'dan (3. Çeyrek 2018) başlayarak , Git SHA-256'yı NewHash olarak seçti ve onu koda entegre etme sürecinde (yani SHA1 hala varsayılan (Q2 2019, Git 2.21), ancak SHA2 halefi olacak)

Orijinal cevap (25 Şubat) Ancak:

• Bu bir damla oluşturmaya izin verir, ancak ağacın SHA-1'i yine de dövme olacaktır, çünkü sahte damla boyutu orijinal olanla aynı olmayabilir: bkz. " Git karma nasıl hesaplanır? "; bir damla SHA1 içeriğe ve boyuta göre hesaplanır .
  Bu var bazı sorunu git-svnolsa . Ya da daha ziyade burada görüldüğü gibi svn'nin kendisiyle .
• Orijinal cevabımda belirttiğim gibi, böyle bir girişimin maliyeti şimdilik şimdilik yasaklayıcı (6.500 CPU yılı ve 100 GPU yılı) " Kriptografik karma fonksiyonlarının yaşamları " nda ayrıca Valerie Anita Aurora'ya bakın .
• Daha önce yorumlandığı gibi, bu güvenlik veya güven ile ilgili değildir , ancak bugün Linus Torvalds tarafından belirtildiğigit fsck gibi a tarafından kolayca tespit edilebilen veri bütünlüğü (çoğaltma ve hata tespiti) . (her zaman hileli bir dosyada bulunmasa da) bir opak veri içeren bir kesinleştirme mesajı hakkında uyarır . Herkes açılmaz, ancak GitHub yapar: hatalı biçimlendirilmiş bir nesne veya kopuk bir bağlantı durumunda herhangi bir push iptal edilir. Yine de ... bunun varsayılan olarak etkinleştirilmemesinin bir nedeni vardır .git fsckNULNUL
transfer.fsck
• bir pdf dosyası, sahte kaynak kodu yerine çakışan bir SHA-1 oluşturmak için değiştirebileceğiniz rastgele ikili verilere sahip olabilir.
  Aynı baş işleme karma ve farklı içeriklere sahip iki Git havuzu oluşturmadaki asıl sorun. Ve o zaman bile, saldırı kıvrık kalır .
• Linus ekler :

  Bütün noktası bir SCM bir kerelik olay hakkında değil, sürekli geçmişi hakkında olmasıdır. Bu da temel olarak başarılı bir saldırının zaman içinde çalışması gerektiği ve tespit edilememesi gerektiği anlamına gelir.
  Bir kez bir SCM'yi kandırabilir, kodunuzu girebilir ve önümüzdeki hafta algılanırsa, aslında yararlı bir şey yapmadınız. Sadece kendini yaktın.

Joey Hess bu pdf'yi Git deposunda deniyor ve şunları buldu :

Bu, git'in üstbilgiyi içeriğe hazırlama biçimi sayesinde farklı BLB'leri alan aynı SHA ve boyutta iki dosya içerir.

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

Bu çarpışan dosyalara aynı verilerin eklenmesi başka çakışmalar oluştururken, bekleyen veriler oluşturmaz.

Yani saldırının ana vektörü (bir taahhütte bulunmak) :

• Düzenli bir taahhüt nesnesi oluşturun;
• seçilen önek olarak tüm taahhüt nesnesini + NUL kullanın ve
• çarpışan iyi / kötü nesneleri oluşturmak için aynı önek çarpışma saldırısını kullanın.
• ... ve bu işe yaramaz çünkü iyi ve kötü taahhüt nesneleri hala aynı ağaca işaret ediyor!

Ayrıca, her dosyada bulunan SHA-1'e karşı kriptanaltik çarpışma saldırılarını zaten tespit edebilir ve cr-marcstevens/sha1collisiondetection

Git'in içine benzer bir çek eklemenin bir miktar hesaplama maliyeti olacaktır .

Değişen karma hakkında, Linux yorumlar :

Karma boyutu ve karma algoritma seçimi bağımsız konulardır.
İçten ve yerli git veritabanında ve sonra varsayılan olarak yalnızca 256-bit hash, kullanım geçiş Ne yapmak muhtemelen ediyorum olduğunu göstermek (40 karakter uzunluğunda onaltı dizesi olarak karma tür zaten şeyler kısaltmak nasıl gibi birçok durum).
Bu şekilde git etrafındaki araçlar, bazı özel " --full-hash" argümanlarda (veya " --abbrev=64" ya da her neyse - 40 olarak kısaltılmış olduğumuz varsayılan) geçmedikçe değişikliği bile görmezler .

Yine de, bir geçiş planı (SHA1'den başka bir hash fonksiyonuna) hala karmaşıktır , ancak aktif olarak incelenir.
Bir convert-to-object_idkampanya olduğunu sürüyor :

20 Mart Güncellemesi: GitHub olası bir saldırıyı ve korunmasını detaylandırıyor :

SHA-1 isimlerine çeşitli mekanizmalar yoluyla güven atanabilir. Örneğin Git, bir taahhüt veya etiketi şifreleme yoluyla imzalamanıza olanak tanır. Bunu yapmak, yalnızca gerçek dosya verilerini içeren diğer nesnelere SHA-1 adlarını kullanarak işaret eden commit veya tag nesnesinin kendisini imzalar. Bu nesnelerdeki bir çarpışma, geçerli görünen ancak imzalayanın amaçladığından farklı verilere işaret eden bir imza oluşturabilir. Böyle bir saldırıda imzalayan kişi çarpışmanın sadece yarısını görür ve kurban diğer yarısını görür.

Koruma:

Son saldırı, SHA-1 algoritmasındaki çok daha kısa sürede bir çarpışma bulan zayıflıklardan yararlanmak için özel teknikler kullanıyor. Bu teknikler, bir çarpışan çiftin her iki yarısının SHA-1'i hesaplanırken saptanabilen baytlarda bir desen bırakır.

GitHub.com şimdi hesapladığı her SHA-1 için bu algılamayı gerçekleştirir ve nesnenin bir çarpışan çiftin yarısı olduğuna dair kanıt varsa işlemi iptal eder. Bu, saldırganların bir projeyi çarpışmalarının "masum" yarısını kabul etmeye ikna etmek ve aynı zamanda kötü niyetli yarıyı barındırmasını önlemek için GitHub'ı kullanmasını engeller.

Marc Stevenssha1collisiondetection tarafından " "

Yine, Q1 2018 Git 2.16 hash algoritmasını temsil eden bir yapı ekleyerek yeni bir hash'a geçişin uygulanmasına başlandı.
Yukarıda belirtildiği gibi, yeni desteklenen Hash SHA-256 olacaktır .

Bence kriptograflar kutlama yapardı.

SHA-1 hakkındaki Wikipedia makalesinden alıntı :

Şubat 2005'te Xiaoyun Wang, Yiqun Lisa Yin ve Hongbo Yu'nun saldırısı açıklandı. Saldırılar SHA-1'in tam sürümünde 2 ^ 69'dan daha az işlem gerektiren çarpışmalar bulabilir. (Kaba kuvvetli bir arama için 2 ^ 80 işlem gerekir.)

SHA-1 gibi karmalar için birkaç farklı saldırı modeli vardır, ancak genellikle tartışılan, Marc Stevens'ın HashClash aracı dahil olmak üzere çarpışma araştırmasıdır .

"2012 itibariyle, SHA-1'e karşı en etkili saldırı, Marc Stevens [34] tarafından bulut sunucularından CPU gücü kiralayarak tek bir karma değeri kırmak için tahmini maliyeti 2,77 milyon dolar olan bir saldırı olarak kabul ediliyor."

İnsanların işaret ettiği gibi, git ile karma bir çarpışmayı zorlayabilirsiniz, ancak bunu yapmak başka bir havuzdaki mevcut nesnelerin üzerine yazmaz. git push -f --no-thinMevcut nesnelerin üzerine bile yazılmayacağını düşünürdüm , ama% 100 emin değilim.

Bununla birlikte, uzak bir depoya hack ederseniz, sahte nesnenizi orada daha eski olanı yapabilir , muhtemelen hack kodunu github veya benzeri bir açık kaynak projesine gömebilirsiniz. Eğer dikkatli olsaydınız, belki de yeni kullanıcıların indirdiği saldırıya uğramış bir versiyonu tanıtabilirsiniz.

Ancak, projenin geliştiricilerinin yapabileceği birçok şeyin milyonlarca dolarlık hackinizi ortaya çıkarabileceğini veya yanlışlıkla yok edebileceğinden şüpheleniyorum. Özellikle, hacklemediğiniz bazı geliştiriciler, git push --no-thinetkilenen dosyaları değiştirdikten sonra, bazen --no-thinbağlı olmadan bile , daha önce çalıştırırsa, bu çok fazla para demektir .