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

2
00:00:13,000 --> 00:00:15,890
>> Rob બોડેન: હું રોબ છું, અને
માતાનો ક્રેકીંગ મળી દો.

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
અમે વધુ B, C, ફરી વળવું હોત
આ, BA, CA, અને તેથી પર, ત્યાં સુધી

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
અમે માંથી grabbed કે મીઠું લઇ શકશો
એનક્રિપ્ટ થયેલ શબ્દમાળાને, અને અમે છો

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
તેથી કેવી રીતે અમારા guesses છે
ફરી વળવું જવા?

89
00:05:28,730 --> 00:05:33,685
વેલ, આ માન્ય અક્ષરો, એ, બી હોય તો
અને c, તો પછી અમે એક સાથે પ્રારંભ જો

90
00:05:33,685 --> 00:05:36,630
તે બી ફરી વળવું પડશે, તે પડશે
સી ફરી વળવું.

91
00:05:36,630 --> 00:05:44,360
કેચ અમારા મહત્તમ પ્રતીક છે, તેથી અમે સેટ પડશે
એક પાછા C, લઘુત્તમ પ્રતીક.

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
એન્ક્રિપ્ટ કે માન્ય પાસવર્ડ
આપેલ શબ્દમાળા છે.

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
>> તે શોધે છે, તો કોઈપણ માટે એન્ક્રિપ્ટ કે
અપેક્ષા એનક્રિપ્ટ થયેલ શબ્દમાળાને, તે પડશે

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
હવે, તે કમ્પાઇલ.

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
અને અમે બધા શક્ય ઉપર વારો કરી રહ્યાં છો
ત્રણ અક્ષરના શબ્દમાળાઓ.

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
અમારા પાસવર્ડ guesses તરીકે તે શબ્દો.

166
00:10:24,860 --> 00:10:29,210
હવે, કદાચ એક પાસવર્ડ
જે સરળ છે.

167
00:10:29,210 --> 00:10:32,600
કદાચ વપરાશકર્તા અંશે હોંશિયાર હતા
અને એક નંબર ઉમેરવાની પ્રયાસ

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
થ્રીસ સાથે.

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