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

2
00:00:13,000 --> 00:00:15,890
>> రాబ్ బౌడెన్: నేను రాబ్ రెడీ, మరియు
యొక్క పగుళ్లను లెట్స్ గెట్.

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
>> మరియు ఇక్కడ, మేము ఉప్పు ha అని చూడండి.

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
మరియు మేము iterate ఈ ఉపయోగించడానికి చేయబోతున్నామని
అన్ని తీగలను ఎక్కువ అనుకొనుట

50
00:02:59,860 --> 00:03:01,430
చెల్లుబాటు అయ్యే పాస్వర్డ్లను ఉంటుంది.

51
00:03:01,430 --> 00:03:07,720
కనుక ఒక పాస్వర్డ్ను చెల్లుబాటు అయ్యే అక్షరాలు
అప్పుడు ఒక, b మరియు c, ఉన్నాయి

52
00:03:07,720 --> 00:03:14,970
మేము, ఒక పైగా బి, సి, iterate ఉంటుంది
ఆ, బా, 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
మేము నుండి పట్టుకుని ఉప్పు తీసుకొని వెళ్తాము
ఎన్క్రిప్టెడ్ స్ట్రింగ్, మరియు మేము

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
>> మరియు మేము iterate అనుకుంటున్నారా
తదుపరి చెల్లుబాటు అయ్యే అంచనా.

78
00:04:43,250 --> 00:04:46,410
తద్వారా ఏమి ఈ సమయంలో
లూప్ చేయడానికి ప్రయత్నిస్తున్నారు.

79
00:04:46,410 --> 00:04:51,760
ఇది మా అంచనా iterate అవకాశముంది
తదుపరి చెల్లుబాటులో అంచనాకు.

80
00:04:51,760 --> 00:04:56,080
మేము చెప్పినప్పుడు మీరు గమనించవచ్చు ఒక
మా అంచనా ప్రత్యేక పాత్ర ఉంది

81
00:04:56,080 --> 00:05:01,770
ఇది ఇక్కడ గరిష్ట చిహ్నం, చేరుకుంది
హాష్ నుండి, ఒక tilde నిర్వచిస్తారు

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
సో మా అంచనాలు ఉన్నాయి
iterate వెళుతున్న?

89
00:05:28,730 --> 00:05:33,685
బాగా, చెల్లుబాటు అయ్యే అక్షరాలు, a, b ఉంటే
మరియు సి, అప్పుడు మేము, ఒక ప్రారంభించండి ఉంటే

90
00:05:33,685 --> 00:05:36,630
ఇది బి కు iterate చేస్తాము, ఇది చేస్తాము
సి కు iterate.

91
00:05:36,630 --> 00:05:44,360
సి మా గరిష్టంగా చిహ్నం, కాబట్టి మేము సెట్ చేస్తాము
ఒక తిరిగి సి, కనీస చిహ్నం.

92
00:05:44,360 --> 00:05:48,100
ఆపై మేము ఇండెక్స్ iterate చేస్తాము
తరువాత అక్షరానికి.

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
సో ఈ సమయంలో లూప్ iterate కానుంది
అన్ని తీగలను పైగా.

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
బాగా, oops - ఇది నిర్వచించబడలేదు చెప్పారు
నేల గురించి సూచన.

124
00:07:51,050 --> 00:07:55,330
P స్పెక్ అమర్చుతుంది మరియు కనుక గుర్తు
నేల కూడా మనిషి పేజీ మేము

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
కానీ ఇప్పుడు, మేము అన్ని పైగా iterate అవసరం
సాధ్యం నాలుగు పాత్ర తీగలను, ఇది

150
00:09:22,800 --> 00:09:26,000
ఆ ఉండవచ్చు 10 నిమిషాల సమయం పట్టవచ్చు.

151
00:09:26,000 --> 00:09:28,720
ఆపై మేము ఐదు పాత్ర చేరుకోవడానికి ఉన్నప్పుడు
తీగలను, మేము అన్ని పైగా iterate అవసరం

152
00:09:28,720 --> 00:09:31,450
ఆ, ఇది వాటిని
ఒక జంట గంటలు పడుతుంది.

153
00:09:31,450 --> 00:09:34,080
మరియు మేము అన్ని పైగా iterate అవసరం
ఆరు పాత్ర తీగలను, ఇది

154
00:09:34,080 --> 00:09:36,560
కాబట్టి ఒక జంట రోజుల సమయం పడుతుంది మరియు ఉండవచ్చు.

155
00:09:36,560 --> 00:09:41,380
>> కనుక ఇది చాలా శక్తివంతమైన ఒక పడుతుంది
అన్ని పైగా iterate సమయం

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
బహుశా వినియోగదారు కొంతవరకు నేర్పరి
మరియు ఒక సంఖ్య అనుమతిస్తూ ప్రయత్నించండి

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
నిఘంటువులో అన్ని పదాల కన్నా Iterate
కానీ ఆ పాత్రల స్థానంలో

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
అన్ని పైగా iterate బలవంతం
సాధ్యం తీగలను.

182
00:11:17,340 --> 00:11:22,100
సో చివరికి, మీరు iterate అవసరం
ఒక పాత్ర నుంచి అన్ని తీగలను పైగా

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