
Turkish: 
SHA güvenli karma algoritma anlamına gelir. Sadece biraz kırıldığı göz önüne alındığında ilginç olan
Ama bugün özellikle SHA'ya yapılan saldırı hakkında konuşmayacağım
bu farklı bir video için
Yapmak istediğim, karma fonksiyonları ve ne oldukları hakkında biraz daha ayrıntılı konuşmaktı.
Ve özellikle SHA'nın nasıl çalıştığı, bu gibi şeylerin nasıl uygulandığına dair bir fikir edinebilirsiniz.
Tom'un bu videoda birisini ele geçirmesini sağladığından, kısa bir süre için bir fonksiyonun ne olduğuna kısa bir bakalım.
Bir karma işlevi kullanmanızın birçok nedeni var. Karma fonksiyonların türü
Bahsettiğim konu hakkında konuşmuyorum
Parolaları karma Bu olanlar bir anlamda oldukça yavaş olmalılar çünkü güvende olmalarına ihtiyacın var.
Mesaj şifreleme gibi şeyler için çoğunlukla kriptografide rutin olarak kullanılan hash fonksiyonları hakkında konuşacağız.
Dijital imzalar vb. Bu yüzden hem doğrulamak hem de hesaplamak için oldukça hızlı olmaları gerekir. Bir karma işlevi

English: 
SHA stands for the secure hash algorithm. Which is interesting given that it has just kind of been broken
But I'm not going to talk specifically about the attack on SHA today
that's for a different video, but
What I wanted to do was talk in a little bit more detail about hash functions and what they are
And how SHA in particular works so you can get an idea of a kind of way these things are implemented
let's have a quick look at what a hash function is briefly because Tom's got somebody covered it in this video and
He's gone into a lot of the reasons you might use a hash function. The kind of hash functions
I'm talking about are not the ones that we've been talking about for
Hashing passwords. Those ones have to be quite slow in some sense because you need them to be secure
We're going to talk mostly about the hash functions that are used routinely in cryptography for things like message authentication
Digital signatures, and so on. So they need to be fairly quick, both to verify and compute. A hash function

English: 
Take some string, right, let's say "abc" and it turns it into some fixed length string
(that's not usually three long) of random
So we know a bit string right, but so so you, 011001011...
Go forward this way for however many bits that hash function is. Now, there's a few important properties of Hash functions
That we care about for cryptography, but the most important one perhaps. Is that it's essentially pseudo-random
So that means that we put in "abc"
And we get out something that is in no way like "abc" and appears completely random to us and if we change this even slightly
Because it's appearing random this has completely changed
So let's have a quick look at SHA-1 as an example just so we can see this in action
I'm on some page that has a script that calculates hashes on the fly so I can put in "abc" and
You can see that the hash is a9993e and so on all the way up to d, right?
This is the SHA1 hash. A SHA1 hash is 160 bits long. If I change this

Turkish: 
Bazı dize al, tamam, diyelim ki "abc" diyelim ve onu sabit uzunlukta bir dizgeye çevirir.
(bu genellikle üç uzun değildir) rastgele
Bu yüzden doğru bir dize biliyoruz, ama siz, 011001011 ...
Bu şekilde, hash fonksiyonu olan birçok bit için ilerleyin. Şimdi, Hash fonksiyonlarının birkaç önemli özelliği var.
Kriptografiyi önemsiyoruz, ama belki de en önemlisi. Bu aslında sözde rastgele mi
Yani bu "abc" ye girdiğimiz anlamına geliyor
Ve hiçbir şekilde "abc" gibi olmayan ve bizim için tamamen rastgele görünen bir şey çıkardık ve eğer bunu birazcık değiştirirsek
Rastgele göründüğü için bu tamamen değişti
Öyleyse SHA-1'e bir örnek olarak hızlıca bir göz atalım, bu sayede eylemde görebilirsiniz
Ben "abc" koymak ve böylece anında sinemada karma hesaplar bir komut dosyası vardır bazı sayfalarda
Haşının bir a9993e olduğunu görebilirsiniz, d yolunda.
Bu SHA1 hash. Bir SHA1 karması 160 bit uzunluğundadır. Bunu değiştirirsem

Turkish: 
A'dan D'ye karma tamamen değiştirildi. Yani rastgelelik görünümü var - bu fikir
Bu karma aslında bununla hiç alakalı değil
Olsa ve biz biliyoruz, çünkü tekrar C koyarsam
Bir9993'e geri döndük.
Böylece, mesajların değişmediğini doğrulamak veya sertifikalardaki imzaları doğrulamak için kullanabiliriz.
Ve rastgelelik görünümüne sahip olduğumuzu bilerek yapabiliriz, ama aslında hiç rastgele değil. Bugün
Bunu yapmak için aslında nasıl bir karma işlevi yazdığınız hakkında biraz konuşacağız.
Çok bilinen bir yapıyla esasen rastgele olmayan bir şeyi nasıl alırız ve saçma gibi görünen bir şeye nasıl dönüştürürüz?
Öyle kullanabiliriz ki. Şimdi,
Birkaç kaşını yükselten insanlar olacak.
Bunu yapmak için SHA1 kullanıyorum
Ama aslında bunu yapmak için oldukça makul bir sebep var.
İlk önce bildiğiniz bazı noktalardaki zayıflıklar hakkında da konuşabiliriz.
fakat aynı zamanda SHA-1, yapı olarak tarihsel olarak çok kullanımda görülen MD4 ve MD5’e çarpıcı bir benzerlik göstermektedir.
Bir SHA2 olan SHA-256 ve SHA-512

English: 
C to a D the hash is completely changed. So there's the appearance of randomness - the idea that
This hash is actually not related to this at all
Even though it is and we know it is because if I put C back again
We're back to a9993
So we can use this to verify messages haven't been changed or verify signatures on certificates
And we can do it knowing that we have the appearance of randomness , but actually it's not random at all. Today
We're going to talk a bit about how you actually write a hash function to do this
How do we take something that essentially isn't random with a very known structure and turn it into something that looks like nonsense
Such that we can use it. Now,
There'll be people raising a few eyebrows that
I'm using SHA1 as an example to do this
But actually there's fairly reasonable reason to do so.
First of all you know we might also talk about the weaknesses at some point
but also SHA-1 bears a striking similarity in structure to MD4 and MD5 which is see a lot of use historically and
SHA-256 and SHA-512 which is a SHA2

Turkish: 
Şu anda bir anlamda herkesin doğru SHA3 kullandığı bir standart olan oldukça farklı
Ve bu başka bir gün için başka bir şey
Yani SHA1 NSA tarafından geliştirilmiştir
Ve 1995’te yayımlanan ve yayınlanan birçok insan, NSA’nın varsayılan olarak yaptığı şeylere güvenmiyor
Bu adil olabilir, ancak bu durumda aslında SHA1 uzun bir süre oldukça iyiydi
bazı kaygılar varken ... son zamanlarda çok daha ciddi kaygılar, ama
Aslında NSA arka kapı olarak yapmıyordu ve NSA'nın şifrelemeye ihtiyacı vardı
Tıpkı herkes gibi ve bu da iyi bir fonksiyon
MD5'in birçok sorunu vardı ve temelde yaptıkları onu genişletip daha iyi hale getirmekti.
SHA1 herhangi bir uzunluktaki dizgiyi alır ve
160 bitlik değer. Tamam, yani bu
160 sıfır ve olanlar. O zaman soru şu hale gelir: Bir dizgem var ama "abc" olabilir veya inanılmaz derecede uzun bir dosya olabilir veya
Filmin tamamını doğru biliyorsunuz ve bunun 160 bitlik imzasını hesaplamak istiyorum.
O kadar iyi yapmaya nasıl başlayabilirim ki cevabı temelde bir döngü var

English: 
Which currently is in some sense a standard that everyone uses right SHA3 is quite different
And that's is something else for another day
So SHA1 was developed by the NSA
And released and published in 1995 now a lot of people don't trust things that the NSA do sort of by default
Which might be fair, but in this case actually SHA1 was quite good for a long long time
when there were some concerns ... recently much more serious concerns, but
Originally the NSA weren't doing it as a back door and stuff the NSA need cryptography
Just like everyone else and this is a good function
MD5 had a lot of problems and so what they basically did was extend it and make it better
SHA1 takes any length of string and outputs a
160 bit value. Alright, so that's
160 zeros and ones. The question then becomes: I've got a string but could be "abc" or it could be an incredibly long file or
You know a whole movie right, and I want to calculate 160-bit signature of that
How do I even get started doing that well the answer is that I basically have a loop that takes

English: 
512 bit blocks of data one at a time until the file's expended. Let's look at an example of how SHA1 works on just
a single message of exactly the right length
And then we'll just talk briefly about what you do when inevitably isn't the right length
Which is almost always, right? So SHA1 takes a message of n blocks of 512 bits in length, and
If it's only one block - if the message is exactly 512 bits in length, then we only run it once, in essence
And then we out put the hash at the end so SHA-1
Starts with an internal state then we bring in bits of our message one at a time
And we change that internal state and after we've done that at the very end when there's no more message left
We just read what the internal state is and that's our hash alright
so we're going to basically be taking the internal state and updating it with the message until
We run out of message, and then as soon as that process stops we can read the results
That's how the SHA family of hash functions works, so our internal state we call H so I'm going to say H0

Turkish: 
512 bit veri bloğu, dosya bitene kadar birer birer aynıdır. SHA1'in nasıl çalıştığına dair bir örneğe bakalım
tam doğru uzunlukta tek bir mesaj
Ve sonra kaçınılmaz olarak doğru uzunluk olmadığında ne yaptığınız hakkında kısaca konuşacağız.
Neredeyse her zaman hangisidir? Böylece SHA1, 512 bit uzunluğunda n bloklardan oluşan bir mesaj alır.
Eğer sadece bir blok ise - mesaj tam olarak 512 bit uzunluğundaysa, özünde sadece bir kere çalıştırırız.
Ve sonra sonunda hash'ı sona erdirdik, böylece SHA-1
Dahili bir durumla başlar, sonra mesajımızın bir kısmını birer birer getiririz
Ve bu içsel durumu değiştiririz ve daha sonra hiçbir mesaj kalmadığında bunu en sonunda yaptıktan sonra
Sadece iç durumun ne olduğunu okuduk ve bu bizim karma yolumuz
bu yüzden temelde içsel durumu alıp şu ana kadar mesajla güncelleyeceğiz.
Mesajımız tükenir ve bu işlem biter bitmez sonuçları okuyabiliriz
SHA hash fonksiyonlarının ailesi böyle işler, bu yüzden H olarak adlandırdığımız iç durumumuz H0 diyeceğim.

English: 
H1 H2 H3
and H4
Now the internal state of SHA1 is exactly the same length as the hash that it produces. Which is 160 bits. Which is five
32-bit words four bytes each you know for 32-bit machine this would be an int
So this is initialized based on some constants. Which is defined in the standard
We might talk about that in a bit
but it's not very important and what we're going to do is we're update these h's as
We bring in our message and then at the end. We'll see what the Hs are and that's our hash function
So how do we do this? Well? We have something [called] a compression function?
It's going to take in this data and a bit of message
Turn it into another set of h values and that's going to repeat as we have message
But that's only going to happen once this time because my message is exactly 5 12, which is very handy
So this is our compression function
And I'm going to rename these slightly just to confuse everyone to ABc dearly so at the beginning of our compression function

Turkish: 
H1 H2 H3
ve H4
Şimdi SHA1'in iç durumu, ürettiği karma ile tam olarak aynı uzunluktadır. Bu 160 bit. Hangisi beş
32-bit kelimeler her biri 32-bit makine için bildiğiniz dört bayt, bu bir int olur
Yani bu, bazı sabitlere göre başlatılır. Standartta tanımlanmış olan
Bunun hakkında biraz konuşabiliriz
ama bu çok önemli değil ve yapacağımız şey şu gibi güncellediğimiz:
Mesajımızı getirdik ve sonunda. Hs'nin ne olduğunu göreceğiz ve bu bizim karma fonksiyonumuz
Peki bunu nasıl yapacağız? İyi? Sıkıştırma işlevi diye adlandırdığımız bir şey mi var?
Bu veriyi ve mesajını alacak.
Bunu başka bir h değerine çevirin; mesajımız olduğu gibi tekrar edecek.
Ama bu sefer sadece bir kez olacak, çünkü mesajım tam olarak 5 12, ki bu çok kullanışlı.
Yani bu bizim sıkıştırma fonksiyonumuz
Sıkıştırma fonksiyonumuzun başlangıcında herkesin ABc ile kafasını karıştırmak için bunları biraz değiştireceğim.

Turkish: 
B'nin iç durumunu abcd ve e olarak kopyalarız.
Daha sonra 80 tur char sıkıştırma fonksiyonu yaparız, değil mi?
Bu da böyledir, yani x 80 şimdi yapacak olan şey şu sözlerden almaktır
Mesajımızın 512 bit bloğu, bu yüzden eğer buradaki mesaj bu mesaj ise
512 bit, bu noktada girecek ve şu an için bu ABc ve D ile çok iyi karışacak
Bu sıkıştırma işlevinde tam olarak ne olduğu hakkında konuşmayacağız
Fakat fikir şudur ki, abcde'nin parçaları bir araya getirilmiştir. Karıştırılıyorlar
Gittikçe ve aynı anda daha rastgele görünmesi için etrafına gidip geliyorlar.
Mandamusun görünümünü daha da artırmak için bu mesajdan bitler alıyoruz.
Ancak, bu duş fonksiyonunun sadece genel mesajdan ziyade, bu mesajdaki özeti hesapladığından emin olmak için
Bu mesaj için her seferinde aynı. Daima aynı algoritmayı yapacağız.
Bu mesajı ikinci kez eklersek, duş fonksiyonu tamamen aynı sonucu verir.

English: 
We copy B's the internal state into a b c d and e
We then perform 80 rounds of char compression function, right?
Which is like this so x 80 now what that's going to do is take in words from our
512 bit block of our message, so if this is our message here that message is
512 bits this is going to come in at this point and be mixed in with this ABc and D so well for now
We won't talk about exactly what's going on in this compression function
But the idea is that the bits of abcde are being combined together? They're being shuffled
They're being commuted around to make it look more and more random as we go and at the same time
We're bringing in bits from this message to further increase the appearance of mandamus
But also to make sure that this shower function is calculating a digest on this specific message rather than just a general one
That's the same every time for this message. We're always going to perform the exact same algorithm
So if we put in this message a second time the shower function will produce exactly the same result

English: 
Now once we've done this and we shuffled up abcde will be left with a new
Abcde so a b c d and e
And then we finish this block by bringing our h values down here and adding [them] to these values here
to create a new
H naught
H1 H2 H3
H4 the State is now been updated by whatever we did in this compression function by just adding to it all right now all addition
In Char is done without any overflow modulo 2 to the 32 well that means is that if you ever go over?
The maximum value allowed by a 4-byte integer you lap back around again
Right which is one of the reasons why shark arm in reverse because you might lose information that way
This is not encryption. We don't need to be able to reverse it, so this state is
Finished now if our message is exactly 512 bits

Turkish: 
Şimdi bir kez bunu yaptık ve karıştırdık abcde yeni bir şey bırakacak
Abcde çok abcd ve e
Ve sonra bu bloğu h değerlerimizi buraya getirerek ve bu değerlere [onları] ekleyerek bitiririz.
yeni bir tane oluşturmak için
H
H1 H2 H3
H4 Devlet şimdi bu eklenti işlevinde yaptığımız her şey tarafından, şu anda tüm eklentilere eklenerek güncellenmiştir.
Char'da herhangi bir taşma olmadan yapılırsa modulo 2'ye 32 kuyucuk yani demek oluyor ki?
4-byte tamsayı tarafından izin verilen maksimum değer
Köpekbalığı kolunun tersine dönmesinin nedenlerinden biri de doğru çünkü bu şekilde bilgi kaybedebilirsiniz
Bu şifreleme değil. Bunu tersine çevirmemize gerek yok, yani bu durum
İletimiz tam olarak 512 bit ise, şimdi bitti

English: 
We need these 18 or h1 h2 h3 h4 values out that is our hash, so for short messages. We're done
I could just you know go home
in actual fact the the principle of extending this to arbitrary length messages right in increments of
512 Bits is
We copy this state back up to the top and we repeat the process and then we copy back up and we repeat the process
For as many blocks as we have of our message 512 bits at a time of our message
We feed it in we alter the state using this approach here, and then we lead off a state when we're done, right?
That's basically how it works
So be the security of SHA is all in this compression function and what it's doing. If it's shorter than that, what
happens there?  If it's not a multiple of 512 bits. We're going to have to do some padding right?
Char only works with 512 bit blocks, so what we do is if we have our message. Which is let's say
1 0 1 1 0 1 it's not a very long message. If we want to pad that up to 512 bits

Turkish: 
Bu 18 veya h1 h2 h3 h4 değerlerine ihtiyacımız var, yani kısa mesajlar için. Yapılmıştı
Eve gidebilirsin biliyor musun?
gerçekte, bunu artımlı artışlarla isteğe bağlı uzunluktaki mesajlara genişletme ilkesi
512 Bit
Bu durumu en başa kopyalarız ve işlemi tekrar ederiz, sonra da tekrar kopyalarız ve işlemi tekrar ederiz.
Mesajımızdaki birçok blok için, mesajımızdaki bir anda 512 bit
Burada bu yaklaşımı kullanarak devleti değiştiririz ve sonra bittikten sonra bir devlete yol açarız, değil mi?
Temelde böyle çalışır
Öyleyse SHA'nın güvenliği bu sıkıştırma işlevinde ve ne yaptığıdır. Bundan daha kısa ise, ne
orada olur mu? 512 bitin bir katı değilse. Biraz dolgu yapmak zorunda kalacağız değil mi?
Char sadece 512 bitlik bloklarla çalışır, bu yüzden yaptığımız şey mesajımızın olması. Diyelim ki
1 0 1 1 0 1 çok uzun bir mesaj değil. Eğer bunu 512 bit'e kadar sıkıştırmak istiyorsak

Turkish: 
[A] ile başlayalım. 11 ile yatarız, bu yüzden bir çeşit işaretleyeceğim, buradaki dolguyu işaretleyeceğim
yani birlikte gideceğimizi biliyoruz
0000 ve sonra mesajdaki asıl mesajın uzunluğuyla mesajı bitiririz.
Öyleyse bu durumda 7 olan Binary 1 1 1 e 1 11 olan yastığı nasıl çıkaracağımızı biliyoruz.
Belli ki, uzunluğun için benden çok daha fazla bit olurdu. Şimdi bu dolgu şeması fikri olsun
Aynı uzunluktaki ve aynı şekilde veya çok benzer şekillerde biten mesajların aynı dolguyu paylaşmamasını sağlar
Ve bu çok önemli bir şey olmaktan vazgeçmeyin, bu yüzden bu yaklaşım tekrar tekrar SHA'ya yaklaşıyor.
İç durumun özünde bir sıkıştırma işlevi ile güncellenmesi, merkel down guard inşaatı olarak adlandırılır.
Bu, Murkland lanet olası tarafından bağımsız bir şekilde kanıtlandı. [Allah]
Fakat esasen bunun iyi yanı, eğer sıkıştırma fonksiyonunuz iyi ve pSeudo-random özelliklerinin iyi olması durumunda duş fonksiyonunuz da öyle.

English: 
We start with [a] one. We pad with 11 [alright], so I'm going to sort of mark, de-mark the padding here
so we know we go with
0000 and then we finish off the message with the length of the actual message in it
So we know where to sort of remove the padding which in this case is 7 so in Binary 1 1 1 so 1 11?
Obviously would a lot more bits for your length than I have done. You get the idea now this padding scheme
Ensures that messages of the same length and messages that end in the same way or in very similar ways don't share the same padding
And don't end up being the same that's very important, so this approach to SHA [its] repetitive
Updating of the internal state with a compression function in essence is called a merkel down guard construction
This was sort of independently proved by murkland damn. [God]
But essentially what's good about it is if your compression function is good and has good pSeudo-random properties then so does your shower function

Turkish: 
Hangisi elbette çok yararlıdır?
Sorun char char'in sıkıştırma fonksiyonunun saldırıların o kadar iyi olmamasıdır.
18 yaşına gelene kadar 60'a 2 ile 60'a düşürülebilirler.
Çok parası olan insanlar için imkanlar diyarına

English: 
Which is of course very useful right?
The problem is that the compression function of char one is not so good that the attacks are
To the 18 they can be reduced somewhat to about 2 to the 60 something like this which it becomes
Into the realm of possibility for people with a lot of money
