1
00:00:00,000 --> 00:00:13,000

2
00:00:13,000 --> 00:00:15,890
>> आरओबी BOWDEN: मैं रोब हूँ, और
के खुर मिलता है.

3
00:00:15,890 --> 00:00:19,390
तो pset कल्पना से याद है कि
हम उपयोग करने की जरूरत करने जा रहे हैं

4
00:00:19,390 --> 00:00:20,890
तहखाना समारोह.

5
00:00:20,890 --> 00:00:26,330
आदमी पृष्ठ के लिए, हमारे पास दो
हैश _xopensource परिभाषित.

6
00:00:26,330 --> 00:00:28,290
के बारे में चिंता मत करो क्यों
हम ऐसा करने की जरूरत है.

7
00:00:28,290 --> 00:00:31,550
और भी हैश unistd.h शामिल हैं.

8
00:00:31,550 --> 00:00:35,920
>> उस रास्ते से बाहर है तो एक बार, चलो
वास्तविक कार्यक्रम के लिए मिलता है.

9
00:00:35,920 --> 00:00:39,570
हम क्या करने की जरूरत है पहली बात बनाना है
उपयोगकर्ता एक वैध एन्क्रिप्टेड प्रवेश किया

10
00:00:39,570 --> 00:00:41,520
कमांड लाइन पर पासवर्ड.

11
00:00:41,520 --> 00:00:46,050
कार्यक्रम माना जाता है कि याद रखें
डॉट स्लेश दरार की तरह चलाने के लिए, और किया जाना है

12
00:00:46,050 --> 00:00:48,120
तब स्ट्रिंग एन्क्रिप्टेड.

13
00:00:48,120 --> 00:00:52,990
>> तो यहाँ हम यह सुनिश्चित करने के लिए जाँच कर रहे हैं
हम चाहते हैं कि अगर दो के लिए कि argc

14
00:00:52,990 --> 00:00:54,380
कार्यक्रम के साथ जारी है.

15
00:00:54,380 --> 00:00:58,830
Argc दो नहीं है, तो वह या तो इसका मतलब
उपयोगकर्ता एक एन्क्रिप्टेड दर्ज नहीं किया

16
00:00:58,830 --> 00:01:02,560
कमांड लाइन पर पासवर्ड, या वे
बस एन्क्रिप्टेड से अधिक दर्ज किया

17
00:01:02,560 --> 00:01:05,379
कमांड लाइन पर पासवर्ड, जिसमें
मामले में हम साथ क्या करना है पता नहीं है

18
00:01:05,379 --> 00:01:07,660
कमांड लाइन तर्क.

19
00:01:07,660 --> 00:01:11,390
>> Argc दो था तो, अगर हम जारी रख सकते हैं.

20
00:01:11,390 --> 00:01:14,160
और यहाँ, हम की घोषणा करने जा रहे हैं
एक चर एन्क्रिप्टेड.

21
00:01:14,160 --> 00:01:17,650
वह सिर्फ मूल उर्फ ​​जा रहा है
argv1 इतना है कि इस पूरे

22
00:01:17,650 --> 00:01:20,690
कार्यक्रम, हम यह argv1 फोन करने की जरूरत नहीं है
तो आप सोचने के लिए है जो

23
00:01:20,690 --> 00:01:22,950
कि वास्तव में क्या मतलब के बारे में.

24
00:01:22,950 --> 00:01:27,180
>> तो अंत में, हम यह सत्यापित करना चाहते हैं
एन्क्रिप्टेड पासवर्ड उपयोगकर्ता

25
00:01:27,180 --> 00:01:30,840
दर्ज किया वास्तव में हो सकता था
एक एन्क्रिप्टेड पासवर्ड.

26
00:01:30,840 --> 00:01:35,120
तहखाना ऑफ द प्रति पृष्ठ,
एन्क्रिप्टेड पासवर्ड 13 होना चाहिए

27
00:01:35,120 --> 00:01:36,440
वर्ण लंबा.

28
00:01:36,440 --> 00:01:41,500
यहाँ, हम परिभाषित हैश कि नोटिस
13 के रूप में लंबाई एन्क्रिप्ट.

29
00:01:41,500 --> 00:01:46,140
तो हम सिर्फ यकीन है कि कर रहे हैं
एन्क्रिप्टेड की स्ट्रिंग की लंबाई

30
00:01:46,140 --> 00:01:49,090
पासवर्ड 13 है.

31
00:01:49,090 --> 00:01:52,280
>> अगर ऐसा नहीं है, हम चाहते हैं
कार्यक्रम से बाहर निकलने के लिए.

32
00:01:52,280 --> 00:01:56,470
उस रास्ते से बाहर है तो, एक बार हम कर सकते हैं
अब वास्तव में खोजने के लिए क्या करने की कोशिश

33
00:01:56,470 --> 00:02:00,410
एन्क्रिप्टेड दिया कि पासवर्ड
पासवर्ड था.

34
00:02:00,410 --> 00:02:04,870
यहाँ, हम नमक हथियाना चाहते हैं
एन्क्रिप्टेड पासवर्ड से.

35
00:02:04,870 --> 00:02:08,930
, आदमी प्रति पृष्ठ, याद रखें कि
एक एन्क्रिप्टेड के पहले दो अक्षर

36
00:02:08,930 --> 00:02:10,590
स्ट्रिंग, यहां तरह -

37
00:02:10,590 --> 00:02:12,770
इतने पर 50ZPJ और -

38
00:02:12,770 --> 00:02:16,170
पहले दो अक्षर दे
हमें इस्तेमाल किया गया था कि नमक

39
00:02:16,170 --> 00:02:18,080
तहखाना समारोह में.

40
00:02:18,080 --> 00:02:21,740
>> और यहाँ, हम नमक हा था कि देखते हैं.

41
00:02:21,740 --> 00:02:27,610
इसलिए हम पहले दो कॉपी करना चाहते हैं
वर्ण, नमक लंबाई जा रहा हैश

42
00:02:27,610 --> 00:02:30,230
दो के रूप में परिभाषित किया.

43
00:02:30,230 --> 00:02:35,970
हम पहले दो अक्षर को कॉपी करने के लिए है
इस सरणी में, नमक.

44
00:02:35,970 --> 00:02:39,340
हम नमक लंबाई आवश्यकता से अधिक ध्यान दें कि
एक, हम अभी भी एक नल की जरूरत है

45
00:02:39,340 --> 00:02:42,440
हमारे नमक के अंत में टर्मिनेटर.

46
00:02:42,440 --> 00:02:46,940
>> तो फिर हम इस सरणी की घोषणा करने जा रहे हैं,
अतिथि, आकार अधिकतम लंबाई के साथ साथ

47
00:02:46,940 --> 00:02:51,930
अधिकतम लंबाई हैश परिभाषित किया गया है, जहां एक,
आठ के रूप में, के बाद से अधिकतम पासवर्ड

48
00:02:51,930 --> 00:02:55,090
आठ वर्ण लंबा है.

49
00:02:55,090 --> 00:02:59,860
और हम पुनरावृति करने के लिए इस का उपयोग करने के लिए जा रहे हैं
सभी संभव तार पर कि सका

50
00:02:59,860 --> 00:03:01,430
मान्य पासवर्ड का हो.

51
00:03:01,430 --> 00:03:07,720
तो अगर एक पासवर्ड में मान्य वर्ण
तो सिर्फ ए, बी, और सी, थे

52
00:03:07,720 --> 00:03:14,970
हम क, ख, ग से पुनरावृति होगा,
ए.ए., बीए, सीए, और इतने पर, जब तक

53
00:03:14,970 --> 00:03:16,690
हम cccccccc देखने को मिलता है -

54
00:03:16,690 --> 00:03:19,600
आठ सी है.

55
00:03:19,600 --> 00:03:23,620
>> और हम एक वैध नीचे नहीं है अगर
पासवर्ड, तो हम कहते हैं कि जरूरत

56
00:03:23,620 --> 00:03:26,590
एन्क्रिप्टेड स्ट्रिंग नहीं था
साथ शुरू करने के लिए मान्य है.

57
00:03:26,590 --> 00:03:29,970
तो अब, हम इस समय 1 लूप तक पहुँचने.

58
00:03:29,970 --> 00:03:33,100
यह बात है इसका मतलब नोटिस
एक अनंत लूप.

59
00:03:33,100 --> 00:03:36,430
>> कोई तोड़ बयान कर रहे हैं नोटिस
इस अनंत लूप के अंदर.

60
00:03:36,430 --> 00:03:38,570
केवल वापसी बयान कर रहे हैं.

61
00:03:38,570 --> 00:03:41,210
इसलिए हम वास्तव में उम्मीद नहीं
पाश बाहर निकलने के लिए.

62
00:03:41,210 --> 00:03:44,750
हम केवल कार्यक्रम से बाहर निकलने की उम्मीद है.

63
00:03:44,750 --> 00:03:48,220
मैं करने के लिए इस प्रिंट बयान जोड़ दिया है
बस बाहर मुद्रित करने के लिए इस लूप के ऊपर

64
00:03:48,220 --> 00:03:51,790
क्या हमारे वर्तमान अनुमान
क्या पासवर्ड है.

65
00:03:51,790 --> 00:03:53,630
>> अब, इस लूप क्या कर रहा है?

66
00:03:53,630 --> 00:03:58,330
यह सब संभव तार पर पाशन है
कि मान्य पासवर्ड का हो सकता है.

67
00:03:58,330 --> 00:04:02,700
हम क्या करने जा रहे हैं, पहली बात है
क्या के लिए हमारे वर्तमान अनुमान ले

68
00:04:02,700 --> 00:04:03,920
पासवर्ड है.

69
00:04:03,920 --> 00:04:07,230
हम से पकड़ा कि नमक ले जाऊँगा
एन्क्रिप्टेड स्ट्रिंग, और हम कर रहे हैं

70
00:04:07,230 --> 00:04:09,850
अनुमान है कि एन्क्रिप्ट करने के लिए जा रहा है.

71
00:04:09,850 --> 00:04:14,760
यह हमें एक एन्क्रिप्टेड अनुमान दे देंगे,
हम के खिलाफ तुलना करने के लिए जा रहे हैं जो

72
00:04:14,760 --> 00:04:18,810
एन्क्रिप्टेड स्ट्रिंग है कि उपयोगकर्ता
कमांड लाइन में प्रवेश किया.

73
00:04:18,810 --> 00:04:23,030
>> वे, जो मामले में वही कर रहे हैं
तुलनीय स्ट्रिंग, तो शून्य वापसी करेंगे

74
00:04:23,030 --> 00:04:28,050
वे वही कर रहे हैं, तो लगता था
एन्क्रिप्टेड उत्पन्न कि पासवर्ड

75
00:04:28,050 --> 00:04:33,520
हम मुद्रित कर सकते हैं, जो मामले में स्ट्रिंग,
कि हमारे पासवर्ड और वापसी के रूप में.

76
00:04:33,520 --> 00:04:37,520
लेकिन वे एक ही नहीं थे, कि
हमारा अनुमान गलत था मतलब है.

77
00:04:37,520 --> 00:04:43,250
>> और हम करने के लिए पुनरावृति करना चाहते हैं
अगले वैध अनुमान है.

78
00:04:43,250 --> 00:04:46,410
तो है कि क्या इस समय
पाश करने की कोशिश कर रहा है.

79
00:04:46,410 --> 00:04:51,760
यह हमारा अनुमान पुनरावृति करने के लिए जा रहा है
अगले वैध अनुमान है.

80
00:04:51,760 --> 00:04:56,080
जब हम कहते हैं कि सूचना है कि एक
हमारे अनुमान में विशेष चरित्र है

81
00:04:56,080 --> 00:05:01,770
जो यहां अधिकतम प्रतीक, पहुँचे
हैश के बाद से ध्यानपूर्वक, के रूप में परिभाषित किया गया है

82
00:05:01,770 --> 00:05:05,710
कि सबसे बड़ी ASCII मूल्य चरित्र है
एक उपयोगकर्ता में प्रवेश कर सकते हैं

83
00:05:05,710 --> 00:05:11,210
कीबोर्ड, चरित्र पहुँचता है
अधिकतम प्रतीक, तो हम भेजना चाहते हैं

84
00:05:11,210 --> 00:05:17,150
इसे वापस न्यूनतम प्रतीक को, जो
फिर एक अंतरिक्ष, सबसे कम ASCII है

85
00:05:17,150 --> 00:05:20,800
मूल्य प्रतीक है कि एक उपयोगकर्ता कर सकते हैं
कुंजीपटल पर दर्ज करें.

86
00:05:20,800 --> 00:05:22,940
>> इसलिए हम चाहते हैं कि सेट करने के लिए जा रहे हैं
न्यूनतम प्रतीक है.

87
00:05:22,940 --> 00:05:25,720
और फिर हम जाने के लिए जा रहे हैं
अगले चरित्र पर.

88
00:05:25,720 --> 00:05:28,730
तो कैसे हमारे अनुमान हैं
पुनरावृति करने के लिए जा रहे हैं?

89
00:05:28,730 --> 00:05:33,685
खैर, वैध अक्षर ए, बी हैं,
और सी, तो हम एक साथ शुरू किया था, तो

90
00:05:33,685 --> 00:05:36,630
यह यह हूँ, ख की पुनरावृति करेंगे
सी के लिए पुनरावृति.

91
00:05:36,630 --> 00:05:44,360
सी हमारी अधिकतम प्रतीक है, इसलिए हम निर्धारित करेंगे
ग पर वापस करने के लिए, कम से कम प्रतीक.

92
00:05:44,360 --> 00:05:48,100
और फिर हम सूचकांक पुनरावृति करेंगे
अगले चरित्र को.

93
00:05:48,100 --> 00:05:53,920
>> मूल अनुमान ग था तो, तो अगले
चरित्र अशक्त होने जा रहा है

94
00:05:53,920 --> 00:05:55,560
टर्मिनेटर.

95
00:05:55,560 --> 00:06:00,670
यहाँ नीचे, सूचना है कि अगर चरित्र
अब हम चाहते हैं कि करने के लिए

96
00:06:00,670 --> 00:06:04,690
वेतन वृद्धि, अशक्त टर्मिनेटर था
फिर हम इसे स्थापित करने के लिए जा रहे हैं

97
00:06:04,690 --> 00:06:06,260
न्यूनतम प्रतीक.

98
00:06:06,260 --> 00:06:11,431
अनुमान है कि ग था ऐसा है, तो हमारी
नए अनुमान ए.ए. होने जा रहा है.

99
00:06:11,431 --> 00:06:16,050
और हमारी मूल अनुमान था अगर
cccc, तो हमारे नए अनुमान

100
00:06:16,050 --> 00:06:18,380
AAAAA होने जा रहा है.

101
00:06:18,380 --> 00:06:24,430
>> हम अधिकतम स्ट्रिंग तक पहुँचने तो जब भी
किसी दिए गए लंबाई की, तो हम कर रहे हैं

102
00:06:24,430 --> 00:06:29,090
न्यूनतम स्ट्रिंग को लागू करने के लिए जा रहा
अगले लंबाई की, जो होगा

103
00:06:29,090 --> 00:06:34,420
बस सभी पात्रों का होना
न्यूनतम प्रतीक.

104
00:06:34,420 --> 00:06:36,970
अब, यह चेक यहाँ क्या कर रहा है?

105
00:06:36,970 --> 00:06:42,780
खैर, सूचकांक आठवें से चले गए, तो
नौ चरित्र को चरित्र -

106
00:06:42,780 --> 00:06:46,460
इसलिए हम के रूप में आठ सी जोड़
हमारे पिछले अनुमान है कि -

107
00:06:46,460 --> 00:06:51,270
फिर सूचकांक पर ध्यान केंद्रित करने जा रहा है
हमारे अनुमान के अंतिम अशक्त टर्मिनेटर

108
00:06:51,270 --> 00:06:57,990
वास्तव में यह मतलब नहीं है जो सरणी,
हमारे पासवर्ड में इस्तेमाल किया जा.

109
00:06:57,990 --> 00:07:03,530
>> हम चाहते हैं कि पिछले अशक्त करने पर ध्यान केंद्रित कर रहे हैं ताकि अगर
टर्मिनेटर, तो हम एक नहीं मिला है

110
00:07:03,530 --> 00:07:07,750
सिर्फ आठ का उपयोग वैध है कि पासवर्ड
कोई नहीं है, जिसका मतलब है वर्ण,

111
00:07:07,750 --> 00:07:10,550
encrypts कि वैध पासवर्ड
दिए गए स्ट्रिंग के लिए.

112
00:07:10,550 --> 00:07:13,520
और हम कह, कि मुद्रित करने के लिए है
हम एक मान्य नहीं मिल सकता है

113
00:07:13,520 --> 00:07:16,100
पासवर्ड, और वापसी.

114
00:07:16,100 --> 00:07:20,280
इसलिए इस समय पाश पुनरावृति करने के लिए जा रहा है
सभी संभव तार पर.

115
00:07:20,280 --> 00:07:24,640
>> यह करने के लिए encrypts कि किसी भी पाता है
उम्मीद एन्क्रिप्टेड स्ट्रिंग, यह हूँ

116
00:07:24,640 --> 00:07:26,190
उस पासवर्ड वापसी.

117
00:07:26,190 --> 00:07:29,610
और यह तो ठीक है, कुछ भी नहीं मिल रहा है
यह मुद्रण, वापस आ जाएगी कि यह

118
00:07:29,610 --> 00:07:31,910
कुछ भी खोजने के लिए सक्षम नहीं था.

119
00:07:31,910 --> 00:07:39,220
अब, सूचना है कि सब कुछ खत्म पुनरावृति
संभव तार शायद जा रहा है

120
00:07:39,220 --> 00:07:40,420
एक समय लग.

121
00:07:40,420 --> 00:07:43,590
वास्तव में देखते हैं कैसे
लंबे समय लेता है.

122
00:07:43,590 --> 00:07:47,230
>> की दरार कर दूं.

123
00:07:47,230 --> 00:07:51,050
खैर, ओह - यह अपरिभाषित कहते हैं
तहखाना करने के संदर्भ में है.

124
00:07:51,050 --> 00:07:55,330
पी सेट कल्पना और के लिए तो, याद
भी तहखाना के लिए मैन पेज कि हम

125
00:07:55,330 --> 00:07:58,130
तहखाना में लिंक करने की जरूरत है.

126
00:07:58,130 --> 00:08:01,130
अब, मूलभूत कमांड बनाने
पता नहीं है कि आप उस

127
00:08:01,130 --> 00:08:03,010
उस समारोह का उपयोग करना चाहते हैं.

128
00:08:03,010 --> 00:08:09,680
>> तो चलो इस ग्राहक आदेश की प्रतिलिपि जाने
और सिर्फ अंत करने पर जोड़

129
00:08:09,680 --> 00:08:13,300
तहखाना जोड़ने, इसके बारे में.

130
00:08:13,300 --> 00:08:14,820
अब, यह compiles.

131
00:08:14,820 --> 00:08:23,880
तो चलो एक दिया पर दरार चलाते हैं
एन्क्रिप्टेड स्ट्रिंग -

132
00:08:23,880 --> 00:08:25,130
इसलिए कैसर.

133
00:08:25,130 --> 00:08:28,690

134
00:08:28,690 --> 00:08:30,790
तो यह है कि बहुत तेजी से किया गया था.

135
00:08:30,790 --> 00:08:33,230
>> इस 13 को समाप्त हो गया नोटिस.

136
00:08:33,230 --> 00:08:38,240
खैर, कैसर एन्क्रिप्टेड पासवर्ड
13 होना होता है.

137
00:08:38,240 --> 00:08:41,650
तो चलो एक और पासवर्ड की कोशिश करते हैं.

138
00:08:41,650 --> 00:08:45,830
के Hirschhorn की एन्क्रिप्टेड लेते हैं
पासवर्ड और उस खुर का प्रयास करें.

139
00:08:45,830 --> 00:08:51,750

140
00:08:51,750 --> 00:08:55,110
>> तो हम पहले ही पहुँच चुके नोटिस
तीन अक्षर.

141
00:08:55,110 --> 00:08:58,660
और हम सभी संभव पर iterating कर रहे हैं
तीन चरित्र तार.

142
00:08:58,660 --> 00:09:01,420
यही कारण है कि हम पहले से ही खत्म कर दिया है इसका मतलब
सभी संभव एक और अधिक पुनरावृति

143
00:09:01,420 --> 00:09:04,660
दो चरित्र तार.

144
00:09:04,660 --> 00:09:09,180
इस जा रहा है की तरह अब, ऐसा लगता है
हम तक पहुंचने से पहले एक समय लग

145
00:09:09,180 --> 00:09:10,580
चार वर्ण स्ट्रिंग.

146
00:09:10,580 --> 00:09:14,680
यह कुछ मिनट लग सकते हैं.

147
00:09:14,680 --> 00:09:16,055
>> यह मिनट के एक जोड़े को नहीं ले गए थे.

148
00:09:16,055 --> 00:09:18,450
हम चार चरित्र तार पर हैं.

149
00:09:18,450 --> 00:09:22,800
लेकिन अब, हम सब से अधिक पुनरावृति करने की आवश्यकता
संभव चार वर्ण स्ट्रिंग, जो

150
00:09:22,800 --> 00:09:26,000
हो सकता है कि 10 मिनट लग सकते हैं.

151
00:09:26,000 --> 00:09:28,720
और फिर हम पाँच चरित्र पर पहुँचने पर
तार, हम सब से अधिक पुनरावृति करने की आवश्यकता

152
00:09:28,720 --> 00:09:31,450
उन में से, जो हो सकता है
एक दो घंटे ले.

153
00:09:31,450 --> 00:09:34,080
और हम सभी संभव पर पुनरावृति करने की आवश्यकता
छह चरित्र तार, जो

154
00:09:34,080 --> 00:09:36,560
इतने पर एक दो दिन में लेने और हो सकता है.

155
00:09:36,560 --> 00:09:41,380
>> तो यह एक संभावित बहुत लंबे समय ले सकता है
सभी संभव पर पुनरावृति करने के लिए समय

156
00:09:41,380 --> 00:09:44,850
आठ चरित्र और कम तार.

157
00:09:44,850 --> 00:09:50,600
इसलिए यह जरूरी नहीं है कि सूचना के एक
खोजने के लिए बहुत ही कुशल एल्गोरिथ्म

158
00:09:50,600 --> 00:09:51,860
एक पासवर्ड.

159
00:09:51,860 --> 00:09:54,540
तुम्हें पता है कि वहाँ लगता है कि शायद
बेहतर तरीके से कर रहे हैं.

160
00:09:54,540 --> 00:10:02,230
उदाहरण के लिए, पासवर्ड ZYX! 32ab
शायद एक बहुत ही आम पासवर्ड नहीं है,

161
00:10:02,230 --> 00:10:06,440
पासवर्ड 12345 है जबकि
शायद एक बहुत अधिक सामान्य.

162
00:10:06,440 --> 00:10:13,570
>> एक पासवर्ड को खोजने की कोशिश की तो एक ही रास्ता
और अधिक तेजी से बस देखने के लिए है

163
00:10:13,570 --> 00:10:15,560
अधिक आम हैं कि पासवर्ड्स पर.

164
00:10:15,560 --> 00:10:20,480
तो उदाहरण के लिए, हम शब्दों को पढ़ने के लिए कोशिश कर सकते हैं
एक शब्दकोश से और सभी की कोशिश

165
00:10:20,480 --> 00:10:24,860
हमारे पासवर्ड अनुमान के रूप में उन शब्दों.

166
00:10:24,860 --> 00:10:29,210
अब, शायद एक पासवर्ड
इतना आसान नहीं है.

167
00:10:29,210 --> 00:10:32,600
हो सकता है कि उपयोगकर्ता कुछ हद तक चालाक था
और करने के लिए एक नंबर appending कोशिश

168
00:10:32,600 --> 00:10:34,220
किसी शब्द के अंत.

169
00:10:34,220 --> 00:10:37,000
>> तो शायद उनके पासवर्ड password1 गया था.

170
00:10:37,000 --> 00:10:41,520
तो तुम सभी शब्द पुनरावृति से अधिक प्रयास कर सकते हैं
एक एक के साथ इस शब्दकोश में

171
00:10:41,520 --> 00:10:43,210
यह के अंत में जोड़ा.

172
00:10:43,210 --> 00:10:47,360
और फिर हो सकता है कि करने के बाद, आप हूँ
यह अंत करने के लिए एक दो संलग्न.

173
00:10:47,360 --> 00:10:50,240
>> या हो सकता है उपयोगकर्ता करने की कोशिश कर रहा है और भी
अधिक चतुर है, और वे चाहते हैं कि उनके

174
00:10:50,240 --> 00:10:54,980
पासवर्ड "हैकर" हो सकता है लेकिन वे कर रहे हैं करने के लिए
ई के सभी उदाहरणों को बदलने के लिए जा रहा

175
00:10:54,980 --> 00:10:56,600
threes साथ.

176
00:10:56,600 --> 00:10:58,440
तो अगर आप भी ऐसा कर सकता है.

177
00:10:58,440 --> 00:11:02,100
शब्दकोश में सभी शब्द पर पुनरावृति
लेकिन पात्रों की जगह

178
00:11:02,100 --> 00:11:04,790
उन लोगों की संख्या के साथ नंबर की तरह लग रही है.

179
00:11:04,790 --> 00:11:09,670
>> तो इस तरह, आप और भी अधिक पकड़ सकता है
बहुत आम हैं कि पासवर्ड.

180
00:11:09,670 --> 00:11:14,690
लेकिन अंत में, आप कर सकते हैं एक ही रास्ता
सभी पासवर्ड कब्जा जानवर है

181
00:11:14,690 --> 00:11:17,340
बल पर सभी पुनरावृति
संभव तार.

182
00:11:17,340 --> 00:11:22,100
तो अंत में, आप पुनरावृति करने की जरूरत है
एक वर्ण से सभी तारों के ऊपर

183
00:11:22,100 --> 00:11:28,110
ले सकता है जो आठ वर्ण, एक
बहुत लंबे समय है, लेकिन आप यह सब करने की जरूरत है.

184
00:11:28,110 --> 00:11:30,024
>> मेरा नाम रोब बोडेन है.

185
00:11:30,024 --> 00:11:31,425
और इस दरार है.

186
00:11:31,425 --> 00:11:36,533