>> ROB BOWDEN: მე Rob და დე, cracking.
ასე რომ გახსოვთ pset სპეც რომ ჩვენ უნდა სჭირდება გამოყენება
სამარხი ფუნქცია.
კაცი გვერდზე, ჩვენ გვაქვს ორი hash განსაზღვრავს _xopensource.
არ ინერვიულოთ შესახებ, თუ რატომ ჩვენ უნდა გავაკეთოთ, რომ.
ასევე hash მოიცავს unistd.h.
>> ასე რომ, კიდევ ერთხელ, რომ იმ გზას, მოდით მიიღოს ფაქტობრივი პროგრამა.
პირველი, რაც ჩვენ უნდა გავაკეთოთ არის დავრწმუნდეთ, მომხმარებლის შევიდა ძალაში დაშიფრული
დაგავიწყდათ ბრძანებათა ზოლში.
გახსოვდეთ, რომ პროგრამა უნდა უნდა აწარმოებს, როგორიცაა dot ხაზი ბზარი და
მაშინ დაშიფრული სიმებიანი.
>> ასე რომ, აქ ჩვენ შემოწმების რომ დავრწმუნდეთ რომ argc ორი თუ გვინდა
გაგრძელება პროგრამა.
თუ argc არ არის ორი, ეს ნიშნავს, რომ არც შესახებ არ გამოჩენილა დაშიფრული
დაგავიწყდათ ზე ბრძანების, ან ისინი შევიდა მხოლოდ დაშიფრული
დაგავიწყდათ ზე ბრძანების, რომელშიც თუ ჩვენ არ ვიცით, რა უნდა გააკეთოს
ბრძანების ხაზი არგუმენტები.
>> ასე რომ, თუ argc იყო ორი, ჩვენ შევძლებთ.
აქ, ჩვენ ვაპირებთ, განაცხადოს ცვლადი დაშიფრული.
ეს მხოლოდ აპირებს alias ორიგინალური argv1 ისე, რომ მთელი ამ
პროგრამა, ჩვენ არ უნდა დავარქვათ argv1, რომელიც მაშინ უნდა ვიფიქროთ
იმაზე, თუ რა რომ რეალურად ნიშნავდა.
>> საბოლოოდ, ჩვენ გვინდა, რათა შეამოწმოს, რომ დაშიფრული დაგავიწყდათ შესახებ
შევიდა შეეძლო პრაქტიკულად დაშიფრული პაროლი.
პერ კაცი გვერდზე სამარხი, დაშიფრული პაროლი უნდა 13
სიმბოლო.
აქ, შეამჩნია, რომ ჩვენ hash განსაზღვრული დაშიფროთ სიგრძე როგორც 13.
ასე რომ, ჩვენ უბრალოდ რაც დარწმუნებული ვარ, რომ სიმებიანი ხანგრძლივობა დაშიფრული
პაროლი არის 13.
>> და თუ ეს ასე არ არის, ჩვენ გვინდა გასასვლელად პროგრამა.
ასე რომ, კიდევ ერთხელ, რომ იმ გზას, ჩვენ შეგვიძლია ახლა რეალურად ცდილობენ იპოვონ რა
დაგავიწყდათ, რომ მისცა დაშიფრული დაგავიწყდათ იყო.
აქ, ჩვენ გვინდა, რომ დაიბრუნოს მარილი საწყისი დაშიფრული პაროლი.
გახსოვდეთ, თითო კაცი გვერდზე, რომ პირველი ორი გმირები დაშიფრული
სიმებიანი, მინდა აქ -
50ZPJ და ა.შ. -
პირველი ორი გმირები მისცეს ჩვენს მარილი, რომელიც გამოიყენება
in სამარხი ფუნქცია.
>> აქ ჩვენ ვხედავთ, რომ მარილი იყო ჰა.
ასე რომ, ჩვენ გადააკოპირეთ პირველი ორი პერსონაჟი, მარილი სიგრძის მყოფი hash
განისაზღვრება, როგორც ორი.
ჩვენ გვყავს კოპირება პირველი ორი გმირები წინამდებარე მასივი, მარილი.
გავითვალისწინოთ, რომ ჩვენ გვჭირდება მარილი სიგრძის პლუს ერთი, რადგან ჩვენ ჯერ კიდევ null
terminator დასასრულს ჩვენი მარილი.
>> მაშინ ჩვენ ვაპირებთ ვაცხადებ მასივი, სტუმარს, საქართველოს ზომა მაქსიმალური სიგრძის პლუს
, სადაც მაქსიმალური სიგრძე hash განსაზღვრული როგორც რვა, რადგან მაქსიმალური დაგავიწყდათ
რვა სიმბოლო.
და ჩვენ ვაპირებთ გამოვიყენოთ ეს iterate ყველა შესაძლო strings, რომ შესაძლებელი იქნებოდა
ძალაშია პაროლები.
ასე რომ, თუ მოქმედი პერსონაჟი დაგავიწყდათ მხოლოდ, ბ და გ, მაშინ
გვინდა iterate მეტი, B, C, ა, ა, ა, და ასე შემდეგ, სანამ
ჩვენ ვერ ვხედავ cccccccc -
რვა გ ს.
>> და თუ ჩვენ არ გვაქვს ქვემოთ ძალაშია დაგავიწყდათ, მაშინ ჩვენ უნდა ვთქვათ, რომ
დაშიფრული სიმებიანი არ იყო ძალაში უნდა დაიწყოს.
ასე რომ, ახლა, ჩვენ მივაღწევთ, ხოლო 1 ციკლი.
გავითვალისწინოთ რომ იმას ნიშნავს რომ უსასრულო ციკლი.
>> გავითვალისწინოთ, რომ არ არსებობს შესვენების განაცხადი შიგნით ამ უსასრულო ციკლი.
არსებობს მხოლოდ დაბრუნების განცხადებებს.
ასე რომ, ჩვენ არასოდეს რეალურად ველოდოთ გასასვლელად ციკლი.
ჩვენ მხოლოდ ველით გასასვლელად პროგრამა.
მე დასძინა ამ ბეჭდვითი განცხადება დასაწყისი მარყუჟის მხოლოდ ამობეჭდოთ
რა არის ჩვენი დღევანდელი ვხვდები ზე რა პაროლი არის.
>> ახლა, რა არის ეს მარყუჟის აკეთებს?
ეს looping ყველა შესაძლო strings რომ შეიძლება იყოს მოქმედი პაროლები.
პირველი, რაც ჩვენ ვაპირებთ გავაკეთოთ არის ჩვენი დღევანდელი ვხვდები, თუ რა
პაროლი არის.
ჩვენ წავა მარილი, რომ ჩვენ მოგვეწონა დან დაშიფრული ტექსტი, და ჩვენ
მიმდინარეობს დაშიფვრა ვხვდები.
ეს მოგვცემს დაშიფრული ვხვდები, რაც ჩვენ ვაპირებთ შედარების წინააღმდეგ
დაშიფრული სტრიქონი შევიდა ბრძანებათა ზოლში.
>> თუ ისინი იმავე, ამ შემთხვევაში სიმებიანი შესადარებელი დაბრუნდება ნულოვანი, თუ
ისინი იგივე, მაშინ ვხვდები, იყო დაგავიწყდათ, რომ გენერირებული დაშიფრული
სიმებიანი, ამ შემთხვევაში ჩვენ შეგვიძლია ბეჭდვა რომ როგორც ჩვენი სახელით და სანაცვლოდ.
მაგრამ თუ ისინი არ არის იგივე, რაც ანუ ჩვენი ვხვდები არასწორია.
>> გვინდა iterate to შემდეგი მართებული ვხვდები.
ასე რომ, რა, ხოლო მარყუჟის ცდილობს გააკეთოს.
იგი აპირებს iterate ჩვენი ვხვდები მომდევნო მოქმედი ვხვდები.
გავითვალისწინოთ, რომ როდესაც ჩვენ ვამბობთ, რომ კერძოდ ხასიათი ჩვენს ვხვდები აქვს
მიღწეული მაქსიმალური სიმბოლო, რომელიც აქ არის hash განისაზღვრება, როგორც tilde, რადგან
ეს არის ის ყველაზე დიდი ASCII ღირებულება ხასიათი რომ მომხმარებელს შეუძლია enter-ს
კლავიატურა, როდესაც ხასიათი აღწევს მაქსიმალური სიმბოლო, მაშინ ჩვენ გვინდა გაგზავნას
უკან მინიმალური სიმბოლო, რომელიც არის სივრცე, კვლავ ყველაზე დაბალი ASCII
ღირებულება სიმბოლო იმისა, რომ მომხმარებელს შეუძლია enter-ს კლავიატურაზე.
>> ასე რომ, ჩვენ ვაპირებთ მითითებული, რომ მინიმალური სიმბოლო.
და მაშინ ჩვენ ვაპირებთ წავიდეთ მომდევნო ხასიათი.
ასე რომ, როგორ არის ჩვენი შთაბეჭდილებები აპირებს iterate?
ისე, თუ მოქმედი გმირები არიან, B, და გ, მაშინ თუ ჩვენ დავიწყეთ,
ეს თქვენ iterate to ბ, რომ თქვენ iterate რომ გ.
გ არის ჩვენი მაქსიმალური სიმბოლო, ასე რომ ჩვენ მითითებული გ დაბრუნდა, მინიმალური სიმბოლო.
და მაშინ ჩვენ iterate ინდექსი მომდევნო ხასიათი.
>> ასე რომ, თუ ორიგინალური ვხვდები იყო გ, მომდევნო ხასიათი იქნება null
terminator.
ქვემოთ აქ, შეამჩნია, რომ თუ ხასიათი რომ ჩვენ გვინდა
სიზუსტით იყო null terminator, მაშინ ჩვენ ვაპირებთ ვაყენებთ მას
მინიმალური სიმბოლო.
ასე რომ, თუ ვხვდები, იყო გ, მაშინ ჩვენი ახალი ვხვდები იქნება ა.
და თუ ჩვენი ორიგინალური ვხვდები იყო cccc, მაშინ ჩვენი ახალი ვხვდები
იქნება aaaaa.
>> ასე რომ, როცა კი მივაღწევთ მაქსიმალური სიმებიანი მოცემული სიგრძეზე, მაშინ ჩვენ
განახორციელებს მინიმუმამდე სიმებიანი მომდევნო სიგრძე, რომელიც
მხოლოდ ყველა გმირები მინიმალური სიმბოლო.
ახლა, რა არის ეს გამშვები აკეთებ აქ?
ისე, თუ მაჩვენებელი გადავიდა მერვე ხასიათის ცხრა ხასიათი -
ამიტომ ჩვენ დავამატებთ რვა გ, როგორც ჩვენი წინა ვხვდები -
მაშინ ინდექსი აპირებს ყურადღების გამახვილებას ბოლო null terminator ჩვენი ვხვდები
მასივი, რომელიც არ ნიშნავდა, რომ რეალურად იყოს გამოყენებული ჩვენი პაროლი.
>> ასე რომ, თუ ჩვენ მიმართულია, რომ გასულ null terminator, მაშინ ჩვენ ვერ
დაგავიწყდათ რომ მოქმედი გამოყენებით მხოლოდ რვა პერსონაჟი, რაც იმას ნიშნავს, რომ არ არსებობს
მართებული პაროლი, რომ encrypts მოცემულ სიმებიანი.
და ჩვენ გვაქვს ბეჭდვა, რომ ამბობდა ჩვენ ვერ შევძელით მოქმედი
პაროლი და სანაცვლოდ.
ასე რომ, ეს მაშინ, როცა მარყუჟის აპირებს iterate ყველა შესაძლო strings.
>> თუ იგი აღმოაჩენს რაიმე რომ encrypts to მოსალოდნელია დაშიფრული ტექსტი, ეს თქვენ
დაბრუნდნენ, რომ დაგავიწყდათ.
და ეს ის არ პოულობენ არაფრის, მაშინ იგი დაბრუნდება, ბეჭდვა, რომ ეს
ვერ შეძლო პოულობენ არაფრის.
ახლა შეამჩნია, რომ iterating ყველა შესაძლებელია strings ალბათ აპირებს
მიიღოს ხოლო.
მოდით რეალურად ვხედავ, როგორ ხანგრძლივი რომ იღებს.
>> გადავდგათ crack.
ისე, oops - ნათქვამია გაურკვეველი მინიშნება საძვალე.
ასე მახსოვს, რომ ჟ ადგენს სპეც და ასევე კაცის გვერდზე სამარხი, რომ ჩვენ
უნდა ბმულზე საძვალე.
ახლა, რო მიიღოს ბრძანება არ იცის, რომ თქვენ
მინდა, რომ ფუნქცია.
>> მოდით კოპირება ამ ორგანიზაციის ბრძანება და მხოლოდ დამატების შესახებ ბოლომდე
ეს, დამაკავშირებელი საძვალე.
ახლა კი ადგენს.
მოდით აწარმოებს crack მოცემულ დაშიფრული სიმებიანი -
ასე ცეზარის.
ასე რომ, ნამდვილად სწრაფად.
>> გავითვალისწინოთ, რომ ეს დასრულდა 13.
ასევე, კეისრის დაშიფრული დაგავიწყდათ ხდება, 13.
მოდით ახალი პაროლი.
ავიღოთ Hirschhorn ნახვა დაშიფრული სახელით და ვცდილობთ cracking, რომ.
>> ასე რომ შეამჩნია ჩვენ უკვე მიაღწია სამი სიმბოლო.
და ჩვენ iterating ყველა შესაძლო სამი ხასიათი strings.
ეს იმას ნიშნავს, რომ ჩვენ უკვე დასრულდება iterating ყველა შესაძლო ერთსა და
ორი ხასიათი strings.
ახლა, როგორც ჩანს, ამ აპირებს მიიღოს ხნით ადრე მივაღწევთ
ოთხ ხასიათი strings.
ეს შესაძლოა რამდენიმე წუთის განმავლობაში.
>> ეს არ რამდენიმე წუთის განმავლობაში.
ჩვენ ოთხი ხასიათი strings.
მაგრამ ახლა, ჩვენ უნდა iterate ყველა შესაძლებელია ოთხი ხასიათი სიმები, რომლის
რომ შესაძლოა, შესაძლოა, 10 წუთის განმავლობაში.
და მაშინ, როდესაც ჩვენ მივაღწევთ ხუთ ხასიათი strings, ჩვენ უნდა iterate ყველა
იმ, რომლებიც შეიძლება მიიღოს რამდენიმე საათის განმავლობაში.
და ჩვენ უნდა iterate ყველა შესაძლო ექვსი ხასიათი სიმები, რომლის
შესაძლოა რამდენიმე დღე და ასე შემდეგ.
>> ასე რომ, ეს შეიძლება პოტენციურად ძალიან დიდი დრო, რომ iterate ყველა შესაძლო
რვა ხასიათი და ნაკლები strings.
ასე რომ შეამჩნია, რომ ეს არ არის აუცილებელი ძალიან ეფექტური ალგორითმის მოძიების
პაროლი.
თქვენ ალბათ ფიქრობთ, რომ არსებობს უკეთესი გზები.
მაგალითად, დაგავიწყდათ zyx, 32ab ალბათ არ არის ძალიან გავრცელებული პაროლი,
ხოლო დაგავიწყდათ 12345 არის ალბათ გაცილებით მეტი საერთო.
>> ასე რომ, ერთი გზა ცდილობენ გაარკვიონ დაგავიწყდათ უფრო სწრაფად არის შევჩერდეთ
ზე პაროლები, რომ ხშირია.
ასე მაგალითად, ჩვენ შეგვიძლია ცდილობენ წაიკითხა სიტყვა საწყისი ლექსიკონი და ცდილობენ ყველა
ეს სიტყვები, როგორც ჩვენი დაგავიწყდათ ხვდება.
ახლა, შესაძლოა დაგავიწყდათ არ არის, რომ მარტივი.
შესაძლოა შესახებ გარკვეულწილად ჭკვიანი და ცდილობენ appending ნომერი
ბოლოს სიტყვა.
>> ასე რომ, შესაძლოა, მათი დაგავიწყდათ იყო password1.
ასე რომ, შეგიძლიათ ცდილობენ iterating ყველა სიტყვა ამ ლექსიკონის ერთი
ჩაჯდება ბოლოს იგი.
და მაშინ იქნებ შემდეგ აკეთებს, რომ თქვენ დამატება ორიდან ბოლოს იგი.
>> ან იქნებ მომხმარებელი ცდილობს იყოს კიდევ უფრო ჭკვიანი, და მათ სურთ, რომ მათი
დაგავიწყდათ იყოს "ჰაკერების", მაგრამ ისინი აპირებს შეცვალოს ყველა ინსტანციის ელექტრონული ნახვა
ერთად threes.
ასე, რომ თქვენ შეიძლება ამის გაკეთება ძალიან.
Iterate ყველა სიტყვა ლექსიკონი მაგრამ შეცვლის ნიშნებს,
ჰგავს ციფრები იმ ნომრები.
>> ასე რომ, ამ გზით, შეიძლება დაჭერა კიდევ უფრო პაროლები, რომლებიც საკმაოდ გავრცელებული.
თუმცა საბოლოოდ, ერთადერთი გზა, თქვენ შეგიძლიათ ხელში ყველა პაროლები არის უხეში
აიძულოს iterate ყველა შესაძლებელია strings.
ასე რომ, საბოლოო ჯამში, თქვენ უნდა iterate ყველა strings ერთი ხასიათის
რვა პერსონაჟი, რომელიც შესაძლოა ძალიან დიდი ხანია, მაგრამ თქვენ უნდა გავაკეთოთ.
>> ჩემი სახელი Rob Bowden.
და ეს არის Crack.