|
688
|
1 #!PYTHON |
|
|
2 |
|
|
3 Red = '\033[1;31m' |
|
|
4 Green = '\033[1;32m' |
|
|
5 Yellow = '\033[1;33m' |
|
|
6 DefColour = '\033[0;0m' |
|
689
|
7 SpliceX = Red + '[Splice' + Yellow + 'X' + Red + ']: ' + DefColour |
|
688
|
8 |
|
|
9 def HELP(): |
|
|
10 print(Red+""" |
|
|
11 __________ _ _ __ __ ______ |
|
|
12 / / / / ___| _ __ | (_) ___ ___\ \/ / / / / / |
|
|
13 / / / /\___ \| '_ \| | |/ __/ _ \\\\ / / / / / |
|
|
14 / / / / ___) | |_) | | | (_| __// \ / / / / |
|
|
15 /_/_/_/ |____/| .__/|_|_|\___\___/_/\_\/_/_/_/ |
|
|
16 |_| |
|
|
17 |
|
|
18 """+DefColour) |
|
|
19 |
|
|
20 print(Yellow+""" |
|
|
21 .:Brute Force Utilities For GNU/Linux:. |
|
|
22 """+DefColour) |
|
|
23 |
|
|
24 print(""" |
|
|
25 |
|
|
26 SpliceX is free software: you can redistribute it and/or modify it under |
|
|
27 the terms of the GNU General Public License as published by the Free |
|
|
28 Software Foundation, either version 3 of the License, or (at your option) |
|
|
29 any later version. |
|
|
30 |
|
|
31 SpliceX is distributed in the hope that it will be useful, but WITHOUT |
|
|
32 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
|
33 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
|
34 for more details. <http://www.gnu.org/licenses/> |
|
|
35 |
|
|
36 |
|
|
37 """) |
|
|
38 print(""" |
|
|
39 --help Show help display and exit |
|
|
40 |
|
|
41 --command Parse passwords to this command |
|
|
42 |
|
|
43 --dictionary Path to custom dictionary(wordlist) |
|
|
44 |
|
|
45 --rtfm Show manual page and exit |
|
|
46 |
|
|
47 --restore Path to restore file |
|
|
48 |
|
|
49 --save Directory path to create save file |
|
|
50 |
|
|
51 --test Test output of command |
|
|
52 |
|
|
53 --time Manipulate timed iterations |
|
|
54 |
|
|
55 --usernames Path to username list |
|
|
56 |
|
|
57 --exh-l Use an exhaustive attack with letters only |
|
|
58 |
|
|
59 --exh-n Use an exhaustive attack with numbers only |
|
|
60 |
|
|
61 --exh-s Use an exhaustive attack with special characters only |
|
|
62 |
|
|
63 --exh-ln Use an exhaustive attack with letters and numbers only |
|
|
64 |
|
|
65 --exh-ls Use an exhaustive attack with letters and special |
|
|
66 characters only |
|
|
67 |
|
|
68 --exh-ns Use an exhaustive attack with numbers and special |
|
|
69 characters only |
|
|
70 |
|
|
71 --exh-all Use an exhaustive attack with all characters |
|
|
72 |
|
|
73 --exh-custom Use an exhaustive attack with custom characters |
|
|
74 |
|
|
75 --stdout Print only passwords to stdout |
|
|
76 |
|
|
77 -A Use alphabetical mixing module |
|
|
78 |
|
|
79 -B Use backwords module |
|
|
80 |
|
|
81 -C Use alternating caps module |
|
|
82 |
|
|
83 -L Use "L337" speak module |
|
|
84 |
|
|
85 -M Use MD5 module |
|
|
86 |
|
|
87 -N Use numerical mixing module |
|
|
88 |
|
|
89 -R Use regular words module |
|
|
90 |
|
|
91 -S Use special mixing module |
|
|
92 |
|
|
93 --mix-custom Use custom mixing module |
|
|
94 |
|
|
95 --wep-5 Use 5 character WEP module |
|
|
96 |
|
|
97 --wep-13 Use 13 character WEP module |
|
|
98 |
|
|
99 --wep-* Use 5 and 13 character WEP module |
|
|
100 |
|
|
101 --letters Use letter characters |
|
|
102 |
|
|
103 --numbers Use number characters |
|
|
104 |
|
|
105 --specials Use special characters |
|
|
106 |
|
|
107 --char-all Use all characters |
|
|
108 |
|
|
109 --no-char Override character usage |
|
|
110 |
|
|
111 --char-length Start and end with set character lengths |
|
|
112 |
|
|
113 --custom Use custom characters |
|
|
114 |
|
|
115 --deshadow Crack shadow hash sums |
|
|
116 |
|
|
117 --get-shadow Get the shadow info for a user |
|
|
118 |
|
|
119 --set-shadow Use the shadow info from a file |
|
|
120 |
|
|
121 --se-module Use the social engineering module |
|
|
122 |
|
|
123 --create Create a dictionary |
|
|
124 |
|
|
125 --debug Enable debugging |
|
|
126 |
|
|
127 """) |
|
|
128 |
|
|
129 import os |
|
|
130 import re |
|
|
131 import sys |
|
|
132 import spwd |
|
|
133 import getpass |
|
|
134 import os.path |
|
|
135 import getopt |
|
|
136 import time |
|
|
137 from hashlib import md5 |
|
|
138 |
|
|
139 cmd = None |
|
|
140 dictionary = None |
|
|
141 save = None |
|
|
142 restore = None |
|
|
143 test = None |
|
|
144 TIME = None |
|
|
145 LENGTH = None |
|
|
146 usernames = None |
|
|
147 MixCustom = None |
|
|
148 ExhCustom = None |
|
|
149 Custom = None |
|
|
150 GetShadow = None |
|
|
151 SetShadow = None |
|
|
152 ExhL = False |
|
|
153 ExhN = False |
|
|
154 ExhS = False |
|
|
155 ExhLN = False |
|
|
156 ExhLS = False |
|
|
157 ExhNS = False |
|
|
158 ExhALL = False |
|
|
159 StdoutSwitch = False |
|
|
160 AlphaSwitch = False |
|
|
161 BWSwitch = False |
|
|
162 CapsSwitch = False |
|
|
163 L337Switch = False |
|
|
164 MD5Switch = False |
|
|
165 NumberSwitch = False |
|
|
166 RegularSwitch = False |
|
|
167 SpecialSwitch = False |
|
|
168 wep5 = False |
|
|
169 wep13 = False |
|
|
170 NoChar = False |
|
|
171 Letters = False |
|
|
172 Numbers = False |
|
|
173 Specials = False |
|
|
174 DeShadow = False |
|
|
175 SESwitch = False |
|
|
176 Create = False |
|
|
177 DebugSwitch = False |
|
|
178 |
|
|
179 for arg in sys.argv: |
|
|
180 if '--command=' in arg: |
|
|
181 cmd = arg.replace('--command=', '', 1) |
|
|
182 elif '--dictionary=' in arg: |
|
|
183 dictionary = arg.replace('--dictionary=', '', 1) |
|
|
184 elif '--save=' in arg: |
|
|
185 save = arg.replace('--save=', '', 1) |
|
|
186 elif '--restore=' in arg: |
|
|
187 restore = arg.replace('--restore=', '', 1) |
|
|
188 elif '--test=' in arg: |
|
|
189 test = arg.replace('--test=', '', 1) |
|
|
190 elif '--time=' in arg: |
|
|
191 TIME = arg.replace('--time=', '', 1) |
|
|
192 elif '--char-length=' in arg: |
|
|
193 LENGTH = arg.replace('--char-length=', '', 1) |
|
|
194 elif '--usernames=' in arg: |
|
|
195 usernames = arg.replace('--usernames=', '', 1) |
|
|
196 elif '--mix-custom=' in arg: |
|
|
197 MixCustom = arg.replace('--mix-custom=', '', 1) |
|
|
198 elif '--exh-custom=' in arg: |
|
|
199 ExhCustom = arg.replace('--exh-custom=', '', 1) |
|
|
200 elif '--custom=' in arg: |
|
|
201 Custom = arg.replace('--custom=', '', 1) |
|
|
202 elif '--get-shadow=' in arg: |
|
|
203 GetShadow = arg.replace('--get-shadow=', '', 1) |
|
|
204 elif '--set-shadow=' in arg: |
|
|
205 SetShadow = arg.replace('--set-shadow=', '', 1) |
|
|
206 elif '--rtfm' in arg: |
|
|
207 os.system("man /etc/splicex/splicex.1.gz") |
|
|
208 sys.exit(0) |
|
|
209 elif '--exh-l' in arg: |
|
|
210 ExhL = True |
|
|
211 elif '--exh-n' in arg: |
|
|
212 ExhN = True |
|
|
213 elif '--exh-s' in arg: |
|
|
214 ExhS = True |
|
|
215 elif '--exh-ln' in arg: |
|
|
216 ExhLN = True |
|
|
217 elif '--exh-ls' in arg: |
|
|
218 ExhLS = True |
|
|
219 elif '--exh-ns' in arg: |
|
|
220 ExhNS = True |
|
|
221 elif '--exh-all' in arg: |
|
|
222 ExhALL = True |
|
|
223 elif '--stdout' in arg: |
|
|
224 StdoutSwitch = True |
|
|
225 elif '-A' in arg: |
|
|
226 AlphaSwitch = True |
|
|
227 elif '-B' in arg: |
|
|
228 BWSwitch = True |
|
|
229 elif '-C' in arg: |
|
|
230 CapsSwitch = True |
|
|
231 elif '-L' in arg: |
|
|
232 L337Switch = True |
|
|
233 elif '-M' in arg: |
|
|
234 MD5Switch = True |
|
|
235 elif '-N' in arg: |
|
|
236 NumberSwitch = True |
|
|
237 elif '-R' in arg: |
|
|
238 RegularSwitch = True |
|
|
239 elif '-S' in arg: |
|
|
240 SpecialSwitch = True |
|
|
241 elif '--wep-5' in arg: |
|
|
242 wep5 = True |
|
|
243 elif '--no-13' in arg: |
|
|
244 wep13 = True |
|
|
245 elif '--wep-*' in arg: |
|
|
246 wep5 = True |
|
|
247 wep13 = True |
|
|
248 elif '--no-char' in arg: |
|
|
249 NoChar = True |
|
|
250 elif '--letters' in arg: |
|
|
251 Letters = True |
|
|
252 elif '--numbers' in arg: |
|
|
253 Numbers = True |
|
|
254 elif '--specials' in arg: |
|
|
255 Specials = True |
|
|
256 elif '--char-all' in arg: |
|
|
257 Letters = True |
|
|
258 Numbers = True |
|
|
259 Specials = True |
|
|
260 elif '--deshadow' in arg: |
|
|
261 DeShadow = True |
|
|
262 elif '--se-module' in arg: |
|
|
263 SESwitch = True |
|
|
264 elif '--create' in arg: |
|
|
265 Create = True |
|
|
266 elif '--debug' in arg: |
|
|
267 DebugSwitch = True |
|
|
268 elif '--help' in arg: |
|
|
269 sys.exit(HELP()) |
|
|
270 |
|
|
271 if DebugSwitch is False: |
|
|
272 sys.tracebacklimit = 0 |
|
|
273 |
|
|
274 if ExhCustom is not None: |
|
|
275 dictionary = ExhCustom |
|
|
276 Custom = ExhCustom |
|
|
277 |
|
|
278 |
|
|
279 |
|
|
280 ExhSwitch = False |
|
|
281 if ExhL == True: |
|
|
282 dictionary = "/etc/splicex/splicex.L" |
|
|
283 Letters = True |
|
|
284 Numbers = False |
|
|
285 Specials = False |
|
|
286 AlphaSwitch = False |
|
|
287 BWSwitch = False |
|
|
288 CapsSwitch = False |
|
|
289 L337Switch = False |
|
|
290 NumberSwitch = False |
|
|
291 MD5Switch = False |
|
|
292 RegularSwitch = True |
|
|
293 SpecialSwitch = False |
|
|
294 ExhSwitch = True |
|
|
295 if ExhN == True: |
|
|
296 dictionary = "/etc/splicex/splicex.N" |
|
|
297 Letters = False |
|
|
298 Numbers = True |
|
|
299 Specials = False |
|
|
300 AlphaSwitch = False |
|
|
301 BWSwitch = False |
|
|
302 CapsSwitch = False |
|
|
303 L337Switch = False |
|
|
304 NumberSwitch = False |
|
|
305 MD5Switch = False |
|
|
306 RegularSwitch = True |
|
|
307 SpecialSwitch = False |
|
|
308 ExhSwitch = True |
|
|
309 if ExhS == True: |
|
|
310 dictionary = "/etc/splicex/splicex.S" |
|
|
311 Letters = False |
|
|
312 Numbers = False |
|
|
313 Specials = True |
|
|
314 AlphaSwitch = False |
|
|
315 BWSwitch = False |
|
|
316 CapsSwitch = False |
|
|
317 L337Switch = False |
|
|
318 NumberSwitch = False |
|
|
319 MD5Switch = False |
|
|
320 RegularSwitch = True |
|
|
321 SpecialSwitch = False |
|
|
322 ExhSwitch = True |
|
|
323 if ExhLN == True: |
|
|
324 dictionary = "/etc/splicex/splicex.LN" |
|
|
325 Letters = True |
|
|
326 Numbers = True |
|
|
327 Specials = False |
|
|
328 AlphaSwitch = False |
|
|
329 BWSwitch = False |
|
|
330 CapsSwitch = False |
|
|
331 L337Switch = False |
|
|
332 NumberSwitch = False |
|
|
333 MD5Switch = False |
|
|
334 RegularSwitch = True |
|
|
335 SpecialSwitch = False |
|
|
336 ExhSwitch = True |
|
|
337 if ExhLS == True: |
|
|
338 dictionary = "/etc/splicex/splicex.LS" |
|
|
339 Letters = True |
|
|
340 Numbers = False |
|
|
341 Specials = True |
|
|
342 AlphaSwitch = False |
|
|
343 BWSwitch = False |
|
|
344 CapsSwitch = False |
|
|
345 L337Switch = False |
|
|
346 NumberSwitch = False |
|
|
347 MD5Switch = False |
|
|
348 RegularSwitch = True |
|
|
349 SpecialSwitch = False |
|
|
350 ExhSwitch = True |
|
|
351 if ExhNS == True: |
|
|
352 dictionary = "/etc/splicex/splicex.NS" |
|
|
353 Letters = False |
|
|
354 Numbers = True |
|
|
355 Specials = True |
|
|
356 AlphaSwitch = False |
|
|
357 BWSwitch = False |
|
|
358 CapsSwitch = False |
|
|
359 L337Switch = False |
|
|
360 NumberSwitch = False |
|
|
361 MD5Switch = False |
|
|
362 RegularSwitch = True |
|
|
363 SpecialSwitch = False |
|
|
364 ExhSwitch = True |
|
|
365 if ExhALL == True: |
|
|
366 dictionary = "/etc/splicex/splicex.ALL" |
|
|
367 Letters = True |
|
|
368 Numbers = True |
|
|
369 Specials = True |
|
|
370 AlphaSwitch = False |
|
|
371 BWSwitch = False |
|
|
372 CapsSwitch = False |
|
|
373 L337Switch = False |
|
|
374 NumberSwitch = False |
|
|
375 MD5Switch = False |
|
|
376 RegularSwitch = True |
|
|
377 SpecialSwitch = False |
|
|
378 ExhSwitch = True |
|
|
379 |
|
|
380 if Custom is not None and dictionary is not None: |
|
|
381 if Custom == dictionary: |
|
|
382 Letters = False |
|
|
383 Numbers = True |
|
|
384 Specials = True |
|
|
385 AlphaSwitch = False |
|
|
386 BWSwitch = False |
|
|
387 CapsSwitch = False |
|
|
388 L337Switch = False |
|
|
389 NumberSwitch = False |
|
|
390 MD5Switch = False |
|
|
391 RegularSwitch = True |
|
|
392 SpecialSwitch = False |
|
|
393 ExhSwitch = True |
|
|
394 |
|
|
395 |
|
|
396 ShadowValue = [] |
|
|
397 if DeShadow is True and SetShadow is None and GetShadow is None: |
|
689
|
398 sys.exit(SpliceX + "error: --deshadow requires --getshadow or --setshadow") |
|
688
|
399 if SetShadow is not None and GetShadow is not None: |
|
689
|
400 sys.exit(SpliceX + "error: --getshadow and --setshadow cannot be combined") |
|
688
|
401 elif not os.geteuid()==0 and GetShadow is not None: |
|
689
|
402 sys.exit(SpliceX + "error: --getshadow requires root privileges") |
|
688
|
403 elif os.geteuid()==0 and GetShadow is not None: |
|
|
404 try: |
|
|
405 ShadowValue = spwd.getspnam(GetShadow)[1] |
|
|
406 except: |
|
689
|
407 sys.exit(SpliceX + "error: --getshadow: invalid user entered") |
|
688
|
408 elif SetShadow is not None and os.path.exists(SetShadow): |
|
|
409 ShadowFile = open(SetShadow, 'r') |
|
|
410 for line in ShadowFile: |
|
|
411 line = line.replace('\n', '') |
|
|
412 ShadowValue = line |
|
|
413 if SetShadow is not None and not os.path.exists(SetShadow): |
|
689
|
414 sys.exit(SpliceX + "error: --setshadow: shadow file does not exist") |
|
688
|
415 elif SetShadow is not None or GetShadow is not None: |
|
|
416 ShadowSalt = ShadowValue.replace('$', '^1', 1) |
|
|
417 ShadowSalt = ShadowSalt.replace('$', '^2', 1) |
|
|
418 ShadowSalt = ShadowSalt.replace('$', '^3', 1) |
|
|
419 ShadowSalt=ShadowSalt[ShadowSalt.find("^1"):ShadowSalt.find("^3")] |
|
|
420 ShadowSalt = ShadowSalt.replace('^1', '$') |
|
|
421 ShadowSalt = ShadowSalt.replace('^2', '$') |
|
|
422 ShadowSalt = ShadowSalt + "$" |
|
|
423 ShadowValue = ShadowValue.replace(':', '^1', 1) |
|
|
424 ShadowValue = ShadowValue.replace(':', '^2', 1) |
|
|
425 ShadowValue=ShadowValue[ShadowValue.find("^1")+2:ShadowValue.find("^2")] |
|
|
426 ShadowValue = ShadowValue.replace('$', '\$') |
|
|
427 ShadowSalt = ShadowSalt.replace('$', '\$') |
|
|
428 |
|
|
429 if restore is not None and os.path.exists(restore) is False: |
|
689
|
430 sys.exit(SpliceX + "error: restore file does not exist") |
|
688
|
431 elif restore is not None and os.path.exists(restore) is True: |
|
|
432 RestoreSwitch = True |
|
|
433 State = [] |
|
|
434 StateCount = 0 |
|
|
435 if RestoreSwitch is True: |
|
|
436 RESTORE = open(restore, 'r') |
|
|
437 for line in RESTORE: |
|
|
438 line = line.replace('\n', '') |
|
|
439 State.append(line) |
|
|
440 StateCount += 1 |
|
|
441 StateCount -= 1 |
|
|
442 else: |
|
|
443 RestoreSwitch = False |
|
|
444 |
|
|
445 Slash = "/" |
|
|
446 if save is not None and not os.path.isdir(save): |
|
689
|
447 sys.exit(SpliceX + "error: ( -s ) invalid directory") |
|
688
|
448 elif save is not None and os.path.isdir(save): |
|
|
449 SaveSwitch = True |
|
|
450 s = "" |
|
|
451 up = 0 |
|
|
452 end = 0 |
|
|
453 for let in save: |
|
|
454 end += 1 |
|
|
455 for let in save: |
|
|
456 up += 1 |
|
|
457 if let == Slash and end == up: |
|
|
458 s += "" |
|
|
459 else: |
|
|
460 s += let |
|
|
461 save = s |
|
|
462 save += Slash + "splicex.save" |
|
|
463 else: |
|
|
464 SaveSwitch = False |
|
|
465 |
|
|
466 if dictionary is None: |
|
|
467 dictionary = "/etc/splicex/splicex.list" |
|
|
468 elif dictionary is not None and not os.path.exists(dictionary): |
|
689
|
469 sys.exit(SpliceX + "error: dictionary does not exist") |
|
|
470 |
|
688
|
471 if usernames is None: |
|
|
472 UserSwitch = False |
|
|
473 elif usernames is not None and not os.path.exists(usernames): |
|
689
|
474 sys.exit(SpliceX + "error: username list does not exist") |
|
688
|
475 else: |
|
|
476 UserSwitch = True |
|
|
477 |
|
|
478 if RestoreSwitch is False: |
|
|
479 AlphaSwitch = AlphaSwitch |
|
|
480 CapsSwitch = CapsSwitch |
|
|
481 BWSwitch = BWSwitch |
|
|
482 L337Switch = L337Switch |
|
|
483 MD5Switch = MD5Switch |
|
|
484 NumberSwitch = NumberSwitch |
|
|
485 RegularSwitch = RegularSwitch |
|
|
486 SpecialSwitch = SpecialSwitch |
|
|
487 Letters = Letters |
|
|
488 Numbers = Numbers |
|
|
489 Specials = Specials |
|
|
490 MixCustom = MixCustom |
|
|
491 Custom = Custom |
|
|
492 wep5 = wep5 |
|
|
493 wep13 = wep13 |
|
|
494 else: |
|
|
495 cmd = State[0] |
|
|
496 dictionary = State[1] |
|
|
497 MixCustom = State[2] |
|
|
498 Custom = State[3] |
|
|
499 if State[4] == "True": |
|
|
500 ExhSwitch = True |
|
|
501 else: |
|
|
502 ExhSwitch = False |
|
|
503 if State[5] == "True": |
|
|
504 StdoutSwitch = True |
|
|
505 else: |
|
|
506 StdoutSwitch = False |
|
|
507 usernames = State[6] |
|
|
508 if State[7] == "True": |
|
|
509 UserSwitch = True |
|
|
510 else: |
|
|
511 UserSwitch = False |
|
|
512 if State[8] == "True": |
|
|
513 AlphaSwitch = True |
|
|
514 else: |
|
|
515 AlphaSwitch = False |
|
|
516 if State[9] == "True": |
|
|
517 BWSwitch = True |
|
|
518 else: |
|
|
519 BWSwitch = False |
|
|
520 if State[10] == "True": |
|
|
521 CapsSwitch = True |
|
|
522 else: |
|
|
523 CapsSwitch = False |
|
|
524 if State[11] == "True": |
|
|
525 L337Switch = True |
|
|
526 else: |
|
|
527 L337Switch = False |
|
|
528 if State[12] == "True": |
|
|
529 MD5Switch = True |
|
|
530 else: |
|
|
531 MD5Switch = False |
|
|
532 if State[13] == "True": |
|
|
533 NumberSwitch = True |
|
|
534 else: |
|
|
535 NumberSwitch = False |
|
|
536 if State[14] == "True": |
|
|
537 RegularSwitch = True |
|
|
538 else: |
|
|
539 RegularSwitch = False |
|
|
540 if State[15] == "True": |
|
|
541 SpecialSwitch = True |
|
|
542 else: |
|
|
543 SpecialSwitch = False |
|
|
544 if State[16] == "True": |
|
|
545 Letters = True |
|
|
546 else: |
|
|
547 Letters = False |
|
|
548 if State[17] == "True": |
|
|
549 Numbers = True |
|
|
550 else: |
|
|
551 Numbers = False |
|
|
552 if State[18] == "True": |
|
|
553 Specials = True |
|
|
554 else: |
|
|
555 Specials = False |
|
|
556 if State[19] == "True": |
|
|
557 wep5 = True |
|
|
558 else: |
|
|
559 wep5 = False |
|
|
560 if State[20] == "True": |
|
|
561 wep13 = True |
|
|
562 else: |
|
|
563 wep13 = False |
|
|
564 if State[21] == "True": |
|
|
565 SESwitch = True |
|
|
566 else: |
|
|
567 SESwitch = False |
|
|
568 |
|
|
569 if StdoutSwitch is True: |
|
|
570 cmd = "STDOUT PASSWORD ON" |
|
|
571 |
|
|
572 if Create is False and RestoreSwitch is False: |
|
|
573 ShadowSwitch = DeShadow |
|
|
574 if ShadowSwitch is True: |
|
689
|
575 cmd = "splicex-deshadow PASSWORD '" + ShadowSalt + "' '" + ShadowValue + "'" |
|
688
|
576 if cmd is None: |
|
689
|
577 sys.exit(SpliceX + "error: invalid usage") |
|
688
|
578 else: |
|
|
579 cmd = cmd.replace('','eval ', 1) |
|
|
580 |
|
|
581 if Create is False and RestoreSwitch is False: |
|
|
582 if cmd.__contains__("PASSWORD"): |
|
|
583 pass |
|
|
584 else: |
|
689
|
585 sys.exit(SpliceX + "error: -c does not contain regexp `PASSWORD'") |
|
688
|
586 |
|
|
587 if usernames is not None and RestoreSwitch is False: |
|
|
588 if cmd.__contains__("USERNAME"): |
|
|
589 pass |
|
|
590 else: |
|
689
|
591 sys.exit(SpliceX + "error: -c does not contain regexp `USERNAME'") |
|
688
|
592 |
|
|
593 if Create is True: |
|
|
594 print('Creating dictionary and exiting') |
|
|
595 |
|
|
596 if Create is False and cmd.__contains__("splicex-deshadow"): |
|
|
597 test = "SHADOW CRACKED" |
|
|
598 |
|
|
599 |
|
|
600 if AlphaSwitch is False and BWSwitch is False and CapsSwitch is False\ |
|
|
601 and L337Switch is False and NumberSwitch is False and RegularSwitch is False\ |
|
|
602 and SpecialSwitch is False and MixCustom is None and MD5Switch is False\ |
|
|
603 and wep5 is False and wep13 is False and SESwitch is False: |
|
689
|
604 sys.exit(SpliceX + "error: no modules selected: ( -A -B -C -L -M -N -R -S --mix-custom --wep-5 --wep-13 --wep-* --se-module)") |
|
688
|
605 |
|
|
606 CharsMain = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",\ |
|
|
607 "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",\ |
|
|
608 "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "-", "_", "=", "+", "[", "]",\ |
|
|
609 "`", "~", "{", "}", "\\", "|", ";", ":", "\"", "'", "<", ",", ">", ".", "?", "/"] |
|
|
610 |
|
|
611 CharSet1 = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",\ |
|
|
612 "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",\ |
|
|
613 "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "-", "_", "=", "+", "[", "]", "{", "}", "\\", "|", ";", ":", "\"", "'", "<", ",",\ |
|
|
614 "`", "~", ">", ".", "?", "/", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] |
|
|
615 |
|
|
616 CharSet2 = ["!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "-", "_", "=", "+", "[", "]", "{", "}", "\\", "|", ";", ":", "\"", "'", "<", ",",\ |
|
|
617 "`", "~", ">", ".", "?", "/", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] |
|
|
618 |
|
|
619 CharSet3 = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",\ |
|
|
620 "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",\ |
|
|
621 "!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "-", "_", "=", "+", "[", "]", "{", "}", "\\", "|", ";", ":", "\"", "'", "<", ",",\ |
|
|
622 "`", "~", ">", ".", "?", "/"] |
|
|
623 |
|
|
624 CharSet4 = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",\ |
|
|
625 "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",\ |
|
|
626 "1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] |
|
|
627 |
|
|
628 CharSet5 = ["!", "@", "#", "$", "%", "^", "&", "*", "(", ")", "-", "_", "=", "+", "[", "]", "{", "}", "\\", "|", ";", ":", "\"", "'", "<", ",",\ |
|
|
629 "`", "~", ">", ".", "?", "/"] |
|
|
630 |
|
|
631 CharSet6 = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",\ |
|
|
632 "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"] |
|
|
633 |
|
|
634 CharSet7 = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"] |
|
|
635 |
|
|
636 |
|
|
637 if Letters == True and Numbers == True and Specials == True: |
|
|
638 Characters = CharSet1 |
|
|
639 elif Letters == False and Numbers == True and Specials == True: |
|
|
640 Characters = CharSet2 |
|
|
641 elif Letters == True and Numbers == False and Specials == True: |
|
|
642 Characters = CharSet3 |
|
|
643 elif Letters == True and Numbers == True and Specials == False: |
|
|
644 Characters = CharSet4 |
|
|
645 elif Letters == False and Numbers == False and Specials == True: |
|
|
646 Characters = CharSet5 |
|
|
647 elif Letters == True and Numbers == False and Specials == False: |
|
|
648 Characters = CharSet6 |
|
|
649 elif Letters == False and Numbers == True and Specials == False: |
|
|
650 Characters = CharSet7 |
|
|
651 else: |
|
|
652 Characters = CharSet1 |
|
|
653 |
|
|
654 if Custom != "None" and RestoreSwitch is True: |
|
|
655 if os.path.exists(Custom): |
|
|
656 Characters = [] |
|
|
657 UserCharacters = open(Custom, 'r') |
|
|
658 for line in UserCharacters: |
|
|
659 Characters.append(line.replace('\n', '')) |
|
|
660 elif Custom is not None and RestoreSwitch is False: |
|
|
661 if os.path.exists(Custom): |
|
|
662 Characters = [] |
|
|
663 UserCharacters = open(Custom, 'r') |
|
|
664 for line in UserCharacters: |
|
|
665 Characters.append(line.replace('\n', '')) |
|
|
666 else: |
|
689
|
667 sys.exit(SpliceX + "error: --custom list does not exist") |
|
688
|
668 |
|
|
669 EndCount = 0 |
|
|
670 for CountChars in Characters: |
|
|
671 EndCount += 1 |
|
|
672 |
|
|
673 Char1 = [] |
|
|
674 for a in range(0, EndCount): |
|
|
675 Char1.append(Characters[a]) |
|
|
676 Char2 = [] |
|
|
677 for a in range(0, EndCount): |
|
|
678 Char2.append("\\\\\\" + Characters[a]) |
|
|
679 |
|
|
680 if AlphaSwitch == True and NumberSwitch == True and SpecialSwitch == True: |
|
|
681 MixChars = CharSet1 |
|
|
682 elif AlphaSwitch == False and NumberSwitch == True and SpecialSwitch == True: |
|
|
683 MixChars = CharSet2 |
|
|
684 elif AlphaSwitch == True and NumberSwitch == False and SpecialSwitch == True: |
|
|
685 MixChars = CharSet3 |
|
|
686 elif AlphaSwitch == True and NumberSwitch == True and SpecialSwitch == False: |
|
|
687 MixChars = CharSet4 |
|
|
688 elif AlphaSwitch == False and NumberSwitch == False and SpecialSwitch == True: |
|
|
689 MixChars = CharSet5 |
|
|
690 elif AlphaSwitch == True and NumberSwitch == False and SpecialSwitch == False: |
|
|
691 MixChars = CharSet6 |
|
|
692 elif AlphaSwitch == False and NumberSwitch == True and SpecialSwitch == False: |
|
|
693 MixChars = CharSet7 |
|
|
694 else: |
|
|
695 MixChars = CharSet1 |
|
|
696 |
|
|
697 if MixCustom != "None" and RestoreSwitch is True: |
|
|
698 if os.path.exists(MixCustom): |
|
|
699 MixChars = [] |
|
|
700 MixCharacters = open(MixCustom, 'r') |
|
|
701 for line in MixCharacters: |
|
|
702 MixChars.append(line.replace('\n', '')) |
|
|
703 elif MixCustom is not None and RestoreSwitch is False: |
|
|
704 if os.path.exists(MixCustom): |
|
|
705 MixChars = [] |
|
|
706 MixCharacters = open(MixCustom, 'r') |
|
|
707 for line in MixCharacters: |
|
|
708 MixChars.append(line.replace('\n', '')) |
|
|
709 else: |
|
689
|
710 sys.exit(SpliceX + "error: -U list does not exist") |
|
688
|
711 |
|
|
712 Word = [] |
|
|
713 ReadDictionary = open(dictionary, 'r') |
|
|
714 def REGULAR(): |
|
|
715 for line in ReadDictionary: |
|
|
716 Word.append(line.replace('\n', '')) |
|
|
717 |
|
|
718 def L337(): |
|
|
719 for line in ReadDictionary: |
|
|
720 line = line.replace("a", "4", 1) |
|
|
721 Word.append(line.replace('\n', '')) |
|
|
722 |
|
|
723 for line in ReadDictionary: |
|
|
724 line = line.replace("a", "4") |
|
|
725 Word.append(line.replace('\n', '')) |
|
|
726 |
|
|
727 for line in ReadDictionary: |
|
|
728 line = line.replace("a", "@", 1) |
|
|
729 Word.append(line.replace('\n', '')) |
|
|
730 |
|
|
731 for line in ReadDictionary: |
|
|
732 line = line.replace("a", "@") |
|
|
733 Word.append(line.replace('\n', '')) |
|
|
734 |
|
|
735 for line in ReadDictionary: |
|
|
736 line = line.replace("a", "^", 1) |
|
|
737 Word.append(line.replace('\n', '')) |
|
|
738 |
|
|
739 for line in ReadDictionary: |
|
|
740 line = line.replace("a", "^") |
|
|
741 Word.append(line.replace('\n', '')) |
|
|
742 |
|
|
743 for line in ReadDictionary: |
|
|
744 line = line.replace("b", "8", 1) |
|
|
745 Word.append(line.replace('\n', '')) |
|
|
746 for line in ReadDictionary: |
|
|
747 line = line.replace("b", "8") |
|
|
748 Word.append(line.replace('\n', '')) |
|
|
749 |
|
|
750 for line in ReadDictionary: |
|
|
751 line = line.replace("e", "3", 1) |
|
|
752 Word.append(line.replace('\n', '')) |
|
|
753 |
|
|
754 for line in ReadDictionary: |
|
|
755 line = line.replace("e", "3") |
|
|
756 Word.append(line.replace('\n', '')) |
|
|
757 |
|
|
758 for line in ReadDictionary: |
|
|
759 line = line.replace("f", "ph", 1) |
|
|
760 Word.append(line.replace('\n', '')) |
|
|
761 |
|
|
762 for line in ReadDictionary: |
|
|
763 line = line.replace("g", "6", 1) |
|
|
764 Word.append(line.replace('\n', '')) |
|
|
765 |
|
|
766 for line in ReadDictionary: |
|
|
767 line = line.replace("g", "6") |
|
|
768 Word.append(line.replace('\n', '')) |
|
|
769 |
|
|
770 for line in ReadDictionary: |
|
|
771 line = line.replace("g", "9", 1) |
|
|
772 Word.append(line.replace('\n', '')) |
|
|
773 |
|
|
774 for line in ReadDictionary: |
|
|
775 line = line.replace("g", "9") |
|
|
776 Word.append(line.replace('\n', '')) |
|
|
777 |
|
|
778 for line in ReadDictionary: |
|
|
779 line = line.replace("h", "#", 1) |
|
|
780 Word.append(line.replace('\n', '')) |
|
|
781 |
|
|
782 for line in ReadDictionary: |
|
|
783 line = line.replace("h", "#") |
|
|
784 Word.append(line.replace('\n', '')) |
|
|
785 |
|
|
786 for line in ReadDictionary: |
|
|
787 line = line.replace("i", "1", 1) |
|
|
788 Word.append(line.replace('\n', '')) |
|
|
789 |
|
|
790 for line in ReadDictionary: |
|
|
791 line = line.replace("i", "1") |
|
|
792 Word.append(line.replace('\n', '')) |
|
|
793 |
|
|
794 for line in ReadDictionary: |
|
|
795 line = line.replace("i", "!", 1) |
|
|
796 Word.append(line.replace('\n', '')) |
|
|
797 |
|
|
798 for line in ReadDictionary: |
|
|
799 line = line.replace("i", "!") |
|
|
800 Word.append(line.replace('\n', '')) |
|
|
801 |
|
|
802 for line in ReadDictionary: |
|
|
803 line = line.replace("i", "|", 1) |
|
|
804 Word.append(line.replace('\n', '')) |
|
|
805 |
|
|
806 for line in ReadDictionary: |
|
|
807 line = line.replace("i", "|") |
|
|
808 Word.append(line.replace('\n', '')) |
|
|
809 |
|
|
810 for line in ReadDictionary: |
|
|
811 line = line.replace("k", "X", 1) |
|
|
812 Word.append(line.replace('\n', '')) |
|
|
813 |
|
|
814 for line in ReadDictionary: |
|
|
815 line = line.replace("k", "X") |
|
|
816 Word.append(line.replace('\n', '')) |
|
|
817 |
|
|
818 for line in ReadDictionary: |
|
|
819 line = line.replace("l", "1", 1) |
|
|
820 Word.append(line.replace('\n', '')) |
|
|
821 |
|
|
822 for line in ReadDictionary: |
|
|
823 line = line.replace("l", "1") |
|
|
824 Word.append(line.replace('\n', '')) |
|
|
825 |
|
|
826 for line in ReadDictionary: |
|
|
827 line = line.replace("l", "|", 1) |
|
|
828 Word.append(line.replace('\n', '')) |
|
|
829 |
|
|
830 for line in ReadDictionary: |
|
|
831 line = line.replace("l", "|") |
|
|
832 Word.append(line.replace('\n', '')) |
|
|
833 |
|
|
834 for line in ReadDictionary: |
|
|
835 line = line.replace("o", "0", 1) |
|
|
836 Word.append(line.replace('\n', '')) |
|
|
837 |
|
|
838 for line in ReadDictionary: |
|
|
839 line = line.replace("o", "0") |
|
|
840 Word.append(line.replace('\n', '')) |
|
|
841 |
|
|
842 for line in ReadDictionary: |
|
|
843 line = line.replace("s", "5", 1) |
|
|
844 Word.append(line.replace('\n', '')) |
|
|
845 |
|
|
846 for line in ReadDictionary: |
|
|
847 line = line.replace("s", "5") |
|
|
848 Word.append(line.replace('\n', '')) |
|
|
849 |
|
|
850 for line in ReadDictionary: |
|
|
851 line = line.replace("s", "$", 1) |
|
|
852 Word.append(line.replace('\n', '')) |
|
|
853 |
|
|
854 for line in ReadDictionary: |
|
|
855 line = line.replace("s", "$") |
|
|
856 Word.append(line.replace('\n', '')) |
|
|
857 |
|
|
858 for line in ReadDictionary: |
|
|
859 line = line.replace("t", "7", 1) |
|
|
860 Word.append(line.replace('\n', '')) |
|
|
861 |
|
|
862 for line in ReadDictionary: |
|
|
863 line = line.replace("t", "7") |
|
|
864 Word.append(line.replace('\n', '')) |
|
|
865 |
|
|
866 for line in ReadDictionary: |
|
|
867 line = line.replace("t", "+", 1) |
|
|
868 Word.append(line.replace('\n', '')) |
|
|
869 |
|
|
870 for line in ReadDictionary: |
|
|
871 line = line.replace("t", "+") |
|
|
872 Word.append(line.replace('\n', '')) |
|
|
873 |
|
|
874 for line in ReadDictionary: |
|
|
875 line = line.replace("z", "2", 1) |
|
|
876 Word.append(line.replace('\n', '')) |
|
|
877 |
|
|
878 for line in ReadDictionary: |
|
|
879 line = line.replace("z", "2") |
|
|
880 Word.append(line.replace('\n', '')) |
|
|
881 |
|
|
882 for line in ReadDictionary: |
|
|
883 line = line.replace("a", "4") |
|
|
884 line = line.replace("b", "8") |
|
|
885 line = line.replace("e", "3") |
|
|
886 line = line.replace("f", "ph", 1) |
|
|
887 line = line.replace("g", "6") |
|
|
888 line = line.replace("h", "#") |
|
|
889 line = line.replace("i", "1") |
|
|
890 line = line.replace("l", "|") |
|
|
891 line = line.replace("k", "X") |
|
|
892 line = line.replace("o", "0") |
|
|
893 line = line.replace("s", "5") |
|
|
894 line = line.replace("t", "7") |
|
|
895 line = line.replace("z", "2") |
|
|
896 Word.append(line.replace('\n', '')) |
|
|
897 |
|
|
898 for line in ReadDictionary: |
|
|
899 line = line.replace("a", "^") |
|
|
900 line = line.replace("b", "8") |
|
|
901 line = line.replace("e", "3") |
|
|
902 line = line.replace("f", "ph", 1) |
|
|
903 line = line.replace("g", "6") |
|
|
904 line = line.replace("h", "#") |
|
|
905 line = line.replace("i", "1") |
|
|
906 line = line.replace("l", "|") |
|
|
907 line = line.replace("k", "X") |
|
|
908 line = line.replace("o", "0") |
|
|
909 line = line.replace("s", "5") |
|
|
910 line = line.replace("t", "7") |
|
|
911 line = line.replace("z", "2") |
|
|
912 Word.append(line.replace('\n', '')) |
|
|
913 |
|
|
914 for line in ReadDictionary: |
|
|
915 line = line.replace("a", "4") |
|
|
916 line = line.replace("b", "8") |
|
|
917 line = line.replace("e", "3") |
|
|
918 line = line.replace("f", "ph", 1) |
|
|
919 line = line.replace("g", "9") |
|
|
920 line = line.replace("h", "#") |
|
|
921 line = line.replace("i", "1") |
|
|
922 line = line.replace("l", "|") |
|
|
923 line = line.replace("k", "X") |
|
|
924 line = line.replace("o", "0") |
|
|
925 line = line.replace("s", "5") |
|
|
926 line = line.replace("t", "7") |
|
|
927 line = line.replace("z", "2") |
|
|
928 Word.append(line.replace('\n', '')) |
|
|
929 |
|
|
930 for line in ReadDictionary: |
|
|
931 line = line.replace("a", "^") |
|
|
932 line = line.replace("b", "8") |
|
|
933 line = line.replace("e", "3") |
|
|
934 line = line.replace("f", "ph", 1) |
|
|
935 line = line.replace("g", "9") |
|
|
936 line = line.replace("h", "#") |
|
|
937 line = line.replace("i", "1") |
|
|
938 line = line.replace("l", "|") |
|
|
939 line = line.replace("k", "X") |
|
|
940 line = line.replace("o", "0") |
|
|
941 line = line.replace("s", "5") |
|
|
942 line = line.replace("t", "7") |
|
|
943 line = line.replace("z", "2") |
|
|
944 Word.append(line.replace('\n', '')) |
|
|
945 |
|
|
946 for line in ReadDictionary: |
|
|
947 line = line.replace("a", "4") |
|
|
948 line = line.replace("b", "8") |
|
|
949 line = line.replace("e", "3") |
|
|
950 line = line.replace("f", "ph", 1) |
|
|
951 line = line.replace("g", "&") |
|
|
952 line = line.replace("h", "#") |
|
|
953 line = line.replace("i", "1") |
|
|
954 line = line.replace("l", "|") |
|
|
955 line = line.replace("k", "X") |
|
|
956 line = line.replace("o", "0") |
|
|
957 line = line.replace("s", "5") |
|
|
958 line = line.replace("t", "7") |
|
|
959 line = line.replace("z", "2") |
|
|
960 Word.append(line.replace('\n', '')) |
|
|
961 |
|
|
962 for line in ReadDictionary: |
|
|
963 line = line.replace("a", "^") |
|
|
964 line = line.replace("b", "8") |
|
|
965 line = line.replace("e", "3") |
|
|
966 line = line.replace("f", "ph", 1) |
|
|
967 line = line.replace("g", "&") |
|
|
968 line = line.replace("h", "#") |
|
|
969 line = line.replace("i", "1") |
|
|
970 line = line.replace("l", "|") |
|
|
971 line = line.replace("k", "X") |
|
|
972 line = line.replace("o", "0") |
|
|
973 line = line.replace("s", "5") |
|
|
974 line = line.replace("t", "7") |
|
|
975 line = line.replace("z", "2") |
|
|
976 Word.append(line.replace('\n', '')) |
|
|
977 |
|
|
978 for line in ReadDictionary: |
|
|
979 line = line.replace("a", "4") |
|
|
980 line = line.replace("b", "8") |
|
|
981 line = line.replace("e", "3") |
|
|
982 line = line.replace("f", "ph", 1) |
|
|
983 line = line.replace("g", "6") |
|
|
984 line = line.replace("h", "#") |
|
|
985 line = line.replace("i", "1") |
|
|
986 line = line.replace("l", "|") |
|
|
987 line = line.replace("k", "X") |
|
|
988 line = line.replace("o", "0") |
|
|
989 line = line.replace("s", "5") |
|
|
990 line = line.replace("t", "7") |
|
|
991 line = line.replace("z", "2") |
|
|
992 Word.append(line.replace('\n', '')) |
|
|
993 |
|
|
994 for line in ReadDictionary: |
|
|
995 line = line.replace("a", "^") |
|
|
996 line = line.replace("b", "8") |
|
|
997 line = line.replace("e", "3") |
|
|
998 line = line.replace("f", "ph", 1) |
|
|
999 line = line.replace("g", "6") |
|
|
1000 line = line.replace("h", "#") |
|
|
1001 line = line.replace("i", "1") |
|
|
1002 line = line.replace("l", "|") |
|
|
1003 line = line.replace("k", "X") |
|
|
1004 line = line.replace("o", "0") |
|
|
1005 line = line.replace("s", "5") |
|
|
1006 line = line.replace("t", "7") |
|
|
1007 line = line.replace("z", "2") |
|
|
1008 Word.append(line.replace('\n', '')) |
|
|
1009 |
|
|
1010 for line in ReadDictionary: |
|
|
1011 line = line.replace("a", "4") |
|
|
1012 line = line.replace("b", "8") |
|
|
1013 line = line.replace("e", "3") |
|
|
1014 line = line.replace("f", "ph", 1) |
|
|
1015 line = line.replace("g", "9") |
|
|
1016 line = line.replace("h", "#") |
|
|
1017 line = line.replace("i", "|") |
|
|
1018 line = line.replace("l", "1") |
|
|
1019 line = line.replace("k", "X") |
|
|
1020 line = line.replace("o", "0") |
|
|
1021 line = line.replace("s", "5") |
|
|
1022 line = line.replace("t", "7") |
|
|
1023 line = line.replace("z", "2") |
|
|
1024 Word.append(line.replace('\n', '')) |
|
|
1025 |
|
|
1026 for line in ReadDictionary: |
|
|
1027 line = line.replace("a", "^") |
|
|
1028 line = line.replace("b", "8") |
|
|
1029 line = line.replace("e", "3") |
|
|
1030 line = line.replace("f", "ph", 1) |
|
|
1031 line = line.replace("g", "9") |
|
|
1032 line = line.replace("h", "#") |
|
|
1033 line = line.replace("i", "|") |
|
|
1034 line = line.replace("l", "1") |
|
|
1035 line = line.replace("k", "X") |
|
|
1036 line = line.replace("o", "0") |
|
|
1037 line = line.replace("s", "5") |
|
|
1038 line = line.replace("t", "7") |
|
|
1039 line = line.replace("z", "2") |
|
|
1040 Word.append(line.replace('\n', '')) |
|
|
1041 |
|
|
1042 for line in ReadDictionary: |
|
|
1043 line = line.replace("a", "4") |
|
|
1044 line = line.replace("b", "8") |
|
|
1045 line = line.replace("e", "3") |
|
|
1046 line = line.replace("f", "ph", 1) |
|
|
1047 line = line.replace("g", "&") |
|
|
1048 line = line.replace("h", "#") |
|
|
1049 line = line.replace("i", "|") |
|
|
1050 line = line.replace("l", "1") |
|
|
1051 line = line.replace("k", "X") |
|
|
1052 line = line.replace("o", "0") |
|
|
1053 line = line.replace("s", "5") |
|
|
1054 line = line.replace("t", "7") |
|
|
1055 line = line.replace("z", "2") |
|
|
1056 Word.append(line.replace('\n', '')) |
|
|
1057 |
|
|
1058 for line in ReadDictionary: |
|
|
1059 line = line.replace("a", "^") |
|
|
1060 line = line.replace("b", "8") |
|
|
1061 line = line.replace("e", "3") |
|
|
1062 line = line.replace("f", "ph", 1) |
|
|
1063 line = line.replace("g", "&") |
|
|
1064 line = line.replace("h", "#") |
|
|
1065 line = line.replace("i", "|") |
|
|
1066 line = line.replace("l", "1") |
|
|
1067 line = line.replace("k", "X") |
|
|
1068 line = line.replace("o", "0") |
|
|
1069 line = line.replace("s", "5") |
|
|
1070 line = line.replace("t", "7") |
|
|
1071 line = line.replace("z", "2") |
|
|
1072 Word.append(line.replace('\n', '')) |
|
|
1073 |
|
|
1074 def BW(): |
|
|
1075 for line in ReadDictionary: |
|
|
1076 Word.append(line[::-1].replace('\n', '')) |
|
|
1077 |
|
|
1078 def CAPS(): |
|
|
1079 for line in ReadDictionary: |
|
|
1080 line = line.replace('\n', '') |
|
|
1081 up = 0 |
|
|
1082 a = "" |
|
|
1083 for let in line: |
|
|
1084 if up == 0: |
|
|
1085 a += let.upper() |
|
|
1086 else: |
|
|
1087 a += let |
|
|
1088 up ^= 1 |
|
|
1089 Word.append(a) |
|
|
1090 |
|
|
1091 for line in ReadDictionary: |
|
|
1092 line = line.replace('\n', '') |
|
|
1093 up = 0 |
|
|
1094 a = "" |
|
|
1095 for let in line: |
|
|
1096 if up == 1: |
|
|
1097 a += let.upper() |
|
|
1098 else: |
|
|
1099 a += let |
|
|
1100 up ^= 1 |
|
|
1101 Word.append(a) |
|
|
1102 |
|
|
1103 for line in ReadDictionary: |
|
|
1104 line = line.replace('\n', '') |
|
|
1105 up = 0 |
|
|
1106 a = "" |
|
|
1107 for let in line: |
|
|
1108 if up <= 1: |
|
|
1109 a += let.upper() |
|
|
1110 up = up + 1 |
|
|
1111 else: |
|
|
1112 a += let |
|
|
1113 up = up + 1 |
|
|
1114 Word.append(a) |
|
|
1115 |
|
|
1116 for line in ReadDictionary: |
|
|
1117 line = line.replace('\n', '') |
|
|
1118 up = 0 |
|
|
1119 a = "" |
|
|
1120 for let in line: |
|
|
1121 if up <= 2: |
|
|
1122 a += let.upper() |
|
|
1123 up = up + 1 |
|
|
1124 else: |
|
|
1125 a += let |
|
|
1126 up = up + 1 |
|
|
1127 Word.append(a) |
|
|
1128 |
|
|
1129 for line in ReadDictionary: |
|
|
1130 line = line.replace('\n', '') |
|
|
1131 a = 0 |
|
|
1132 b = 1 |
|
|
1133 c = "" |
|
|
1134 for let in line: |
|
|
1135 a = a + 1 |
|
|
1136 for let in line: |
|
|
1137 if a != b: |
|
|
1138 b = b + 1 |
|
|
1139 c += let |
|
|
1140 else: |
|
|
1141 c += let.upper() |
|
|
1142 Word.append(c) |
|
|
1143 |
|
|
1144 for line in ReadDictionary: |
|
|
1145 line = line.replace('\n', '') |
|
|
1146 a = 0 |
|
|
1147 b = 1 |
|
|
1148 c = "" |
|
|
1149 for let in line: |
|
|
1150 a = a + 1 |
|
|
1151 a = a - 1 |
|
|
1152 for let in line: |
|
|
1153 if b < a: |
|
|
1154 b = b + 1 |
|
|
1155 c += let |
|
|
1156 else: |
|
|
1157 c += let.upper() |
|
|
1158 Word.append(c) |
|
|
1159 |
|
|
1160 for line in ReadDictionary: |
|
|
1161 line = line.replace("a", "A", 1) |
|
|
1162 if line.__contains__("A"): |
|
|
1163 Word.append(line.replace('\n', '')) |
|
|
1164 |
|
|
1165 for line in ReadDictionary: |
|
|
1166 line = line.replace("a", "A") |
|
|
1167 if line.__contains__("A"): |
|
|
1168 Word.append(line.replace('\n', '')) |
|
|
1169 |
|
|
1170 for line in ReadDictionary: |
|
|
1171 line = line.replace("b", "B", 1) |
|
|
1172 if line.__contains__("B"): |
|
|
1173 Word.append(line.replace('\n', '')) |
|
|
1174 |
|
|
1175 for line in ReadDictionary: |
|
|
1176 line = line.replace("b", "B") |
|
|
1177 if line.__contains__("B"): |
|
|
1178 Word.append(line.replace('\n', '')) |
|
|
1179 |
|
|
1180 for line in ReadDictionary: |
|
|
1181 line = line.replace("c", "C", 1) |
|
|
1182 if line.__contains__("C"): |
|
|
1183 Word.append(line.replace('\n', '')) |
|
|
1184 |
|
|
1185 for line in ReadDictionary: |
|
|
1186 line = line.replace("c", "C") |
|
|
1187 if line.__contains__("C"): |
|
|
1188 Word.append(line.replace('\n', '')) |
|
|
1189 |
|
|
1190 for line in ReadDictionary: |
|
|
1191 line = line.replace("d", "D", 1) |
|
|
1192 if line.__contains__("D"): |
|
|
1193 Word.append(line.replace('\n', '')) |
|
|
1194 |
|
|
1195 for line in ReadDictionary: |
|
|
1196 line = line.replace("d", "D") |
|
|
1197 if line.__contains__("D"): |
|
|
1198 Word.append(line.replace('\n', '')) |
|
|
1199 |
|
|
1200 for line in ReadDictionary: |
|
|
1201 line = line.replace("e", "E", 1) |
|
|
1202 if line.__contains__("E"): |
|
|
1203 Word.append(line.replace('\n', '')) |
|
|
1204 |
|
|
1205 for line in ReadDictionary: |
|
|
1206 line = line.replace("e", "E") |
|
|
1207 if line.__contains__("E"): |
|
|
1208 Word.append(line.replace('\n', '')) |
|
|
1209 |
|
|
1210 for line in ReadDictionary: |
|
|
1211 line = line.replace("f", "F", 1) |
|
|
1212 if line.__contains__("F"): |
|
|
1213 Word.append(line.replace('\n', '')) |
|
|
1214 |
|
|
1215 for line in ReadDictionary: |
|
|
1216 line = line.replace("f", "F") |
|
|
1217 if line.__contains__("F"): |
|
|
1218 Word.append(line.replace('\n', '')) |
|
|
1219 |
|
|
1220 for line in ReadDictionary: |
|
|
1221 line = line.replace("g", "G", 1) |
|
|
1222 if line.__contains__("G"): |
|
|
1223 Word.append(line.replace('\n', '')) |
|
|
1224 |
|
|
1225 for line in ReadDictionary: |
|
|
1226 line = line.replace("g", "G") |
|
|
1227 if line.__contains__("G"): |
|
|
1228 Word.append(line.replace('\n', '')) |
|
|
1229 |
|
|
1230 for line in ReadDictionary: |
|
|
1231 line = line.replace("h", "H", 1) |
|
|
1232 if line.__contains__("H"): |
|
|
1233 Word.append(line.replace('\n', '')) |
|
|
1234 |
|
|
1235 for line in ReadDictionary: |
|
|
1236 line = line.replace("h", "H") |
|
|
1237 if line.__contains__("H"): |
|
|
1238 Word.append(line.replace('\n', '')) |
|
|
1239 |
|
|
1240 for line in ReadDictionary: |
|
|
1241 line = line.replace("i", "I", 1) |
|
|
1242 if line.__contains__("I"): |
|
|
1243 Word.append(line.replace('\n', '')) |
|
|
1244 |
|
|
1245 for line in ReadDictionary: |
|
|
1246 line = line.replace("i", "I") |
|
|
1247 if line.__contains__("I"): |
|
|
1248 Word.append(line.replace('\n', '')) |
|
|
1249 |
|
|
1250 for line in ReadDictionary: |
|
|
1251 line = line.replace("j", "J", 1) |
|
|
1252 if line.__contains__("J"): |
|
|
1253 Word.append(line.replace('\n', '')) |
|
|
1254 |
|
|
1255 for line in ReadDictionary: |
|
|
1256 line = line.replace("j", "J") |
|
|
1257 if line.__contains__("J"): |
|
|
1258 Word.append(line.replace('\n', '')) |
|
|
1259 |
|
|
1260 for line in ReadDictionary: |
|
|
1261 line = line.replace("k", "K", 1) |
|
|
1262 if line.__contains__("K"): |
|
|
1263 Word.append(line.replace('\n', '')) |
|
|
1264 |
|
|
1265 for line in ReadDictionary: |
|
|
1266 line = line.replace("k", "K") |
|
|
1267 if line.__contains__("K"): |
|
|
1268 Word.append(line.replace('\n', '')) |
|
|
1269 |
|
|
1270 for line in ReadDictionary: |
|
|
1271 line = line.replace("l", "L", 1) |
|
|
1272 if line.__contains__("L"): |
|
|
1273 Word.append(line.replace('\n', '')) |
|
|
1274 |
|
|
1275 for line in ReadDictionary: |
|
|
1276 line = line.replace("l", "L") |
|
|
1277 if line.__contains__("L"): |
|
|
1278 Word.append(line.replace('\n', '')) |
|
|
1279 |
|
|
1280 for line in ReadDictionary: |
|
|
1281 line = line.replace("m", "M", 1) |
|
|
1282 if line.__contains__("M"): |
|
|
1283 Word.append(line.replace('\n', '')) |
|
|
1284 |
|
|
1285 for line in ReadDictionary: |
|
|
1286 line = line.replace("m", "M") |
|
|
1287 if line.__contains__("M"): |
|
|
1288 Word.append(line.replace('\n', '')) |
|
|
1289 |
|
|
1290 for line in ReadDictionary: |
|
|
1291 line = line.replace("n", "N", 1) |
|
|
1292 if line.__contains__("N"): |
|
|
1293 Word.append(line.replace('\n', '')) |
|
|
1294 |
|
|
1295 for line in ReadDictionary: |
|
|
1296 line = line.replace("n", "N") |
|
|
1297 if line.__contains__("N"): |
|
|
1298 Word.append(line.replace('\n', '')) |
|
|
1299 |
|
|
1300 for line in ReadDictionary: |
|
|
1301 line = line.replace("o", "O", 1) |
|
|
1302 if line.__contains__("O"): |
|
|
1303 Word.append(line.replace('\n', '')) |
|
|
1304 |
|
|
1305 for line in ReadDictionary: |
|
|
1306 line = line.replace("o", "O") |
|
|
1307 if line.__contains__("O"): |
|
|
1308 Word.append(line.replace('\n', '')) |
|
|
1309 |
|
|
1310 for line in ReadDictionary: |
|
|
1311 line = line.replace("p", "P", 1) |
|
|
1312 if line.__contains__("P"): |
|
|
1313 Word.append(line.replace('\n', '')) |
|
|
1314 |
|
|
1315 for line in ReadDictionary: |
|
|
1316 line = line.replace("p", "P") |
|
|
1317 if line.__contains__("P"): |
|
|
1318 Word.append(line.replace('\n', '')) |
|
|
1319 |
|
|
1320 for line in ReadDictionary: |
|
|
1321 line = line.replace("q", "Q", 1) |
|
|
1322 if line.__contains__("Q"): |
|
|
1323 Word.append(line.replace('\n', '')) |
|
|
1324 |
|
|
1325 for line in ReadDictionary: |
|
|
1326 line = line.replace("q", "Q") |
|
|
1327 if line.__contains__("Q"): |
|
|
1328 Word.append(line.replace('\n', '')) |
|
|
1329 |
|
|
1330 for line in ReadDictionary: |
|
|
1331 line = line.replace("r", "R", 1) |
|
|
1332 if line.__contains__("R"): |
|
|
1333 Word.append(line.replace('\n', '')) |
|
|
1334 |
|
|
1335 for line in ReadDictionary: |
|
|
1336 line = line.replace("r", "R") |
|
|
1337 if line.__contains__("R"): |
|
|
1338 Word.append(line.replace('\n', '')) |
|
|
1339 |
|
|
1340 for line in ReadDictionary: |
|
|
1341 line = line.replace("s", "S", 1) |
|
|
1342 if line.__contains__("S"): |
|
|
1343 Word.append(line.replace('\n', '')) |
|
|
1344 |
|
|
1345 for line in ReadDictionary: |
|
|
1346 line = line.replace("s", "S") |
|
|
1347 if line.__contains__("S"): |
|
|
1348 Word.append(line.replace('\n', '')) |
|
|
1349 |
|
|
1350 for line in ReadDictionary: |
|
|
1351 line = line.replace("t", "T", 1) |
|
|
1352 if line.__contains__("T"): |
|
|
1353 Word.append(line.replace('\n', '')) |
|
|
1354 |
|
|
1355 for line in ReadDictionary: |
|
|
1356 line = line.replace("t", "T") |
|
|
1357 if line.__contains__("T"): |
|
|
1358 Word.append(line.replace('\n', '')) |
|
|
1359 |
|
|
1360 for line in ReadDictionary: |
|
|
1361 line = line.replace("u", "U", 1) |
|
|
1362 if line.__contains__("U"): |
|
|
1363 Word.append(line.replace('\n', '')) |
|
|
1364 |
|
|
1365 for line in ReadDictionary: |
|
|
1366 line = line.replace("u", "U") |
|
|
1367 if line.__contains__("U"): |
|
|
1368 Word.append(line.replace('\n', '')) |
|
|
1369 |
|
|
1370 for line in ReadDictionary: |
|
|
1371 line = line.replace("v", "V", 1) |
|
|
1372 if line.__contains__("V"): |
|
|
1373 Word.append(line.replace('\n', '')) |
|
|
1374 |
|
|
1375 for line in ReadDictionary: |
|
|
1376 line = line.replace("v", "V") |
|
|
1377 if line.__contains__("V"): |
|
|
1378 Word.append(line.replace('\n', '')) |
|
|
1379 |
|
|
1380 for line in ReadDictionary: |
|
|
1381 line = line.replace("w", "W", 1) |
|
|
1382 if line.__contains__("W"): |
|
|
1383 Word.append(line.replace('\n', '')) |
|
|
1384 |
|
|
1385 for line in ReadDictionary: |
|
|
1386 line = line.replace("w", "W") |
|
|
1387 if line.__contains__("W"): |
|
|
1388 Word.append(line.replace('\n', '')) |
|
|
1389 |
|
|
1390 for line in ReadDictionary: |
|
|
1391 line = line.replace("x", "X", 1) |
|
|
1392 if line.__contains__("X"): |
|
|
1393 Word.append(line.replace('\n', '')) |
|
|
1394 |
|
|
1395 for line in ReadDictionary: |
|
|
1396 line = line.replace("x", "X") |
|
|
1397 if line.__contains__("X"): |
|
|
1398 Word.append(line.replace('\n', '')) |
|
|
1399 |
|
|
1400 for line in ReadDictionary: |
|
|
1401 line = line.replace("y", "Y", 1) |
|
|
1402 if line.__contains__("Y"): |
|
|
1403 Word.append(line.replace('\n', '')) |
|
|
1404 |
|
|
1405 for line in ReadDictionary: |
|
|
1406 line = line.replace("y", "Y") |
|
|
1407 if line.__contains__("Y"): |
|
|
1408 Word.append(line.replace('\n', '')) |
|
|
1409 |
|
|
1410 for line in ReadDictionary: |
|
|
1411 line = line.replace("z", "Z", 1) |
|
|
1412 if line.__contains__("Z"): |
|
|
1413 Word.append(line.replace('\n', '')) |
|
|
1414 |
|
|
1415 for line in ReadDictionary: |
|
|
1416 line = line.replace("z", "Z") |
|
|
1417 if line.__contains__("Z"): |
|
|
1418 Word.append(line.replace('\n', '')) |
|
|
1419 |
|
|
1420 def MIX(): |
|
|
1421 for Input in MixChars: |
|
|
1422 for line in ReadDictionary: |
|
|
1423 line = line.replace('\n', '') |
|
|
1424 up = 0 |
|
|
1425 a = "" |
|
|
1426 for let in line: |
|
|
1427 if up <= 1: |
|
|
1428 a += let + Input |
|
|
1429 up = up + 1 |
|
|
1430 else: |
|
|
1431 a += let |
|
|
1432 up = up + 1 |
|
|
1433 Word.append(a) |
|
|
1434 |
|
|
1435 for Input in MixChars: |
|
|
1436 for Input2 in MixChars: |
|
|
1437 for line in ReadDictionary: |
|
|
1438 line = line.replace('\n', '') |
|
|
1439 up = 0 |
|
|
1440 a = "" |
|
|
1441 for let in line: |
|
|
1442 if up == 1: |
|
|
1443 a += Input + let + Input2 |
|
|
1444 up = up + 1 |
|
|
1445 else: |
|
|
1446 a += let |
|
|
1447 up = up + 1 |
|
|
1448 Word.append(a) |
|
|
1449 |
|
|
1450 for Input in MixChars: |
|
|
1451 for line in ReadDictionary: |
|
|
1452 line = line.replace('\n', '') |
|
|
1453 a = 0 |
|
|
1454 b = 1 |
|
|
1455 c = "" |
|
|
1456 for let in line: |
|
|
1457 a = a + 1 |
|
|
1458 for let in line: |
|
|
1459 if a != b: |
|
|
1460 b = b + 1 |
|
|
1461 c += let |
|
|
1462 else: |
|
|
1463 c += Input + let |
|
|
1464 Word.append(c) |
|
|
1465 |
|
|
1466 for Input in MixChars: |
|
|
1467 for Input2 in MixChars: |
|
|
1468 for line in ReadDictionary: |
|
|
1469 line = line.replace('\n', '') |
|
|
1470 a = 0 |
|
|
1471 b = 0 |
|
|
1472 c = "" |
|
|
1473 for let in line: |
|
|
1474 a = a + 1 |
|
|
1475 a = a - 2 |
|
|
1476 for let in line: |
|
|
1477 if b == a: |
|
|
1478 b = b + 1 |
|
|
1479 c += Input + let + Input2 |
|
|
1480 else: |
|
|
1481 c += let |
|
|
1482 b = b + 1 |
|
|
1483 Word.append(c) |
|
|
1484 |
|
|
1485 def MD5(): |
|
|
1486 for line in ReadDictionary: |
|
|
1487 Word.append(md5(line.replace('\n', '')).hexdigest()) |
|
|
1488 |
|
|
1489 def WEP5(): |
|
|
1490 for line in ReadDictionary: |
|
|
1491 i = 0 |
|
|
1492 for let in line: |
|
|
1493 i += 1 |
|
|
1494 i -= 1 |
|
|
1495 if i == 5: |
|
|
1496 line = line.encode('hex') |
|
|
1497 line = line.replace('\n', '') |
|
|
1498 Word.append(line.replace('0a', '')) |
|
|
1499 |
|
|
1500 def WEP13(): |
|
|
1501 for line in ReadDictionary: |
|
|
1502 i = 0 |
|
|
1503 for let in line: |
|
|
1504 i += 1 |
|
|
1505 i -= 1 |
|
|
1506 if i == 13: |
|
|
1507 line = line.encode('hex') |
|
|
1508 line = line.replace('\n', '') |
|
|
1509 Word.append(line.replace('0a', '')) |
|
|
1510 |
|
|
1511 |
|
|
1512 def SOCEN(): |
|
|
1513 socen = [] |
|
|
1514 socen_a = [] |
|
|
1515 socen_words = [] |
|
|
1516 |
|
|
1517 try: |
|
|
1518 for i in Word: |
|
|
1519 socen_words.append(i.replace('\n', '')) |
|
|
1520 except: |
|
|
1521 pass |
|
|
1522 |
|
|
1523 for line in ReadDictionary: |
|
|
1524 socen_words.append(line.replace('\n', '')) |
|
|
1525 socen_words = list(set(socen_words)) |
|
|
1526 |
|
|
1527 for i in socen_words: |
|
|
1528 for let in i: |
|
|
1529 try: |
|
|
1530 let += 1 |
|
|
1531 break |
|
|
1532 except: |
|
|
1533 socen_a.append(let) |
|
|
1534 break |
|
|
1535 |
|
|
1536 for a in socen_a: |
|
|
1537 socen_words.append(a) |
|
|
1538 |
|
|
1539 for a in socen_words: |
|
|
1540 x = 0 |
|
|
1541 for let in a: |
|
|
1542 x += 1 |
|
|
1543 if x > 1: |
|
|
1544 Word.append(a) |
|
|
1545 |
|
|
1546 for a in socen_words: |
|
|
1547 for b in socen_words: |
|
|
1548 x = 0 |
|
|
1549 for let in a: |
|
|
1550 x += 1 |
|
|
1551 n = 0 |
|
|
1552 for let in b: |
|
|
1553 n += 1 |
|
|
1554 if x > 1 or n > 1 and a != b: |
|
|
1555 Word.append(a + b) |
|
|
1556 |
|
|
1557 for a in socen_words: |
|
|
1558 for b in socen_words: |
|
|
1559 for c in socen_words: |
|
|
1560 if a != b and a != c and b != c: |
|
|
1561 Word.append(a + b + c) |
|
|
1562 |
|
|
1563 |
|
|
1564 if RegularSwitch is True: |
|
|
1565 REGULAR() |
|
|
1566 if BWSwitch is True: |
|
|
1567 BW() |
|
|
1568 if CapsSwitch is True: |
|
|
1569 CAPS() |
|
|
1570 if L337Switch is True: |
|
|
1571 L337() |
|
|
1572 if MD5Switch is True: |
|
|
1573 MD5() |
|
|
1574 if wep5 is True: |
|
|
1575 WEP5() |
|
|
1576 if wep13 is True: |
|
|
1577 WEP13() |
|
|
1578 if SESwitch is True: |
|
|
1579 SOCEN() |
|
|
1580 |
|
|
1581 DoMix = False |
|
|
1582 if AlphaSwitch is True: |
|
|
1583 DoMix = True |
|
|
1584 if NumberSwitch is True: |
|
|
1585 DoMix = True |
|
|
1586 if SpecialSwitch is True: |
|
|
1587 DoMix = True |
|
|
1588 if MixCustom != None and MixCustom != "None": |
|
|
1589 DoMix = True |
|
|
1590 if DoMix is True: |
|
|
1591 MIX() |
|
|
1592 |
|
|
1593 User = [] |
|
|
1594 if UserSwitch == True: |
|
|
1595 UserCount = 0 |
|
|
1596 ReadUsernames = open(usernames, 'r') |
|
|
1597 for line in ReadUsernames: |
|
|
1598 User.append(line.replace('\n', '')) |
|
|
1599 UserCount += 1 |
|
|
1600 else: |
|
|
1601 User.append("") |
|
|
1602 UserCount = 1 |
|
|
1603 |
|
|
1604 if not Word: |
|
689
|
1605 sys.exit(SpliceX + "error: compiled empty wordlist") |
|
688
|
1606 |
|
|
1607 Word = list(set(Word)) |
|
|
1608 WordCount = 0 |
|
|
1609 ShowWord = [] |
|
|
1610 PassWd = [] |
|
|
1611 for Input in Word: |
|
|
1612 ShowWord.append(Input) |
|
|
1613 c = "" |
|
|
1614 for let in Input: |
|
|
1615 c += "\\\\\\" + let |
|
|
1616 PassWd.append(c) |
|
|
1617 |
|
|
1618 |
|
|
1619 if TIME != None: |
|
|
1620 try: |
|
|
1621 TIME = TIME.split(", ") |
|
|
1622 sleep_now = int(TIME[0]) |
|
|
1623 sleep_for = int(TIME[1]) |
|
|
1624 |
|
|
1625 except: |
|
689
|
1626 sys.exit(SpliceX + "error: invalid --time arguments") |
|
688
|
1627 |
|
|
1628 else: |
|
|
1629 sleep_now = 0 |
|
|
1630 sleep_for = 0 |
|
|
1631 |
|
|
1632 if LENGTH != None: |
|
|
1633 try: |
|
|
1634 LENGTH = LENGTH.split(", ") |
|
|
1635 length_start = int(LENGTH[0]) |
|
|
1636 length_end = int(LENGTH[1]) |
|
|
1637 if length_end > 10: |
|
|
1638 length_end = 10 |
|
|
1639 if ExhSwitch is True: |
|
|
1640 length_start -= 1 |
|
|
1641 length_end -= 1 |
|
|
1642 |
|
|
1643 except: |
|
689
|
1644 sys.exit(SpliceX + " error: invalid --char-length arguments") |
|
688
|
1645 |
|
|
1646 else: |
|
|
1647 length_start = 0 |
|
|
1648 length_end = 10 |
|
|
1649 |
|
|
1650 def BF1(): |
|
|
1651 WordCount = 0 |
|
|
1652 for CountWords in ShowWord: |
|
|
1653 WordCount += 1 |
|
|
1654 StartTime = time.time() |
|
|
1655 StartTime = StartTime - 1 |
|
|
1656 PassAmount = 0 |
|
|
1657 timeup = 0 |
|
|
1658 for u in range(StateU, UserCount): |
|
|
1659 if length_start > 0: |
|
|
1660 break |
|
|
1661 if length_end < 0: |
|
689
|
1662 sys.exit(SpliceX + 'unable to find password') |
|
688
|
1663 for x in range(StateW, WordCount): |
|
|
1664 if SaveSwitch is True: |
|
|
1665 WriteSave = [] |
|
|
1666 FILE = open(save, 'w') |
|
|
1667 WriteSave.append(str(cmd)) |
|
|
1668 WriteSave.append(str(dictionary)) |
|
|
1669 WriteSave.append(str(MixCustom)) |
|
|
1670 WriteSave.append(str(Custom)) |
|
|
1671 WriteSave.append(str(ExhSwitch)) |
|
|
1672 WriteSave.append(str(StdoutSwitch)) |
|
|
1673 WriteSave.append(str(usernames)) |
|
|
1674 WriteSave.append(str(UserSwitch)) |
|
|
1675 WriteSave.append(str(AlphaSwitch)) |
|
|
1676 WriteSave.append(str(BWSwitch)) |
|
|
1677 WriteSave.append(str(CapsSwitch)) |
|
|
1678 WriteSave.append(str(L337Switch)) |
|
|
1679 WriteSave.append(str(MD5Switch)) |
|
|
1680 WriteSave.append(str(NumberSwitch)) |
|
|
1681 WriteSave.append(str(RegularSwitch)) |
|
|
1682 WriteSave.append(str(SpecialSwitch)) |
|
|
1683 WriteSave.append(str(Letters)) |
|
|
1684 WriteSave.append(str(Numbers)) |
|
|
1685 WriteSave.append(str(Specials)) |
|
|
1686 WriteSave.append(str(wep5)) |
|
|
1687 WriteSave.append(str(wep13)) |
|
|
1688 WriteSave.append(str(SESwitch)) |
|
|
1689 WriteSave.append(str(u)) |
|
|
1690 WriteSave.append(str(x)) |
|
|
1691 for WriteStates in WriteSave: |
|
|
1692 FILE.write(WriteStates + "\n") |
|
|
1693 FILE.close() |
|
|
1694 PassAmount += 1 |
|
|
1695 Timer = int(round(float(time.time() - StartTime))) |
|
|
1696 Speed = PassAmount / Timer |
|
|
1697 NewShowWord = ShowWord[x] |
|
|
1698 NewPassWd = PassWd[x] |
|
|
1699 timeup += 1 |
|
|
1700 if timeup == sleep_now: |
|
|
1701 time.sleep(sleep_for) |
|
|
1702 timeup = 0 |
|
689
|
1703 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
1704 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
1705 if test == None: |
|
|
1706 print(output) |
|
|
1707 elif output.__contains__(test): |
|
|
1708 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
1709 else: |
|
|
1710 print(output) |
|
|
1711 |
|
|
1712 def BF2(): |
|
|
1713 if NoChar is True: |
|
689
|
1714 sys.exit(SpliceX + 'unable to find password') |
|
688
|
1715 WordCount = 0 |
|
|
1716 for CountWords in ShowWord: |
|
|
1717 WordCount += 1 |
|
|
1718 StartTime = time.time() |
|
|
1719 StartTime = StartTime - 1 |
|
|
1720 PassAmount = 0 |
|
|
1721 timeup = 0 |
|
|
1722 for u in range(StateU, UserCount): |
|
|
1723 if length_start > 1: |
|
|
1724 break |
|
|
1725 if length_end < 1: |
|
689
|
1726 sys.exit(SpliceX + 'unable to find password') |
|
688
|
1727 for a in range(StateA, EndCount): |
|
|
1728 for x in range(StateW, WordCount): |
|
|
1729 if SaveSwitch is True: |
|
|
1730 WriteSave = [] |
|
|
1731 FILE = open(save, 'w') |
|
|
1732 WriteSave.append(str(cmd)) |
|
|
1733 WriteSave.append(str(dictionary)) |
|
|
1734 WriteSave.append(str(MixCustom)) |
|
|
1735 WriteSave.append(str(Custom)) |
|
|
1736 WriteSave.append(str(ExhSwitch)) |
|
|
1737 WriteSave.append(str(StdoutSwitch)) |
|
|
1738 WriteSave.append(str(usernames)) |
|
|
1739 WriteSave.append(str(UserSwitch)) |
|
|
1740 WriteSave.append(str(AlphaSwitch)) |
|
|
1741 WriteSave.append(str(BWSwitch)) |
|
|
1742 WriteSave.append(str(CapsSwitch)) |
|
|
1743 WriteSave.append(str(L337Switch)) |
|
|
1744 WriteSave.append(str(MD5Switch)) |
|
|
1745 WriteSave.append(str(NumberSwitch)) |
|
|
1746 WriteSave.append(str(RegularSwitch)) |
|
|
1747 WriteSave.append(str(SpecialSwitch)) |
|
|
1748 WriteSave.append(str(Letters)) |
|
|
1749 WriteSave.append(str(Numbers)) |
|
|
1750 WriteSave.append(str(Specials)) |
|
|
1751 WriteSave.append(str(wep5)) |
|
|
1752 WriteSave.append(str(wep13)) |
|
|
1753 WriteSave.append(str(SESwitch)) |
|
|
1754 WriteSave.append(str(u)) |
|
|
1755 WriteSave.append(str(x)) |
|
|
1756 WriteSave.append(str(a)) |
|
|
1757 for WriteStates in WriteSave: |
|
|
1758 FILE.write(WriteStates + "\n") |
|
|
1759 FILE.close() |
|
|
1760 PassAmount += 1 |
|
|
1761 Timer = int(round(float(time.time() - StartTime))) |
|
|
1762 Speed = PassAmount / Timer |
|
|
1763 NewShowWord = Char1[a] + ShowWord[x] |
|
|
1764 NewPassWd = Char2[a] + PassWd[x] |
|
|
1765 timeup += 1 |
|
|
1766 if timeup == sleep_now: |
|
|
1767 time.sleep(sleep_for) |
|
|
1768 timeup = 0 |
|
689
|
1769 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
1770 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
1771 if test == None: |
|
|
1772 print(output) |
|
|
1773 elif output.__contains__(test): |
|
|
1774 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
1775 else: |
|
|
1776 print(output) |
|
|
1777 |
|
|
1778 if ExhSwitch is False: |
|
|
1779 PassAmount += 1 |
|
|
1780 Timer = int(round(float(time.time() - StartTime))) |
|
|
1781 Speed = PassAmount / Timer |
|
|
1782 NewShowWord = ShowWord[x] + Char1[a] |
|
|
1783 NewPassWd = PassWd[x] + Char2[a] |
|
|
1784 timeup += 1 |
|
|
1785 if timeup == sleep_now: |
|
|
1786 time.sleep(sleep_for) |
|
|
1787 timeup = 0 |
|
689
|
1788 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
1789 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
1790 if test == None: |
|
|
1791 print(output) |
|
|
1792 elif output.__contains__(test): |
|
|
1793 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
1794 else: |
|
|
1795 print(output) |
|
|
1796 |
|
|
1797 def BF3(): |
|
|
1798 if NoChar is True: |
|
689
|
1799 sys.exit(SpliceX + 'unable to find password') |
|
688
|
1800 WordCount = 0 |
|
|
1801 for CountWords in ShowWord: |
|
|
1802 WordCount += 1 |
|
|
1803 StartTime = time.time() |
|
|
1804 StartTime = StartTime - 1 |
|
|
1805 PassAmount = 0 |
|
|
1806 timeup = 0 |
|
|
1807 for u in range(StateU, UserCount): |
|
|
1808 if length_start > 2: |
|
|
1809 break |
|
|
1810 if length_end < 2: |
|
689
|
1811 sys.exit(SpliceX + 'unable to find password') |
|
688
|
1812 for a in range(StateA, EndCount): |
|
|
1813 for b in range(StateB, EndCount): |
|
|
1814 for x in range(StateW, WordCount): |
|
|
1815 if SaveSwitch is True: |
|
|
1816 WriteSave = [] |
|
|
1817 FILE = open(save, 'w') |
|
|
1818 WriteSave.append(str(cmd)) |
|
|
1819 WriteSave.append(str(dictionary)) |
|
|
1820 WriteSave.append(str(MixCustom)) |
|
|
1821 WriteSave.append(str(Custom)) |
|
|
1822 WriteSave.append(str(ExhSwitch)) |
|
|
1823 WriteSave.append(str(StdoutSwitch)) |
|
|
1824 WriteSave.append(str(usernames)) |
|
|
1825 WriteSave.append(str(UserSwitch)) |
|
|
1826 WriteSave.append(str(AlphaSwitch)) |
|
|
1827 WriteSave.append(str(BWSwitch)) |
|
|
1828 WriteSave.append(str(CapsSwitch)) |
|
|
1829 WriteSave.append(str(L337Switch)) |
|
|
1830 WriteSave.append(str(MD5Switch)) |
|
|
1831 WriteSave.append(str(NumberSwitch)) |
|
|
1832 WriteSave.append(str(RegularSwitch)) |
|
|
1833 WriteSave.append(str(SpecialSwitch)) |
|
|
1834 WriteSave.append(str(Letters)) |
|
|
1835 WriteSave.append(str(Numbers)) |
|
|
1836 WriteSave.append(str(Specials)) |
|
|
1837 WriteSave.append(str(wep5)) |
|
|
1838 WriteSave.append(str(wep13)) |
|
|
1839 WriteSave.append(str(SESwitch)) |
|
|
1840 WriteSave.append(str(u)) |
|
|
1841 WriteSave.append(str(x)) |
|
|
1842 WriteSave.append(str(a)) |
|
|
1843 WriteSave.append(str(b)) |
|
|
1844 for WriteStates in WriteSave: |
|
|
1845 FILE.write(WriteStates + "\n") |
|
|
1846 FILE.close() |
|
|
1847 PassAmount += 1 |
|
|
1848 Timer = int(round(float(time.time() - StartTime))) |
|
|
1849 Speed = PassAmount / Timer |
|
|
1850 NewShowWord = Char1[a] + ShowWord[x] + Char1[b] |
|
|
1851 NewPassWd = Char2[a] + PassWd[x] + Char2[b] |
|
|
1852 timeup += 1 |
|
|
1853 if timeup == sleep_now: |
|
|
1854 time.sleep(sleep_for) |
|
|
1855 timeup = 0 |
|
689
|
1856 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
1857 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
1858 if test == None: |
|
|
1859 print(output) |
|
|
1860 elif output.__contains__(test): |
|
|
1861 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
1862 else: |
|
|
1863 print(output) |
|
|
1864 |
|
|
1865 if ExhSwitch is False: |
|
|
1866 PassAmount += 1 |
|
|
1867 Timer = int(round(float(time.time() - StartTime))) |
|
|
1868 Speed = PassAmount / Timer |
|
|
1869 NewShowWord = Char1[a] + Char1[b] + ShowWord[x] |
|
|
1870 NewPassWd = Char2[a] + Char2[b] + PassWd[x] |
|
|
1871 timeup += 1 |
|
|
1872 if timeup == sleep_now: |
|
|
1873 time.sleep(sleep_for) |
|
|
1874 timeup = 0 |
|
689
|
1875 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
1876 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
1877 if test == None: |
|
|
1878 print(output) |
|
|
1879 elif output.__contains__(test): |
|
|
1880 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
1881 else: |
|
|
1882 print(output) |
|
|
1883 |
|
|
1884 PassAmount += 1 |
|
|
1885 Timer = int(round(float(time.time() - StartTime))) |
|
|
1886 Speed = PassAmount / Timer |
|
|
1887 NewShowWord = ShowWord[x] + Char1[b] + Char1[a] |
|
|
1888 NewPassWd = PassWd[x] + Char2[b] + Char2[a] |
|
|
1889 timeup += 1 |
|
|
1890 if timeup == sleep_now: |
|
|
1891 time.sleep(sleep_for) |
|
|
1892 timeup = 0 |
|
689
|
1893 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
1894 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
1895 if test == None: |
|
|
1896 print(output) |
|
|
1897 elif output.__contains__(test): |
|
|
1898 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
1899 else: |
|
|
1900 print(output) |
|
|
1901 |
|
|
1902 def BF4(): |
|
|
1903 if NoChar is True: |
|
689
|
1904 sys.exit(SpliceX + 'unable to find password') |
|
688
|
1905 WordCount = 0 |
|
|
1906 for CountWords in ShowWord: |
|
|
1907 WordCount += 1 |
|
|
1908 StartTime = time.time() |
|
|
1909 StartTime = StartTime - 1 |
|
|
1910 PassAmount = 0 |
|
|
1911 timeup = 0 |
|
|
1912 for u in range(StateU, UserCount): |
|
|
1913 if length_start > 3: |
|
|
1914 break |
|
|
1915 if length_end < 3: |
|
689
|
1916 sys.exit(SpliceX + 'unable to find password') |
|
688
|
1917 for a in range(StateA, EndCount): |
|
|
1918 for b in range(StateB, EndCount): |
|
|
1919 for c in range(StateC, EndCount): |
|
|
1920 for x in range(StateW, WordCount): |
|
|
1921 if SaveSwitch is True: |
|
|
1922 WriteSave = [] |
|
|
1923 FILE = open(save, 'w') |
|
|
1924 WriteSave.append(str(cmd)) |
|
|
1925 WriteSave.append(str(dictionary)) |
|
|
1926 WriteSave.append(str(MixCustom)) |
|
|
1927 WriteSave.append(str(Custom)) |
|
|
1928 WriteSave.append(str(ExhSwitch)) |
|
|
1929 WriteSave.append(str(StdoutSwitch)) |
|
|
1930 WriteSave.append(str(usernames)) |
|
|
1931 WriteSave.append(str(UserSwitch)) |
|
|
1932 WriteSave.append(str(AlphaSwitch)) |
|
|
1933 WriteSave.append(str(BWSwitch)) |
|
|
1934 WriteSave.append(str(CapsSwitch)) |
|
|
1935 WriteSave.append(str(L337Switch)) |
|
|
1936 WriteSave.append(str(MD5Switch)) |
|
|
1937 WriteSave.append(str(NumberSwitch)) |
|
|
1938 WriteSave.append(str(RegularSwitch)) |
|
|
1939 WriteSave.append(str(SpecialSwitch)) |
|
|
1940 WriteSave.append(str(Letters)) |
|
|
1941 WriteSave.append(str(Numbers)) |
|
|
1942 WriteSave.append(str(Specials)) |
|
|
1943 WriteSave.append(str(wep5)) |
|
|
1944 WriteSave.append(str(wep13)) |
|
|
1945 WriteSave.append(str(SESwitch)) |
|
|
1946 WriteSave.append(str(u)) |
|
|
1947 WriteSave.append(str(x)) |
|
|
1948 WriteSave.append(str(a)) |
|
|
1949 WriteSave.append(str(b)) |
|
|
1950 WriteSave.append(str(c)) |
|
|
1951 for WriteStates in WriteSave: |
|
|
1952 FILE.write(WriteStates + "\n") |
|
|
1953 FILE.close() |
|
|
1954 PassAmount += 1 |
|
|
1955 Timer = int(round(float(time.time() - StartTime))) |
|
|
1956 Speed = PassAmount / Timer |
|
|
1957 NewShowWord = Char1[c] + Char1[a] + ShowWord[x] + Char1[b] |
|
|
1958 NewPassWd = Char2[c] + Char2[a] + PassWd[x] + Char2[b] |
|
|
1959 timeup += 1 |
|
|
1960 if timeup == sleep_now: |
|
|
1961 time.sleep(sleep_for) |
|
|
1962 timeup = 0 |
|
689
|
1963 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
1964 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
1965 if test == None: |
|
|
1966 print(output) |
|
|
1967 elif output.__contains__(test): |
|
|
1968 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
1969 else: |
|
|
1970 print(output) |
|
|
1971 |
|
|
1972 if ExhSwitch is False: |
|
|
1973 PassAmount += 1 |
|
|
1974 Timer = int(round(float(time.time() - StartTime))) |
|
|
1975 Speed = PassAmount / Timer |
|
|
1976 NewShowWord = Char1[b] + ShowWord[x] + Char1[a] + Char1[c] |
|
|
1977 NewPassWd = Char2[b] + PassWd[x] + Char2[a] + Char2[c] |
|
|
1978 timeup += 1 |
|
|
1979 if timeup == sleep_now: |
|
|
1980 time.sleep(sleep_for) |
|
|
1981 timeup = 0 |
|
689
|
1982 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
1983 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
1984 if test == None: |
|
|
1985 print(output) |
|
|
1986 elif output.__contains__(test): |
|
|
1987 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
1988 else: |
|
|
1989 print(output) |
|
|
1990 |
|
|
1991 PassAmount += 1 |
|
|
1992 Timer = int(round(float(time.time() - StartTime))) |
|
|
1993 Speed = PassAmount / Timer |
|
|
1994 NewShowWord = Char1[c] + Char1[a] + Char1[b] + ShowWord[x] |
|
|
1995 NewPassWd = Char2[c] + Char2[a] + Char2[b] + PassWd[x] |
|
|
1996 timeup += 1 |
|
|
1997 if timeup == sleep_now: |
|
|
1998 time.sleep(sleep_for) |
|
|
1999 timeup = 0 |
|
689
|
2000 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2001 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2002 if test == None: |
|
|
2003 print(output) |
|
|
2004 elif output.__contains__(test): |
|
|
2005 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2006 else: |
|
|
2007 print(output) |
|
|
2008 |
|
|
2009 PassAmount += 1 |
|
|
2010 Timer = int(round(float(time.time() - StartTime))) |
|
|
2011 Speed = PassAmount / Timer |
|
|
2012 NewShowWord = ShowWord[x] + Char1[b] + Char1[a] + Char1[c] |
|
|
2013 NewPassWd = PassWd[x] + Char2[b] + Char2[a] + Char2[c] |
|
|
2014 timeup += 1 |
|
|
2015 if timeup == sleep_now: |
|
|
2016 time.sleep(sleep_for) |
|
|
2017 timeup = 0 |
|
689
|
2018 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2019 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2020 if test == None: |
|
|
2021 print(output) |
|
|
2022 elif output.__contains__(test): |
|
|
2023 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2024 else: |
|
|
2025 print(output) |
|
|
2026 |
|
|
2027 def BF5(): |
|
|
2028 if NoChar is True: |
|
689
|
2029 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2030 WordCount = 0 |
|
|
2031 for CountWords in ShowWord: |
|
|
2032 WordCount += 1 |
|
|
2033 StartTime = time.time() |
|
|
2034 StartTime = StartTime - 1 |
|
|
2035 PassAmount = 0 |
|
|
2036 timeup = 0 |
|
|
2037 for u in range(StateU, UserCount): |
|
|
2038 if length_start > 4: |
|
|
2039 break |
|
|
2040 if length_end < 4: |
|
689
|
2041 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2042 for a in range(StateA, EndCount): |
|
|
2043 for b in range(StateB, EndCount): |
|
|
2044 for c in range(StateC, EndCount): |
|
|
2045 for d in range(StateD, EndCount): |
|
|
2046 for x in range(StateW, WordCount): |
|
|
2047 if SaveSwitch is True: |
|
|
2048 WriteSave = [] |
|
|
2049 FILE = open(save, 'w') |
|
|
2050 WriteSave.append(str(cmd)) |
|
|
2051 WriteSave.append(str(dictionary)) |
|
|
2052 WriteSave.append(str(MixCustom)) |
|
|
2053 WriteSave.append(str(Custom)) |
|
|
2054 WriteSave.append(str(ExhSwitch)) |
|
|
2055 WriteSave.append(str(StdoutSwitch)) |
|
|
2056 WriteSave.append(str(usernames)) |
|
|
2057 WriteSave.append(str(UserSwitch)) |
|
|
2058 WriteSave.append(str(AlphaSwitch)) |
|
|
2059 WriteSave.append(str(BWSwitch)) |
|
|
2060 WriteSave.append(str(CapsSwitch)) |
|
|
2061 WriteSave.append(str(L337Switch)) |
|
|
2062 WriteSave.append(str(MD5Switch)) |
|
|
2063 WriteSave.append(str(NumberSwitch)) |
|
|
2064 WriteSave.append(str(RegularSwitch)) |
|
|
2065 WriteSave.append(str(SpecialSwitch)) |
|
|
2066 WriteSave.append(str(Letters)) |
|
|
2067 WriteSave.append(str(Numbers)) |
|
|
2068 WriteSave.append(str(Specials)) |
|
|
2069 WriteSave.append(str(wep5)) |
|
|
2070 WriteSave.append(str(wep13)) |
|
|
2071 WriteSave.append(str(SESwitch)) |
|
|
2072 WriteSave.append(str(u)) |
|
|
2073 WriteSave.append(str(x)) |
|
|
2074 WriteSave.append(str(a)) |
|
|
2075 WriteSave.append(str(b)) |
|
|
2076 WriteSave.append(str(c)) |
|
|
2077 WriteSave.append(str(d)) |
|
|
2078 for WriteStates in WriteSave: |
|
|
2079 FILE.write(WriteStates + "\n") |
|
|
2080 FILE.close() |
|
|
2081 PassAmount += 1 |
|
|
2082 Timer = int(round(float(time.time() - StartTime))) |
|
|
2083 Speed = PassAmount / Timer |
|
|
2084 NewShowWord = Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] |
|
|
2085 NewPassWd = Char2[c] + Char2[a] + PassWd[x] + Char2[b] + Char2[d] |
|
|
2086 timeup += 1 |
|
|
2087 if timeup == sleep_now: |
|
|
2088 time.sleep(sleep_for) |
|
|
2089 timeup = 0 |
|
689
|
2090 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2091 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2092 if test == None: |
|
|
2093 print(output) |
|
|
2094 elif output.__contains__(test): |
|
|
2095 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2096 else: |
|
|
2097 print(output) |
|
|
2098 |
|
|
2099 if ExhSwitch is False: |
|
|
2100 PassAmount += 1 |
|
|
2101 Timer = int(round(float(time.time() - StartTime))) |
|
|
2102 Speed = PassAmount / Timer |
|
|
2103 NewShowWord = Char1[c] + Char1[a] + Char1[b] + Char1[d] + ShowWord[x] |
|
|
2104 NewPassWd = Char2[c] + Char2[a] + Char2[b] + Char2[d] + PassWd[x] |
|
|
2105 timeup += 1 |
|
|
2106 if timeup == sleep_now: |
|
|
2107 time.sleep(sleep_for) |
|
|
2108 timeup = 0 |
|
689
|
2109 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2110 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2111 if test == None: |
|
|
2112 print(output) |
|
|
2113 elif output.__contains__(test): |
|
|
2114 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2115 else: |
|
|
2116 print(output) |
|
|
2117 |
|
|
2118 PassAmount += 1 |
|
|
2119 Timer = int(round(float(time.time() - StartTime))) |
|
|
2120 Speed = PassAmount / Timer |
|
|
2121 NewShowWord = ShowWord[x] + Char1[d] + Char1[b] + Char1[a] + Char1[c] |
|
|
2122 NewPassWd = PassWd[x] + Char2[d] + Char2[b] + Char2[a] + Char2[c] |
|
|
2123 timeup += 1 |
|
|
2124 if timeup == sleep_now: |
|
|
2125 time.sleep(sleep_for) |
|
|
2126 timeup = 0 |
|
689
|
2127 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2128 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2129 if test == None: |
|
|
2130 print(output) |
|
|
2131 elif output.__contains__(test): |
|
|
2132 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2133 else: |
|
|
2134 print(output) |
|
|
2135 |
|
|
2136 def BF6(): |
|
|
2137 if NoChar is True: |
|
689
|
2138 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2139 WordCount = 0 |
|
|
2140 for CountWords in ShowWord: |
|
|
2141 WordCount += 1 |
|
|
2142 StartTime = time.time() |
|
|
2143 StartTime = StartTime - 1 |
|
|
2144 PassAmount = 0 |
|
|
2145 timeup = 0 |
|
|
2146 for u in range(StateU, UserCount): |
|
|
2147 if length_start > 5: |
|
|
2148 break |
|
|
2149 if length_end < 5: |
|
689
|
2150 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2151 for a in range(StateA, EndCount): |
|
|
2152 for b in range(StateB, EndCount): |
|
|
2153 for c in range(StateC, EndCount): |
|
|
2154 for d in range(StateD, EndCount): |
|
|
2155 for e in range(StateE, EndCount): |
|
|
2156 for x in range(StateW, WordCount): |
|
|
2157 if SaveSwitch is True: |
|
|
2158 WriteSave = [] |
|
|
2159 FILE = open(save, 'w') |
|
|
2160 WriteSave.append(str(cmd)) |
|
|
2161 WriteSave.append(str(dictionary)) |
|
|
2162 WriteSave.append(str(MixCustom)) |
|
|
2163 WriteSave.append(str(Custom)) |
|
|
2164 WriteSave.append(str(ExhSwitch)) |
|
|
2165 WriteSave.append(str(StdoutSwitch)) |
|
|
2166 WriteSave.append(str(usernames)) |
|
|
2167 WriteSave.append(str(UserSwitch)) |
|
|
2168 WriteSave.append(str(AlphaSwitch)) |
|
|
2169 WriteSave.append(str(BWSwitch)) |
|
|
2170 WriteSave.append(str(CapsSwitch)) |
|
|
2171 WriteSave.append(str(L337Switch)) |
|
|
2172 WriteSave.append(str(MD5Switch)) |
|
|
2173 WriteSave.append(str(NumberSwitch)) |
|
|
2174 WriteSave.append(str(RegularSwitch)) |
|
|
2175 WriteSave.append(str(SpecialSwitch)) |
|
|
2176 WriteSave.append(str(Letters)) |
|
|
2177 WriteSave.append(str(Numbers)) |
|
|
2178 WriteSave.append(str(Specials)) |
|
|
2179 WriteSave.append(str(wep5)) |
|
|
2180 WriteSave.append(str(wep13)) |
|
|
2181 WriteSave.append(str(SESwitch)) |
|
|
2182 WriteSave.append(str(u)) |
|
|
2183 WriteSave.append(str(x)) |
|
|
2184 WriteSave.append(str(a)) |
|
|
2185 WriteSave.append(str(b)) |
|
|
2186 WriteSave.append(str(c)) |
|
|
2187 WriteSave.append(str(d)) |
|
|
2188 WriteSave.append(str(e)) |
|
|
2189 for WriteStates in WriteSave: |
|
|
2190 FILE.write(WriteStates + "\n") |
|
|
2191 FILE.close() |
|
|
2192 PassAmount += 1 |
|
|
2193 Timer = int(round(float(time.time() - StartTime))) |
|
|
2194 Speed = PassAmount / Timer |
|
|
2195 NewShowWord = Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] |
|
|
2196 NewPassWd = Char2[e] + Char2[c] + Char2[a] + PassWd[x] + Char2[b] + Char2[d] |
|
|
2197 timeup += 1 |
|
|
2198 if timeup == sleep_now: |
|
|
2199 time.sleep(sleep_for) |
|
|
2200 timeup = 0 |
|
689
|
2201 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2202 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2203 if test == None: |
|
|
2204 print(output) |
|
|
2205 elif output.__contains__(test): |
|
|
2206 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2207 else: |
|
|
2208 print(output) |
|
|
2209 |
|
|
2210 if ExhSwitch is False: |
|
|
2211 PassAmount += 1 |
|
|
2212 Timer = int(round(float(time.time() - StartTime))) |
|
|
2213 Speed = PassAmount / Timer |
|
|
2214 NewShowWord = Char1[d] + Char1[b] + ShowWord[x] + Char1[a] + Char1[c] + Char1[e] |
|
|
2215 NewPassWd = Char2[d] + Char2[b] + PassWd[x] + Char2[a] + Char2[c] + Char2[e] |
|
|
2216 timeup += 1 |
|
|
2217 if timeup == sleep_now: |
|
|
2218 time.sleep(sleep_for) |
|
|
2219 timeup = 0 |
|
689
|
2220 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2221 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2222 if test == None: |
|
|
2223 print(output) |
|
|
2224 elif output.__contains__(test): |
|
|
2225 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2226 else: |
|
|
2227 print(output) |
|
|
2228 |
|
|
2229 PassAmount += 1 |
|
|
2230 Timer = int(round(float(time.time() - StartTime))) |
|
|
2231 Speed = PassAmount / Timer |
|
|
2232 NewShowWord = Char1[e] + Char1[c] + Char1[a] + Char1[b] + Char1[d] + ShowWord[x] |
|
|
2233 NewPassWd = Char2[e] + Char2[c] + Char2[a] + Char2[b] + Char2[d] + PassWd[x] |
|
|
2234 timeup += 1 |
|
|
2235 if timeup == sleep_now: |
|
|
2236 time.sleep(sleep_for) |
|
|
2237 timeup = 0 |
|
689
|
2238 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2239 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2240 if test == None: |
|
|
2241 print(output) |
|
|
2242 elif output.__contains__(test): |
|
|
2243 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2244 else: |
|
|
2245 print(output) |
|
|
2246 |
|
|
2247 PassAmount += 1 |
|
|
2248 Timer = int(round(float(time.time() - StartTime))) |
|
|
2249 Speed = PassAmount / Timer |
|
|
2250 NewShowWord = ShowWord[x] + Char1[d] + Char1[b] + Char1[a] + Char1[c] + Char1[e] |
|
|
2251 NewPassWd = PassWd[x] + Char2[d] + Char2[b] + Char2[a] + Char2[c] + Char2[e] |
|
|
2252 timeup += 1 |
|
|
2253 if timeup == sleep_now: |
|
|
2254 time.sleep(sleep_for) |
|
|
2255 timeup = 0 |
|
689
|
2256 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2257 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2258 if test == None: |
|
|
2259 print(output) |
|
|
2260 elif output.__contains__(test): |
|
|
2261 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2262 else: |
|
|
2263 print(output) |
|
|
2264 |
|
|
2265 def BF7(): |
|
|
2266 if NoChar is True: |
|
689
|
2267 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2268 WordCount = 0 |
|
|
2269 for CountWords in ShowWord: |
|
|
2270 WordCount += 1 |
|
|
2271 StartTime = time.time() |
|
|
2272 StartTime = StartTime - 1 |
|
|
2273 PassAmount = 0 |
|
|
2274 timeup = 0 |
|
|
2275 for u in range(StateU, UserCount): |
|
|
2276 if length_start > 6: |
|
|
2277 break |
|
|
2278 if length_end < 6: |
|
689
|
2279 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2280 for a in range(StateA, EndCount): |
|
|
2281 for b in range(StateB, EndCount): |
|
|
2282 for c in range(StateC, EndCount): |
|
|
2283 for d in range(StateD, EndCount): |
|
|
2284 for e in range(StateE, EndCount): |
|
|
2285 for f in range(StateF, EndCount): |
|
|
2286 for x in range(StateW, WordCount): |
|
|
2287 if SaveSwitch is True: |
|
|
2288 WriteSave = [] |
|
|
2289 FILE = open(save, 'w') |
|
|
2290 WriteSave.append(str(cmd)) |
|
|
2291 WriteSave.append(str(dictionary)) |
|
|
2292 WriteSave.append(str(MixCustom)) |
|
|
2293 WriteSave.append(str(Custom)) |
|
|
2294 WriteSave.append(str(ExhSwitch)) |
|
|
2295 WriteSave.append(str(StdoutSwitch)) |
|
|
2296 WriteSave.append(str(usernames)) |
|
|
2297 WriteSave.append(str(UserSwitch)) |
|
|
2298 WriteSave.append(str(AlphaSwitch)) |
|
|
2299 WriteSave.append(str(BWSwitch)) |
|
|
2300 WriteSave.append(str(CapsSwitch)) |
|
|
2301 WriteSave.append(str(L337Switch)) |
|
|
2302 WriteSave.append(str(MD5Switch)) |
|
|
2303 WriteSave.append(str(NumberSwitch)) |
|
|
2304 WriteSave.append(str(RegularSwitch)) |
|
|
2305 WriteSave.append(str(SpecialSwitch)) |
|
|
2306 WriteSave.append(str(Letters)) |
|
|
2307 WriteSave.append(str(Numbers)) |
|
|
2308 WriteSave.append(str(Specials)) |
|
|
2309 WriteSave.append(str(wep5)) |
|
|
2310 WriteSave.append(str(wep13)) |
|
|
2311 WriteSave.append(str(SESwitch)) |
|
|
2312 WriteSave.append(str(u)) |
|
|
2313 WriteSave.append(str(x)) |
|
|
2314 WriteSave.append(str(a)) |
|
|
2315 WriteSave.append(str(b)) |
|
|
2316 WriteSave.append(str(c)) |
|
|
2317 WriteSave.append(str(d)) |
|
|
2318 WriteSave.append(str(e)) |
|
|
2319 WriteSave.append(str(f)) |
|
|
2320 for WriteStates in WriteSave: |
|
|
2321 FILE.write(WriteStates + "\n") |
|
|
2322 FILE.close() |
|
|
2323 PassAmount += 1 |
|
|
2324 Timer = int(round(float(time.time() - StartTime))) |
|
|
2325 Speed = PassAmount / Timer |
|
|
2326 NewShowWord = Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] + Char1[f] |
|
|
2327 NewPassWd = Char2[e] + Char2[c] + Char2[a] + PassWd[x] + Char2[b] + Char2[d] + Char2[f] |
|
|
2328 timeup += 1 |
|
|
2329 if timeup == sleep_now: |
|
|
2330 time.sleep(sleep_for) |
|
|
2331 timeup = 0 |
|
689
|
2332 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2333 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2334 if test == None: |
|
|
2335 print(output) |
|
|
2336 elif output.__contains__(test): |
|
|
2337 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2338 else: |
|
|
2339 print(output) |
|
|
2340 |
|
|
2341 if ExhSwitch is False: |
|
|
2342 PassAmount += 1 |
|
|
2343 Timer = int(round(float(time.time() - StartTime))) |
|
|
2344 Speed = PassAmount / Timer |
|
|
2345 NewShowWord = Char1[e] + Char1[c] + Char1[a] + Char1[b] + Char1[d] + Char1[f] + ShowWord[x] |
|
|
2346 NewPassWd = Char2[e] + Char2[c] + Char2[a] + Char2[b] + Char2[d] + Char2[f] + PassWd[x] |
|
|
2347 timeup += 1 |
|
|
2348 if timeup == sleep_now: |
|
|
2349 time.sleep(sleep_for) |
|
|
2350 timeup = 0 |
|
689
|
2351 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2352 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2353 if test == None: |
|
|
2354 print(output) |
|
|
2355 elif output.__contains__(test): |
|
|
2356 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2357 else: |
|
|
2358 print(output) |
|
|
2359 |
|
|
2360 PassAmount += 1 |
|
|
2361 Timer = int(round(float(time.time() - StartTime))) |
|
|
2362 Speed = PassAmount / Timer |
|
|
2363 NewShowWord = ShowWord[x] + Char1[f] + Char1[d] + Char1[b] + Char1[a] + Char1[c] + Char1[e] |
|
|
2364 NewPassWd = PassWd[x] + Char2[f] + Char2[d] + Char2[b] + Char2[a] + Char2[c] + Char2[e] |
|
|
2365 timeup += 1 |
|
|
2366 if timeup == sleep_now: |
|
|
2367 time.sleep(sleep_for) |
|
|
2368 timeup = 0 |
|
689
|
2369 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2370 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2371 if test == None: |
|
|
2372 print(output) |
|
|
2373 elif output.__contains__(test): |
|
|
2374 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2375 else: |
|
|
2376 print(output) |
|
|
2377 |
|
|
2378 def BF8(): |
|
|
2379 if NoChar is True: |
|
689
|
2380 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2381 WordCount = 0 |
|
|
2382 for CountWords in ShowWord: |
|
|
2383 WordCount += 1 |
|
|
2384 StartTime = time.time() |
|
|
2385 StartTime = StartTime - 1 |
|
|
2386 PassAmount = 0 |
|
|
2387 timeup = 0 |
|
|
2388 for u in range(StateU, UserCount): |
|
|
2389 if length_start > 7: |
|
|
2390 break |
|
|
2391 if length_end < 7: |
|
689
|
2392 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2393 for a in range(StateA, EndCount): |
|
|
2394 for b in range(StateB, EndCount): |
|
|
2395 for c in range(StateC, EndCount): |
|
|
2396 for d in range(StateD, EndCount): |
|
|
2397 for e in range(StateE, EndCount): |
|
|
2398 for f in range(StateF, EndCount): |
|
|
2399 for g in range(StateG, EndCount): |
|
|
2400 for x in range(StateW, WordCount): |
|
|
2401 if SaveSwitch is True: |
|
|
2402 WriteSave = [] |
|
|
2403 FILE = open(save, 'w') |
|
|
2404 WriteSave.append(str(cmd)) |
|
|
2405 WriteSave.append(str(dictionary)) |
|
|
2406 WriteSave.append(str(MixCustom)) |
|
|
2407 WriteSave.append(str(Custom)) |
|
|
2408 WriteSave.append(str(ExhSwitch)) |
|
|
2409 WriteSave.append(str(StdoutSwitch)) |
|
|
2410 WriteSave.append(str(usernames)) |
|
|
2411 WriteSave.append(str(UserSwitch)) |
|
|
2412 WriteSave.append(str(AlphaSwitch)) |
|
|
2413 WriteSave.append(str(BWSwitch)) |
|
|
2414 WriteSave.append(str(CapsSwitch)) |
|
|
2415 WriteSave.append(str(L337Switch)) |
|
|
2416 WriteSave.append(str(MD5Switch)) |
|
|
2417 WriteSave.append(str(NumberSwitch)) |
|
|
2418 WriteSave.append(str(RegularSwitch)) |
|
|
2419 WriteSave.append(str(SpecialSwitch)) |
|
|
2420 WriteSave.append(str(Letters)) |
|
|
2421 WriteSave.append(str(Numbers)) |
|
|
2422 WriteSave.append(str(Specials)) |
|
|
2423 WriteSave.append(str(wep5)) |
|
|
2424 WriteSave.append(str(wep13)) |
|
|
2425 WriteSave.append(str(SESwitch)) |
|
|
2426 WriteSave.append(str(u)) |
|
|
2427 WriteSave.append(str(x)) |
|
|
2428 WriteSave.append(str(a)) |
|
|
2429 WriteSave.append(str(b)) |
|
|
2430 WriteSave.append(str(c)) |
|
|
2431 WriteSave.append(str(d)) |
|
|
2432 WriteSave.append(str(e)) |
|
|
2433 WriteSave.append(str(f)) |
|
|
2434 WriteSave.append(str(g)) |
|
|
2435 for WriteStates in WriteSave: |
|
|
2436 FILE.write(WriteStates + "\n") |
|
|
2437 FILE.close() |
|
|
2438 PassAmount += 1 |
|
|
2439 Timer = int(round(float(time.time() - StartTime))) |
|
|
2440 Speed = PassAmount / Timer |
|
|
2441 NewShowWord = Char1[g] + Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] + Char1[f] |
|
|
2442 NewPassWd = Char2[g] + Char2[e] + Char2[c] + Char2[a] + PassWd[x] + Char2[b] + Char2[d] + Char2[f] |
|
|
2443 timeup += 1 |
|
|
2444 if timeup == sleep_now: |
|
|
2445 time.sleep(sleep_for) |
|
|
2446 timeup = 0 |
|
689
|
2447 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2448 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2449 if test == None: |
|
|
2450 print(output) |
|
|
2451 elif output.__contains__(test): |
|
|
2452 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2453 else: |
|
|
2454 print(output) |
|
|
2455 |
|
|
2456 if ExhSwitch is False: |
|
|
2457 PassAmount += 1 |
|
|
2458 Timer = int(round(float(time.time() - StartTime))) |
|
|
2459 Speed = PassAmount / Timer |
|
|
2460 NewShowWord = Char1[f] + Char1[d] + Char1[b] + ShowWord[x] + Char1[a] + Char1[c] + Char1[e] + Char1[g] |
|
|
2461 NewPassWd = Char2[f] + Char2[d] + Char2[b] + PassWd[x] + Char2[a] + Char2[c] + Char2[e] + Char2[g] |
|
|
2462 timeup += 1 |
|
|
2463 if timeup == sleep_now: |
|
|
2464 time.sleep(sleep_for) |
|
|
2465 timeup = 0 |
|
689
|
2466 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2467 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2468 if test == None: |
|
|
2469 print(output) |
|
|
2470 elif output.__contains__(test): |
|
|
2471 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2472 else: |
|
|
2473 print(output) |
|
|
2474 |
|
|
2475 PassAmount += 1 |
|
|
2476 Timer = int(round(float(time.time() - StartTime))) |
|
|
2477 Speed = PassAmount / Timer |
|
|
2478 NewShowWord = Char1[g] + Char1[e] + Char1[c] + Char1[a] + Char1[b] + Char1[d] + Char1[f] + ShowWord[x] |
|
|
2479 NewPassWd = Char2[g] + Char2[e] + Char2[c] + Char2[a] + Char2[b] + Char2[d] + Char2[f] + PassWd[x] |
|
|
2480 timeup += 1 |
|
|
2481 if timeup == sleep_now: |
|
|
2482 time.sleep(sleep_for) |
|
|
2483 timeup = 0 |
|
689
|
2484 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2485 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2486 if test == None: |
|
|
2487 print(output) |
|
|
2488 elif output.__contains__(test): |
|
|
2489 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2490 else: |
|
|
2491 print(output) |
|
|
2492 |
|
|
2493 PassAmount += 1 |
|
|
2494 Timer = int(round(float(time.time() - StartTime))) |
|
|
2495 Speed = PassAmount / Timer |
|
|
2496 NewShowWord = ShowWord[x] + Char1[f] + Char1[d] + Char1[b] + Char1[a] + Char1[c] + Char1[e] + Char1[g] |
|
|
2497 NewPassWd = PassWd[x] + Char2[f] + Char2[d] + Char2[b] + Char2[a] + Char2[c] + Char2[e] + Char2[g] |
|
|
2498 timeup += 1 |
|
|
2499 if timeup == sleep_now: |
|
|
2500 time.sleep(sleep_for) |
|
|
2501 timeup = 0 |
|
689
|
2502 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2503 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2504 if test == None: |
|
|
2505 print(output) |
|
|
2506 elif output.__contains__(test): |
|
|
2507 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2508 else: |
|
|
2509 print(output) |
|
|
2510 |
|
|
2511 def BF9(): |
|
|
2512 if NoChar is True: |
|
689
|
2513 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2514 WordCount = 0 |
|
|
2515 for CountWords in ShowWord: |
|
|
2516 WordCount += 1 |
|
|
2517 StartTime = time.time() |
|
|
2518 StartTime = StartTime - 1 |
|
|
2519 PassAmount = 0 |
|
|
2520 timeup = 0 |
|
|
2521 for u in range(StateU, UserCount): |
|
|
2522 if length_start > 8: |
|
|
2523 break |
|
|
2524 if length_end < 8: |
|
689
|
2525 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2526 for a in range(StateA, EndCount): |
|
|
2527 for b in range(StateB, EndCount): |
|
|
2528 for c in range(StateC, EndCount): |
|
|
2529 for d in range(StateD, EndCount): |
|
|
2530 for e in range(StateE, EndCount): |
|
|
2531 for f in range(StateF, EndCount): |
|
|
2532 for g in range(StateG, EndCount): |
|
|
2533 for h in range(StateH, EndCount): |
|
|
2534 for x in range(StateW, WordCount): |
|
|
2535 if SaveSwitch is True: |
|
|
2536 WriteSave = [] |
|
|
2537 FILE = open(save, 'w') |
|
|
2538 WriteSave.append(str(cmd)) |
|
|
2539 WriteSave.append(str(dictionary)) |
|
|
2540 WriteSave.append(str(MixCustom)) |
|
|
2541 WriteSave.append(str(Custom)) |
|
|
2542 WriteSave.append(str(ExhSwitch)) |
|
|
2543 WriteSave.append(str(StdoutSwitch)) |
|
|
2544 WriteSave.append(str(usernames)) |
|
|
2545 WriteSave.append(str(UserSwitch)) |
|
|
2546 WriteSave.append(str(AlphaSwitch)) |
|
|
2547 WriteSave.append(str(BWSwitch)) |
|
|
2548 WriteSave.append(str(CapsSwitch)) |
|
|
2549 WriteSave.append(str(L337Switch)) |
|
|
2550 WriteSave.append(str(MD5Switch)) |
|
|
2551 WriteSave.append(str(NumberSwitch)) |
|
|
2552 WriteSave.append(str(RegularSwitch)) |
|
|
2553 WriteSave.append(str(SpecialSwitch)) |
|
|
2554 WriteSave.append(str(Letters)) |
|
|
2555 WriteSave.append(str(Numbers)) |
|
|
2556 WriteSave.append(str(Specials)) |
|
|
2557 WriteSave.append(str(wep5)) |
|
|
2558 WriteSave.append(str(wep13)) |
|
|
2559 WriteSave.append(str(SESwitch)) |
|
|
2560 WriteSave.append(str(u)) |
|
|
2561 WriteSave.append(str(x)) |
|
|
2562 WriteSave.append(str(a)) |
|
|
2563 WriteSave.append(str(b)) |
|
|
2564 WriteSave.append(str(c)) |
|
|
2565 WriteSave.append(str(d)) |
|
|
2566 WriteSave.append(str(e)) |
|
|
2567 WriteSave.append(str(f)) |
|
|
2568 WriteSave.append(str(g)) |
|
|
2569 WriteSave.append(str(h)) |
|
|
2570 for WriteStates in WriteSave: |
|
|
2571 FILE.write(WriteStates + "\n") |
|
|
2572 FILE.close() |
|
|
2573 PassAmount += 1 |
|
|
2574 Timer = int(round(float(time.time() - StartTime))) |
|
|
2575 Speed = PassAmount / Timer |
|
|
2576 NewShowWord = Char1[g] + Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] + Char1[f] + Char1[h] |
|
|
2577 NewPassWd = Char2[g] + Char2[e] + Char2[c] + Char2[a] + PassWd[x] + Char2[b] + Char2[d] + Char2[f] + Char2[h] |
|
|
2578 timeup += 1 |
|
|
2579 if timeup == sleep_now: |
|
|
2580 time.sleep(sleep_for) |
|
|
2581 timeup = 0 |
|
689
|
2582 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2583 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2584 if test == None: |
|
|
2585 print(output) |
|
|
2586 elif output.__contains__(test): |
|
|
2587 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2588 else: |
|
|
2589 print(output) |
|
|
2590 |
|
|
2591 if ExhSwitch is False: |
|
|
2592 PassAmount += 1 |
|
|
2593 Timer = int(round(float(time.time() - StartTime))) |
|
|
2594 Speed = PassAmount / Timer |
|
|
2595 NewShowWord = Char1[g] + Char1[e] + Char1[c] + Char1[a] +Char1[b] + Char1[d] + Char1[f] + Char1[h] + ShowWord[x] |
|
|
2596 NewPassWd = Char2[g] + Char2[e] + Char2[c] + Char2[a] + Char2[b] + Char2[d] + Char2[f] + Char2[h] + PassWd[x] |
|
|
2597 timeup += 1 |
|
|
2598 if timeup == sleep_now: |
|
|
2599 time.sleep(sleep_for) |
|
|
2600 timeup = 0 |
|
689
|
2601 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2602 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2603 if test == None: |
|
|
2604 print(output) |
|
|
2605 elif output.__contains__(test): |
|
|
2606 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2607 else: |
|
|
2608 print(output) |
|
|
2609 |
|
|
2610 PassAmount += 1 |
|
|
2611 Timer = int(round(float(time.time() - StartTime))) |
|
|
2612 Speed = PassAmount / Timer |
|
|
2613 NewShowWord = ShowWord[x] + Char1[h] + Char1[f] + Char1[d] + Char1[b] + Char1[a] + Char1[c] + Char1[e] + Char1[g] |
|
|
2614 NewPassWd = PassWd[x] + Char2[h] + Char2[f] + Char2[d] + Char2[b] + Char2[a] + Char2[c] + Char2[e] + Char2[g] |
|
|
2615 timeup += 1 |
|
|
2616 if timeup == sleep_now: |
|
|
2617 time.sleep(sleep_for) |
|
|
2618 timeup = 0 |
|
689
|
2619 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2620 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2621 if test == None: |
|
|
2622 print(output) |
|
|
2623 elif output.__contains__(test): |
|
|
2624 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2625 else: |
|
|
2626 print(output) |
|
|
2627 |
|
|
2628 def BF10(): |
|
|
2629 if NoChar is True: |
|
689
|
2630 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2631 WordCount = 0 |
|
|
2632 for CountWords in ShowWord: |
|
|
2633 WordCount += 1 |
|
|
2634 StartTime = time.time() |
|
|
2635 StartTime = StartTime - 1 |
|
|
2636 PassAmount = 0 |
|
|
2637 timeup = 0 |
|
|
2638 for u in range(StateU, UserCount): |
|
|
2639 if length_start > 9: |
|
|
2640 break |
|
|
2641 if length_end < 9: |
|
689
|
2642 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2643 for a in range(StateA, EndCount): |
|
|
2644 for b in range(StateB, EndCount): |
|
|
2645 for c in range(StateC, EndCount): |
|
|
2646 for d in range(StateD, EndCount): |
|
|
2647 for e in range(StateE, EndCount): |
|
|
2648 for f in range(StateF, EndCount): |
|
|
2649 for g in range(StateG, EndCount): |
|
|
2650 for h in range(StateH, EndCount): |
|
|
2651 for i in range(StateI, EndCount): |
|
|
2652 for x in range(StateW, WordCount): |
|
|
2653 if SaveSwitch is True: |
|
|
2654 WriteSave = [] |
|
|
2655 FILE = open(save, 'w') |
|
|
2656 WriteSave.append(str(cmd)) |
|
|
2657 WriteSave.append(str(dictionary)) |
|
|
2658 WriteSave.append(str(MixCustom)) |
|
|
2659 WriteSave.append(str(Custom)) |
|
|
2660 WriteSave.append(str(ExhSwitch)) |
|
|
2661 WriteSave.append(str(StdoutSwitch)) |
|
|
2662 WriteSave.append(str(usernames)) |
|
|
2663 WriteSave.append(str(UserSwitch)) |
|
|
2664 WriteSave.append(str(AlphaSwitch)) |
|
|
2665 WriteSave.append(str(BWSwitch)) |
|
|
2666 WriteSave.append(str(CapsSwitch)) |
|
|
2667 WriteSave.append(str(L337Switch)) |
|
|
2668 WriteSave.append(str(MD5Switch)) |
|
|
2669 WriteSave.append(str(NumberSwitch)) |
|
|
2670 WriteSave.append(str(RegularSwitch)) |
|
|
2671 WriteSave.append(str(SpecialSwitch)) |
|
|
2672 WriteSave.append(str(Letters)) |
|
|
2673 WriteSave.append(str(Numbers)) |
|
|
2674 WriteSave.append(str(Specials)) |
|
|
2675 WriteSave.append(str(wep5)) |
|
|
2676 WriteSave.append(str(wep13)) |
|
|
2677 WriteSave.append(str(SESwitch)) |
|
|
2678 WriteSave.append(str(u)) |
|
|
2679 WriteSave.append(str(x)) |
|
|
2680 WriteSave.append(str(a)) |
|
|
2681 WriteSave.append(str(b)) |
|
|
2682 WriteSave.append(str(c)) |
|
|
2683 WriteSave.append(str(d)) |
|
|
2684 WriteSave.append(str(e)) |
|
|
2685 WriteSave.append(str(f)) |
|
|
2686 WriteSave.append(str(g)) |
|
|
2687 WriteSave.append(str(h)) |
|
|
2688 WriteSave.append(str(i)) |
|
|
2689 for WriteStates in WriteSave: |
|
|
2690 FILE.write(WriteStates + "\n") |
|
|
2691 FILE.close() |
|
|
2692 PassAmount += 1 |
|
|
2693 Timer = int(round(float(time.time() - StartTime))) |
|
|
2694 Speed = PassAmount / Timer |
|
|
2695 NewShowWord = Char1[i] + Char1[g] + Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] + Char1[f] + Char1[h] |
|
|
2696 NewPassWd = Char2[i] + Char2[g] + Char2[e] + Char2[c] + Char2[a] + PassWd[x] + Char2[b] + Char2[d] + Char2[f] + Char2[h] |
|
|
2697 timeup += 1 |
|
|
2698 if timeup == sleep_now: |
|
|
2699 time.sleep(sleep_for) |
|
|
2700 timeup = 0 |
|
689
|
2701 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2702 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2703 if test == None: |
|
|
2704 print(output) |
|
|
2705 elif output.__contains__(test): |
|
|
2706 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2707 else: |
|
|
2708 print(output) |
|
|
2709 |
|
|
2710 if ExhSwitch is False: |
|
|
2711 PassAmount += 1 |
|
|
2712 Timer = int(round(float(time.time() - StartTime))) |
|
|
2713 Speed = PassAmount / Timer |
|
|
2714 NewShowWord = Char1[h] + Char1[f] + Char1[d] + Char1[b] + ShowWord[x] + Char1[a] + Char1[c] + Char1[e] + Char1[g] + Char1[i] |
|
|
2715 NewPassWd = Char2[h] + Char2[f] + Char2[d] + Char2[b] + PassWd[x] + Char2[a] + Char2[c] + Char2[e] + Char2[g] + Char2[i] |
|
|
2716 timeup += 1 |
|
|
2717 if timeup == sleep_now: |
|
|
2718 time.sleep(sleep_for) |
|
|
2719 timeup = 0 |
|
689
|
2720 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2721 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2722 if test == None: |
|
|
2723 print(output) |
|
|
2724 elif output.__contains__(test): |
|
|
2725 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2726 else: |
|
|
2727 print(output) |
|
|
2728 |
|
|
2729 PassAmount += 1 |
|
|
2730 Timer = int(round(float(time.time() - StartTime))) |
|
|
2731 Speed = PassAmount / Timer |
|
|
2732 NewShowWord = Char1[i] + Char1[g] + Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] + Char1[f] + Char1[h] + ShowWord[x] |
|
|
2733 NewPassWd = Char2[i] + Char2[g] + Char2[e] + Char2[c] + Char2[a] + PassWd[x] + Char2[b] + Char2[d] + Char2[f] + Char2[h] + PassWd[x] |
|
|
2734 timeup += 1 |
|
|
2735 if timeup == sleep_now: |
|
|
2736 time.sleep(sleep_for) |
|
|
2737 timeup = 0 |
|
689
|
2738 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2739 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2740 if test == None: |
|
|
2741 print(output) |
|
|
2742 elif output.__contains__(test): |
|
|
2743 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2744 else: |
|
|
2745 print(output) |
|
|
2746 |
|
|
2747 PassAmount += 1 |
|
|
2748 Timer = int(round(float(time.time() - StartTime))) |
|
|
2749 Speed = PassAmount / Timer |
|
|
2750 NewShowWord = ShowWord[x] + Char1[h] + Char1[f] + Char1[d] + Char1[b] + Char1[a] + Char1[c] + Char1[e] + Char1[g] + Char1[i] |
|
|
2751 NewPassWd = PassWd[x] + Char2[h] + Char2[f] + Char2[d] + Char2[b] + Char2[a] + Char2[c] + Char2[e] + Char2[g] + Char2[i] |
|
|
2752 timeup += 1 |
|
|
2753 if timeup == sleep_now: |
|
|
2754 time.sleep(sleep_for) |
|
|
2755 timeup = 0 |
|
689
|
2756 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2757 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2758 if test == None: |
|
|
2759 print(output) |
|
|
2760 elif output.__contains__(test): |
|
|
2761 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2762 else: |
|
|
2763 print(output) |
|
|
2764 |
|
|
2765 def BF11(): |
|
|
2766 if NoChar is True: |
|
689
|
2767 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2768 WordCount = 0 |
|
|
2769 for CountWords in ShowWord: |
|
|
2770 WordCount += 1 |
|
|
2771 StartTime = time.time() |
|
|
2772 StartTime = StartTime - 1 |
|
|
2773 PassAmount = 0 |
|
|
2774 timeup = 0 |
|
|
2775 for u in range(StateU, UserCount): |
|
|
2776 if length_start > 10: |
|
|
2777 break |
|
|
2778 if length_end < 10: |
|
689
|
2779 sys.exit(SpliceX + 'unable to find password') |
|
688
|
2780 for a in range(StateA, EndCount): |
|
|
2781 for b in range(StateB, EndCount): |
|
|
2782 for c in range(StateC, EndCount): |
|
|
2783 for d in range(StateD, EndCount): |
|
|
2784 for e in range(StateE, EndCount): |
|
|
2785 for f in range(StateF, EndCount): |
|
|
2786 for g in range(StateG, EndCount): |
|
|
2787 for h in range(StateH, EndCount): |
|
|
2788 for i in range(StateI, EndCount): |
|
|
2789 for j in range(StateJ, EndCount): |
|
|
2790 for x in range(StateW, WordCount): |
|
|
2791 if SaveSwitch is True: |
|
|
2792 WriteSave = [] |
|
|
2793 FILE = open(save, 'w') |
|
|
2794 WriteSave.append(str(cmd)) |
|
|
2795 WriteSave.append(str(dictionary)) |
|
|
2796 WriteSave.append(str(MixCustom)) |
|
|
2797 WriteSave.append(str(Custom)) |
|
|
2798 WriteSave.append(str(ExhSwitch)) |
|
|
2799 WriteSave.append(str(StdoutSwitch)) |
|
|
2800 WriteSave.append(str(usernames)) |
|
|
2801 WriteSave.append(str(UserSwitch)) |
|
|
2802 WriteSave.append(str(AlphaSwitch)) |
|
|
2803 WriteSave.append(str(BWSwitch)) |
|
|
2804 WriteSave.append(str(CapsSwitch)) |
|
|
2805 WriteSave.append(str(L337Switch)) |
|
|
2806 WriteSave.append(str(MD5Switch)) |
|
|
2807 WriteSave.append(str(NumberSwitch)) |
|
|
2808 WriteSave.append(str(RegularSwitch)) |
|
|
2809 WriteSave.append(str(SpecialSwitch)) |
|
|
2810 WriteSave.append(str(Letters)) |
|
|
2811 WriteSave.append(str(Numbers)) |
|
|
2812 WriteSave.append(str(Specials)) |
|
|
2813 WriteSave.append(str(wep5)) |
|
|
2814 WriteSave.append(str(wep13)) |
|
|
2815 WriteSave.append(str(SESwitch)) |
|
|
2816 WriteSave.append(str(u)) |
|
|
2817 WriteSave.append(str(x)) |
|
|
2818 WriteSave.append(str(a)) |
|
|
2819 WriteSave.append(str(b)) |
|
|
2820 WriteSave.append(str(c)) |
|
|
2821 WriteSave.append(str(d)) |
|
|
2822 WriteSave.append(str(e)) |
|
|
2823 WriteSave.append(str(f)) |
|
|
2824 WriteSave.append(str(g)) |
|
|
2825 WriteSave.append(str(h)) |
|
|
2826 WriteSave.append(str(i)) |
|
|
2827 WriteSave.append(str(j)) |
|
|
2828 for WriteStates in WriteSave: |
|
|
2829 FILE.write(WriteStates + "\n") |
|
|
2830 FILE.close() |
|
|
2831 PassAmount += 1 |
|
|
2832 Timer = int(round(float(time.time() - StartTime))) |
|
|
2833 Speed = PassAmount / Timer |
|
|
2834 NewShowWord = Char1[i] + Char1[g] + Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] + Char1[f] + Char1[h] + Char1[j] |
|
|
2835 NewPassWd = Char2[i] + Char2[g] + Char2[e] + Char2[c] + Char2[a] + PassWd[x] + Char2[b] + Char2[d] + Char2[f] + Char2[h] + Char2[j] |
|
|
2836 timeup += 1 |
|
|
2837 if timeup == sleep_now: |
|
|
2838 time.sleep(sleep_for) |
|
|
2839 timeup = 0 |
|
689
|
2840 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2841 cmd = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace('USERNAME', User[u].replace(" ", ""))) |
|
|
2842 if test == None: |
|
|
2843 print(output) |
|
|
2844 elif output.__contains__(test): |
|
|
2845 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2846 else: |
|
|
2847 print(output) |
|
|
2848 |
|
|
2849 if ExhSwitch is False: |
|
|
2850 PassAmount += 1 |
|
|
2851 Timer = int(round(float(time.time() - StartTime))) |
|
|
2852 Speed = PassAmount / Timer |
|
|
2853 NewShowWord = Char1[i] + Char1[g] + Char1[e] + Char1[c] + Char1[a] + Char1[b] + Char1[d] + Char1[f] + Char1[h] + Char1[j] + ShowWord[x] |
|
|
2854 NewPassWd = Char2[i] + Char2[g] + Char2[e] + Char2[c] + Char2[a] + Char2[b] + Char2[d] + Char2[f] + Char2[h] + Char2[j] + PassWd[x] |
|
|
2855 timeup += 1 |
|
|
2856 if timeup == sleep_now: |
|
|
2857 time.sleep(sleep_for) |
|
|
2858 timeup = 0 |
|
689
|
2859 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2860 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2861 if test == None: |
|
|
2862 print(output) |
|
|
2863 elif output.__contains__(test): |
|
|
2864 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2865 else: |
|
|
2866 print(output) |
|
|
2867 |
|
|
2868 PassAmount += 1 |
|
|
2869 Timer = int(round(float(time.time() - StartTime))) |
|
|
2870 Speed = PassAmount / Timer |
|
|
2871 NewShowWord = ShowWord[x] + Char1[j] + Char1[h] + Char1[f] + Char1[d] + Char1[b] + Char1[a] + Char1[c] + Char1[e] + Char1[g] + Char1[i] |
|
|
2872 NewPassWd = PassWd[x] + Char2[j] + Char2[h] + Char2[f] + Char2[d] + Char2[b] + Char2[a] + Char2[c] + Char2[e] + Char2[g] + Char2[i] |
|
|
2873 timeup += 1 |
|
|
2874 if timeup == sleep_now: |
|
|
2875 time.sleep(sleep_for) |
|
|
2876 timeup = 0 |
|
689
|
2877 print(SpliceX + str(Speed) + "/s " + User[u].replace(" ", "") + " " + NewShowWord.replace(" ", "")) |
|
688
|
2878 output = os.popen(cmd.replace("PASSWORD", NewPassWd.replace(" ", "")).replace("USERNAME", User[u].replace(" ", ""))).read() |
|
|
2879 if test == None: |
|
|
2880 print(output) |
|
|
2881 elif output.__contains__(test): |
|
|
2882 sys.exit(Red + "[PASSWORD FOUND]: " + Green + NewShowWord + DefColour) |
|
|
2883 else: |
|
|
2884 print(output) |
|
|
2885 |
|
|
2886 def SBF1(): |
|
|
2887 WordCount = 0 |
|
|
2888 for CountWords in ShowWord: |
|
|
2889 WordCount += 1 |
|
|
2890 for u in range(StateU, UserCount): |
|
|
2891 if length_start > 0: |
|
|
2892 break |
|
|
2893 if length_end < 0: |
|
|
2894 sys.exit(0) |
|
|
2895 for x in range(StateW, WordCount): |
|
|
2896 if SaveSwitch is True: |
|
|
2897 WriteSave = [] |
|
|
2898 FILE = open(save, 'w') |
|
|
2899 WriteSave.append(str(cmd)) |
|
|
2900 WriteSave.append(str(dictionary)) |
|
|
2901 WriteSave.append(str(MixCustom)) |
|
|
2902 WriteSave.append(str(Custom)) |
|
|
2903 WriteSave.append(str(ExhSwitch)) |
|
|
2904 WriteSave.append(str(StdoutSwitch)) |
|
|
2905 WriteSave.append(str(usernames)) |
|
|
2906 WriteSave.append(str(UserSwitch)) |
|
|
2907 WriteSave.append(str(AlphaSwitch)) |
|
|
2908 WriteSave.append(str(BWSwitch)) |
|
|
2909 WriteSave.append(str(CapsSwitch)) |
|
|
2910 WriteSave.append(str(L337Switch)) |
|
|
2911 WriteSave.append(str(MD5Switch)) |
|
|
2912 WriteSave.append(str(NumberSwitch)) |
|
|
2913 WriteSave.append(str(RegularSwitch)) |
|
|
2914 WriteSave.append(str(SpecialSwitch)) |
|
|
2915 WriteSave.append(str(Letters)) |
|
|
2916 WriteSave.append(str(Numbers)) |
|
|
2917 WriteSave.append(str(Specials)) |
|
|
2918 WriteSave.append(str(wep5)) |
|
|
2919 WriteSave.append(str(wep13)) |
|
|
2920 WriteSave.append(str(SESwitch)) |
|
|
2921 WriteSave.append(str(u)) |
|
|
2922 WriteSave.append(str(x)) |
|
|
2923 for WriteStates in WriteSave: |
|
|
2924 FILE.write(WriteStates + "\n") |
|
|
2925 FILE.close() |
|
|
2926 NewShowWord = ShowWord[x] |
|
|
2927 print(NewShowWord.replace(" ", "")) |
|
|
2928 |
|
|
2929 def SBF2(): |
|
|
2930 WordCount = 0 |
|
|
2931 for CountWords in ShowWord: |
|
|
2932 WordCount += 1 |
|
|
2933 if NoChar is True: |
|
|
2934 sys.exit(0) |
|
|
2935 for u in range(StateU, UserCount): |
|
|
2936 if length_start > 1: |
|
|
2937 break |
|
|
2938 if length_end < 1: |
|
|
2939 sys.exit(0) |
|
|
2940 for a in range(StateA, EndCount): |
|
|
2941 for x in range(StateW, WordCount): |
|
|
2942 if SaveSwitch is True: |
|
|
2943 WriteSave = [] |
|
|
2944 FILE = open(save, 'w') |
|
|
2945 WriteSave.append(str(cmd)) |
|
|
2946 WriteSave.append(str(dictionary)) |
|
|
2947 WriteSave.append(str(MixCustom)) |
|
|
2948 WriteSave.append(str(Custom)) |
|
|
2949 WriteSave.append(str(ExhSwitch)) |
|
|
2950 WriteSave.append(str(StdoutSwitch)) |
|
|
2951 WriteSave.append(str(usernames)) |
|
|
2952 WriteSave.append(str(UserSwitch)) |
|
|
2953 WriteSave.append(str(AlphaSwitch)) |
|
|
2954 WriteSave.append(str(BWSwitch)) |
|
|
2955 WriteSave.append(str(CapsSwitch)) |
|
|
2956 WriteSave.append(str(L337Switch)) |
|
|
2957 WriteSave.append(str(MD5Switch)) |
|
|
2958 WriteSave.append(str(NumberSwitch)) |
|
|
2959 WriteSave.append(str(RegularSwitch)) |
|
|
2960 WriteSave.append(str(SpecialSwitch)) |
|
|
2961 WriteSave.append(str(Letters)) |
|
|
2962 WriteSave.append(str(Numbers)) |
|
|
2963 WriteSave.append(str(Specials)) |
|
|
2964 WriteSave.append(str(wep5)) |
|
|
2965 WriteSave.append(str(wep13)) |
|
|
2966 WriteSave.append(str(SESwitch)) |
|
|
2967 WriteSave.append(str(u)) |
|
|
2968 WriteSave.append(str(x)) |
|
|
2969 WriteSave.append(str(a)) |
|
|
2970 for WriteStates in WriteSave: |
|
|
2971 FILE.write(WriteStates + "\n") |
|
|
2972 FILE.close() |
|
|
2973 NewShowWord = Char1[a] + ShowWord[x] |
|
|
2974 print(NewShowWord.replace(" ", "")) |
|
|
2975 |
|
|
2976 if ExhSwitch is False: |
|
|
2977 NewShowWord = ShowWord[x] + Char1[a] |
|
|
2978 print(NewShowWord.replace(" ", "")) |
|
|
2979 |
|
|
2980 def SBF3(): |
|
|
2981 WordCount = 0 |
|
|
2982 for CountWords in ShowWord: |
|
|
2983 WordCount += 1 |
|
|
2984 if NoChar is True: |
|
|
2985 sys.exit(0) |
|
|
2986 for u in range(StateU, UserCount): |
|
|
2987 if length_start > 2: |
|
|
2988 break |
|
|
2989 if length_end < 2: |
|
|
2990 sys.exit(0) |
|
|
2991 for a in range(StateA, EndCount): |
|
|
2992 for b in range(StateB, EndCount): |
|
|
2993 for x in range(StateW, WordCount): |
|
|
2994 if SaveSwitch is True: |
|
|
2995 WriteSave = [] |
|
|
2996 FILE = open(save, 'w') |
|
|
2997 WriteSave.append(str(cmd)) |
|
|
2998 WriteSave.append(str(dictionary)) |
|
|
2999 WriteSave.append(str(MixCustom)) |
|
|
3000 WriteSave.append(str(Custom)) |
|
|
3001 WriteSave.append(str(ExhSwitch)) |
|
|
3002 WriteSave.append(str(StdoutSwitch)) |
|
|
3003 WriteSave.append(str(usernames)) |
|
|
3004 WriteSave.append(str(UserSwitch)) |
|
|
3005 WriteSave.append(str(AlphaSwitch)) |
|
|
3006 WriteSave.append(str(BWSwitch)) |
|
|
3007 WriteSave.append(str(CapsSwitch)) |
|
|
3008 WriteSave.append(str(L337Switch)) |
|
|
3009 WriteSave.append(str(MD5Switch)) |
|
|
3010 WriteSave.append(str(NumberSwitch)) |
|
|
3011 WriteSave.append(str(RegularSwitch)) |
|
|
3012 WriteSave.append(str(SpecialSwitch)) |
|
|
3013 WriteSave.append(str(Letters)) |
|
|
3014 WriteSave.append(str(Numbers)) |
|
|
3015 WriteSave.append(str(Specials)) |
|
|
3016 WriteSave.append(str(wep5)) |
|
|
3017 WriteSave.append(str(wep13)) |
|
|
3018 WriteSave.append(str(SESwitch)) |
|
|
3019 WriteSave.append(str(u)) |
|
|
3020 WriteSave.append(str(x)) |
|
|
3021 WriteSave.append(str(a)) |
|
|
3022 WriteSave.append(str(b)) |
|
|
3023 for WriteStates in WriteSave: |
|
|
3024 FILE.write(WriteStates + "\n") |
|
|
3025 FILE.close() |
|
|
3026 NewShowWord = Char1[a] + ShowWord[x] + Char1[b] |
|
|
3027 print(NewShowWord.replace(" ", "")) |
|
|
3028 |
|
|
3029 if ExhSwitch is False: |
|
|
3030 NewShowWord = Char1[a] + Char1[b] + ShowWord[x] |
|
|
3031 print(NewShowWord.replace(" ", "")) |
|
|
3032 |
|
|
3033 NewShowWord = ShowWord[x] + Char1[b] + Char1[a] |
|
|
3034 print(NewShowWord.replace(" ", "")) |
|
|
3035 |
|
|
3036 def SBF4(): |
|
|
3037 WordCount = 0 |
|
|
3038 for CountWords in ShowWord: |
|
|
3039 WordCount += 1 |
|
|
3040 if NoChar is True: |
|
|
3041 sys.exit(0) |
|
|
3042 for u in range(StateU, UserCount): |
|
|
3043 if length_start > 3: |
|
|
3044 break |
|
|
3045 if length_end < 3: |
|
|
3046 sys.exit(0) |
|
|
3047 for a in range(StateA, EndCount): |
|
|
3048 for b in range(StateB, EndCount): |
|
|
3049 for c in range(StateC, EndCount): |
|
|
3050 for x in range(StateW, WordCount): |
|
|
3051 if SaveSwitch is True: |
|
|
3052 WriteSave = [] |
|
|
3053 FILE = open(save, 'w') |
|
|
3054 WriteSave.append(str(cmd)) |
|
|
3055 WriteSave.append(str(dictionary)) |
|
|
3056 WriteSave.append(str(MixCustom)) |
|
|
3057 WriteSave.append(str(Custom)) |
|
|
3058 WriteSave.append(str(ExhSwitch)) |
|
|
3059 WriteSave.append(str(StdoutSwitch)) |
|
|
3060 WriteSave.append(str(usernames)) |
|
|
3061 WriteSave.append(str(UserSwitch)) |
|
|
3062 WriteSave.append(str(AlphaSwitch)) |
|
|
3063 WriteSave.append(str(BWSwitch)) |
|
|
3064 WriteSave.append(str(CapsSwitch)) |
|
|
3065 WriteSave.append(str(L337Switch)) |
|
|
3066 WriteSave.append(str(MD5Switch)) |
|
|
3067 WriteSave.append(str(NumberSwitch)) |
|
|
3068 WriteSave.append(str(RegularSwitch)) |
|
|
3069 WriteSave.append(str(SpecialSwitch)) |
|
|
3070 WriteSave.append(str(Letters)) |
|
|
3071 WriteSave.append(str(Numbers)) |
|
|
3072 WriteSave.append(str(Specials)) |
|
|
3073 WriteSave.append(str(wep5)) |
|
|
3074 WriteSave.append(str(wep13)) |
|
|
3075 WriteSave.append(str(SESwitch)) |
|
|
3076 WriteSave.append(str(u)) |
|
|
3077 WriteSave.append(str(x)) |
|
|
3078 WriteSave.append(str(a)) |
|
|
3079 WriteSave.append(str(b)) |
|
|
3080 WriteSave.append(str(c)) |
|
|
3081 for WriteStates in WriteSave: |
|
|
3082 FILE.write(WriteStates + "\n") |
|
|
3083 FILE.close() |
|
|
3084 NewShowWord = Char1[c] + Char1[a] + ShowWord[x] + Char1[b] |
|
|
3085 print(NewShowWord.replace(" ", "")) |
|
|
3086 |
|
|
3087 if ExhSwitch is False: |
|
|
3088 NewShowWord = Char1[b] + ShowWord[x] + Char1[a] + Char1[c] |
|
|
3089 print(NewShowWord.replace(" ", "")) |
|
|
3090 |
|
|
3091 NewShowWord = Char1[c] + Char1[a] + Char1[b] + ShowWord[x] |
|
|
3092 print(NewShowWord.replace(" ", "")) |
|
|
3093 |
|
|
3094 NewShowWord = ShowWord[x] + Char1[b] + Char1[a] + Char1[c] |
|
|
3095 print(NewShowWord.replace(" ", "")) |
|
|
3096 |
|
|
3097 def SBF5(): |
|
|
3098 WordCount = 0 |
|
|
3099 for CountWords in ShowWord: |
|
|
3100 WordCount += 1 |
|
|
3101 if NoChar is True: |
|
|
3102 sys.exit(0) |
|
|
3103 for u in range(StateU, UserCount): |
|
|
3104 if length_start > 4: |
|
|
3105 break |
|
|
3106 if length_end < 4: |
|
|
3107 sys.exit(0) |
|
|
3108 for a in range(StateA, EndCount): |
|
|
3109 for b in range(StateB, EndCount): |
|
|
3110 for c in range(StateC, EndCount): |
|
|
3111 for d in range(StateD, EndCount): |
|
|
3112 for x in range(StateW, WordCount): |
|
|
3113 if SaveSwitch is True: |
|
|
3114 WriteSave = [] |
|
|
3115 FILE = open(save, 'w') |
|
|
3116 WriteSave.append(str(cmd)) |
|
|
3117 WriteSave.append(str(dictionary)) |
|
|
3118 WriteSave.append(str(MixCustom)) |
|
|
3119 WriteSave.append(str(Custom)) |
|
|
3120 WriteSave.append(str(ExhSwitch)) |
|
|
3121 WriteSave.append(str(StdoutSwitch)) |
|
|
3122 WriteSave.append(str(usernames)) |
|
|
3123 WriteSave.append(str(UserSwitch)) |
|
|
3124 WriteSave.append(str(AlphaSwitch)) |
|
|
3125 WriteSave.append(str(BWSwitch)) |
|
|
3126 WriteSave.append(str(CapsSwitch)) |
|
|
3127 WriteSave.append(str(L337Switch)) |
|
|
3128 WriteSave.append(str(MD5Switch)) |
|
|
3129 WriteSave.append(str(NumberSwitch)) |
|
|
3130 WriteSave.append(str(RegularSwitch)) |
|
|
3131 WriteSave.append(str(SpecialSwitch)) |
|
|
3132 WriteSave.append(str(Letters)) |
|
|
3133 WriteSave.append(str(Numbers)) |
|
|
3134 WriteSave.append(str(Specials)) |
|
|
3135 WriteSave.append(str(wep5)) |
|
|
3136 WriteSave.append(str(wep13)) |
|
|
3137 WriteSave.append(str(SESwitch)) |
|
|
3138 WriteSave.append(str(u)) |
|
|
3139 WriteSave.append(str(x)) |
|
|
3140 WriteSave.append(str(a)) |
|
|
3141 WriteSave.append(str(b)) |
|
|
3142 WriteSave.append(str(c)) |
|
|
3143 WriteSave.append(str(d)) |
|
|
3144 for WriteStates in WriteSave: |
|
|
3145 FILE.write(WriteStates + "\n") |
|
|
3146 FILE.close() |
|
|
3147 NewShowWord = Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] |
|
|
3148 print(NewShowWord.replace(" ", "")) |
|
|
3149 |
|
|
3150 if ExhSwitch is False: |
|
|
3151 NewShowWord = Char1[c] + Char1[a] + Char1[b] + Char1[d] + ShowWord[x] |
|
|
3152 print(NewShowWord.replace(" ", "")) |
|
|
3153 |
|
|
3154 NewShowWord = ShowWord[x] + Char1[d] + Char1[b] + Char1[a] + Char1[c] |
|
|
3155 print(NewShowWord.replace(" ", "")) |
|
|
3156 |
|
|
3157 def SBF6(): |
|
|
3158 WordCount = 0 |
|
|
3159 for CountWords in ShowWord: |
|
|
3160 WordCount += 1 |
|
|
3161 if NoChar is True: |
|
|
3162 sys.exit(0) |
|
|
3163 for u in range(StateU, UserCount): |
|
|
3164 if length_start > 5: |
|
|
3165 break |
|
|
3166 if length_end < 5: |
|
|
3167 sys.exit(0) |
|
|
3168 for a in range(StateA, EndCount): |
|
|
3169 for b in range(StateB, EndCount): |
|
|
3170 for c in range(StateC, EndCount): |
|
|
3171 for d in range(StateD, EndCount): |
|
|
3172 for e in range(StateE, EndCount): |
|
|
3173 for x in range(StateW, WordCount): |
|
|
3174 if SaveSwitch is True: |
|
|
3175 WriteSave = [] |
|
|
3176 FILE = open(save, 'w') |
|
|
3177 WriteSave.append(str(cmd)) |
|
|
3178 WriteSave.append(str(dictionary)) |
|
|
3179 WriteSave.append(str(MixCustom)) |
|
|
3180 WriteSave.append(str(Custom)) |
|
|
3181 WriteSave.append(str(ExhSwitch)) |
|
|
3182 WriteSave.append(str(StdoutSwitch)) |
|
|
3183 WriteSave.append(str(usernames)) |
|
|
3184 WriteSave.append(str(UserSwitch)) |
|
|
3185 WriteSave.append(str(AlphaSwitch)) |
|
|
3186 WriteSave.append(str(BWSwitch)) |
|
|
3187 WriteSave.append(str(CapsSwitch)) |
|
|
3188 WriteSave.append(str(L337Switch)) |
|
|
3189 WriteSave.append(str(MD5Switch)) |
|
|
3190 WriteSave.append(str(NumberSwitch)) |
|
|
3191 WriteSave.append(str(RegularSwitch)) |
|
|
3192 WriteSave.append(str(SpecialSwitch)) |
|
|
3193 WriteSave.append(str(Letters)) |
|
|
3194 WriteSave.append(str(Numbers)) |
|
|
3195 WriteSave.append(str(Specials)) |
|
|
3196 WriteSave.append(str(wep5)) |
|
|
3197 WriteSave.append(str(wep13)) |
|
|
3198 WriteSave.append(str(SESwitch)) |
|
|
3199 WriteSave.append(str(u)) |
|
|
3200 WriteSave.append(str(x)) |
|
|
3201 WriteSave.append(str(a)) |
|
|
3202 WriteSave.append(str(b)) |
|
|
3203 WriteSave.append(str(c)) |
|
|
3204 WriteSave.append(str(d)) |
|
|
3205 WriteSave.append(str(e)) |
|
|
3206 for WriteStates in WriteSave: |
|
|
3207 FILE.write(WriteStates + "\n") |
|
|
3208 FILE.close() |
|
|
3209 NewShowWord = Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] |
|
|
3210 print(NewShowWord.replace(" ", "")) |
|
|
3211 |
|
|
3212 if ExhSwitch is False: |
|
|
3213 NewShowWord = Char1[d] + Char1[b] + ShowWord[x] + Char1[a] + Char1[c] + Char1[e] |
|
|
3214 print(NewShowWord.replace(" ", "")) |
|
|
3215 |
|
|
3216 NewShowWord = Char1[e] + Char1[c] + Char1[a] + Char1[b] + Char1[d] + ShowWord[x] |
|
|
3217 print(NewShowWord.replace(" ", "")) |
|
|
3218 |
|
|
3219 NewShowWord = ShowWord[x] + Char1[d] + Char1[b] + Char1[a] + Char1[c] + Char1[e] |
|
|
3220 print(NewShowWord.replace(" ", "")) |
|
|
3221 |
|
|
3222 def SBF7(): |
|
|
3223 WordCount = 0 |
|
|
3224 for CountWords in ShowWord: |
|
|
3225 WordCount += 1 |
|
|
3226 if NoChar is True: |
|
|
3227 sys.exit(0) |
|
|
3228 for u in range(StateU, UserCount): |
|
|
3229 if length_start > 6: |
|
|
3230 break |
|
|
3231 if length_end < 6: |
|
|
3232 sys.exit(0) |
|
|
3233 for a in range(StateA, EndCount): |
|
|
3234 for b in range(StateB, EndCount): |
|
|
3235 for c in range(StateC, EndCount): |
|
|
3236 for d in range(StateD, EndCount): |
|
|
3237 for e in range(StateE, EndCount): |
|
|
3238 for f in range(StateF, EndCount): |
|
|
3239 for x in range(StateW, WordCount): |
|
|
3240 if SaveSwitch is True: |
|
|
3241 WriteSave = [] |
|
|
3242 FILE = open(save, 'w') |
|
|
3243 WriteSave.append(str(cmd)) |
|
|
3244 WriteSave.append(str(dictionary)) |
|
|
3245 WriteSave.append(str(MixCustom)) |
|
|
3246 WriteSave.append(str(Custom)) |
|
|
3247 WriteSave.append(str(ExhSwitch)) |
|
|
3248 WriteSave.append(str(StdoutSwitch)) |
|
|
3249 WriteSave.append(str(usernames)) |
|
|
3250 WriteSave.append(str(UserSwitch)) |
|
|
3251 WriteSave.append(str(AlphaSwitch)) |
|
|
3252 WriteSave.append(str(BWSwitch)) |
|
|
3253 WriteSave.append(str(CapsSwitch)) |
|
|
3254 WriteSave.append(str(L337Switch)) |
|
|
3255 WriteSave.append(str(MD5Switch)) |
|
|
3256 WriteSave.append(str(NumberSwitch)) |
|
|
3257 WriteSave.append(str(RegularSwitch)) |
|
|
3258 WriteSave.append(str(SpecialSwitch)) |
|
|
3259 WriteSave.append(str(Letters)) |
|
|
3260 WriteSave.append(str(Numbers)) |
|
|
3261 WriteSave.append(str(Specials)) |
|
|
3262 WriteSave.append(str(wep5)) |
|
|
3263 WriteSave.append(str(wep13)) |
|
|
3264 WriteSave.append(str(SESwitch)) |
|
|
3265 WriteSave.append(str(u)) |
|
|
3266 WriteSave.append(str(x)) |
|
|
3267 WriteSave.append(str(a)) |
|
|
3268 WriteSave.append(str(b)) |
|
|
3269 WriteSave.append(str(c)) |
|
|
3270 WriteSave.append(str(d)) |
|
|
3271 WriteSave.append(str(e)) |
|
|
3272 WriteSave.append(str(f)) |
|
|
3273 for WriteStates in WriteSave: |
|
|
3274 FILE.write(WriteStates + "\n") |
|
|
3275 FILE.close() |
|
|
3276 NewShowWord = Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] + Char1[f] |
|
|
3277 print(NewShowWord.replace(" ", "")) |
|
|
3278 |
|
|
3279 if ExhSwitch is False: |
|
|
3280 NewShowWord = Char1[e] + Char1[c] + Char1[a] + Char1[b] + Char1[d] + Char1[f] + ShowWord[x] |
|
|
3281 print(NewShowWord.replace(" ", "")) |
|
|
3282 |
|
|
3283 NewShowWord = ShowWord[x] + Char1[f] + Char1[d] + Char1[b] + Char1[a] + Char1[c] + Char1[e] |
|
|
3284 print(NewShowWord.replace(" ", "")) |
|
|
3285 |
|
|
3286 def SBF8(): |
|
|
3287 WordCount = 0 |
|
|
3288 for CountWords in ShowWord: |
|
|
3289 WordCount += 1 |
|
|
3290 if NoChar is True: |
|
|
3291 sys.exit(0) |
|
|
3292 for u in range(StateU, UserCount): |
|
|
3293 if length_start > 7: |
|
|
3294 break |
|
|
3295 if length_end < 7: |
|
|
3296 sys.exit(0) |
|
|
3297 for a in range(StateA, EndCount): |
|
|
3298 for b in range(StateB, EndCount): |
|
|
3299 for c in range(StateC, EndCount): |
|
|
3300 for d in range(StateD, EndCount): |
|
|
3301 for e in range(StateE, EndCount): |
|
|
3302 for f in range(StateF, EndCount): |
|
|
3303 for g in range(StateG, EndCount): |
|
|
3304 for x in range(StateW, WordCount): |
|
|
3305 if SaveSwitch is True: |
|
|
3306 WriteSave = [] |
|
|
3307 FILE = open(save, 'w') |
|
|
3308 WriteSave.append(str(cmd)) |
|
|
3309 WriteSave.append(str(dictionary)) |
|
|
3310 WriteSave.append(str(MixCustom)) |
|
|
3311 WriteSave.append(str(Custom)) |
|
|
3312 WriteSave.append(str(ExhSwitch)) |
|
|
3313 WriteSave.append(str(StdoutSwitch)) |
|
|
3314 WriteSave.append(str(usernames)) |
|
|
3315 WriteSave.append(str(UserSwitch)) |
|
|
3316 WriteSave.append(str(AlphaSwitch)) |
|
|
3317 WriteSave.append(str(BWSwitch)) |
|
|
3318 WriteSave.append(str(CapsSwitch)) |
|
|
3319 WriteSave.append(str(L337Switch)) |
|
|
3320 WriteSave.append(str(MD5Switch)) |
|
|
3321 WriteSave.append(str(NumberSwitch)) |
|
|
3322 WriteSave.append(str(RegularSwitch)) |
|
|
3323 WriteSave.append(str(SpecialSwitch)) |
|
|
3324 WriteSave.append(str(Letters)) |
|
|
3325 WriteSave.append(str(Numbers)) |
|
|
3326 WriteSave.append(str(Specials)) |
|
|
3327 WriteSave.append(str(wep5)) |
|
|
3328 WriteSave.append(str(wep13)) |
|
|
3329 WriteSave.append(str(SESwitch)) |
|
|
3330 WriteSave.append(str(u)) |
|
|
3331 WriteSave.append(str(x)) |
|
|
3332 WriteSave.append(str(a)) |
|
|
3333 WriteSave.append(str(b)) |
|
|
3334 WriteSave.append(str(c)) |
|
|
3335 WriteSave.append(str(d)) |
|
|
3336 WriteSave.append(str(e)) |
|
|
3337 WriteSave.append(str(f)) |
|
|
3338 WriteSave.append(str(g)) |
|
|
3339 for WriteStates in WriteSave: |
|
|
3340 FILE.write(WriteStates + "\n") |
|
|
3341 FILE.close() |
|
|
3342 NewShowWord = Char1[g] + Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] + Char1[f] |
|
|
3343 print(NewShowWord.replace(" ", "")) |
|
|
3344 |
|
|
3345 if ExhSwitch is False: |
|
|
3346 NewShowWord = Char1[f] + Char1[d] + Char1[b] + ShowWord[x] + Char1[a] + Char1[c] + Char1[e] + Char1[g] |
|
|
3347 print(NewShowWord.replace(" ", "")) |
|
|
3348 |
|
|
3349 NewShowWord = Char1[g] + Char1[e] + Char1[c] + Char1[a] + Char1[b] + Char1[d] + Char1[f] + ShowWord[x] |
|
|
3350 print(NewShowWord.replace(" ", "")) |
|
|
3351 |
|
|
3352 NewShowWord = ShowWord[x] + Char1[f] + Char1[d] + Char1[b] + Char1[a] + Char1[c] + Char1[e] + Char1[g] |
|
|
3353 print(NewShowWord.replace(" ", "")) |
|
|
3354 |
|
|
3355 def SBF9(): |
|
|
3356 WordCount = 0 |
|
|
3357 for CountWords in ShowWord: |
|
|
3358 WordCount += 1 |
|
|
3359 if NoChar is True: |
|
|
3360 sys.exit(0) |
|
|
3361 for u in range(StateU, UserCount): |
|
|
3362 if length_start > 8: |
|
|
3363 break |
|
|
3364 if length_end < 8: |
|
|
3365 sys.exit(0) |
|
|
3366 for a in range(StateA, EndCount): |
|
|
3367 for b in range(StateB, EndCount): |
|
|
3368 for c in range(StateC, EndCount): |
|
|
3369 for d in range(StateD, EndCount): |
|
|
3370 for e in range(StateE, EndCount): |
|
|
3371 for f in range(StateF, EndCount): |
|
|
3372 for g in range(StateG, EndCount): |
|
|
3373 for h in range(StateH, EndCount): |
|
|
3374 for x in range(StateW, WordCount): |
|
|
3375 if SaveSwitch is True: |
|
|
3376 WriteSave = [] |
|
|
3377 FILE = open(save, 'w') |
|
|
3378 WriteSave.append(str(cmd)) |
|
|
3379 WriteSave.append(str(dictionary)) |
|
|
3380 WriteSave.append(str(MixCustom)) |
|
|
3381 WriteSave.append(str(Custom)) |
|
|
3382 WriteSave.append(str(ExhSwitch)) |
|
|
3383 WriteSave.append(str(StdoutSwitch)) |
|
|
3384 WriteSave.append(str(usernames)) |
|
|
3385 WriteSave.append(str(UserSwitch)) |
|
|
3386 WriteSave.append(str(AlphaSwitch)) |
|
|
3387 WriteSave.append(str(BWSwitch)) |
|
|
3388 WriteSave.append(str(CapsSwitch)) |
|
|
3389 WriteSave.append(str(L337Switch)) |
|
|
3390 WriteSave.append(str(MD5Switch)) |
|
|
3391 WriteSave.append(str(NumberSwitch)) |
|
|
3392 WriteSave.append(str(RegularSwitch)) |
|
|
3393 WriteSave.append(str(SpecialSwitch)) |
|
|
3394 WriteSave.append(str(Letters)) |
|
|
3395 WriteSave.append(str(Numbers)) |
|
|
3396 WriteSave.append(str(Specials)) |
|
|
3397 WriteSave.append(str(wep5)) |
|
|
3398 WriteSave.append(str(wep13)) |
|
|
3399 WriteSave.append(str(SESwitch)) |
|
|
3400 WriteSave.append(str(u)) |
|
|
3401 WriteSave.append(str(x)) |
|
|
3402 WriteSave.append(str(a)) |
|
|
3403 WriteSave.append(str(b)) |
|
|
3404 WriteSave.append(str(c)) |
|
|
3405 WriteSave.append(str(d)) |
|
|
3406 WriteSave.append(str(e)) |
|
|
3407 WriteSave.append(str(f)) |
|
|
3408 WriteSave.append(str(g)) |
|
|
3409 WriteSave.append(str(h)) |
|
|
3410 for WriteStates in WriteSave: |
|
|
3411 FILE.write(WriteStates + "\n") |
|
|
3412 FILE.close() |
|
|
3413 NewShowWord = Char1[g] + Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] + Char1[f] + Char1[h] |
|
|
3414 print(NewShowWord.replace(" ", "")) |
|
|
3415 |
|
|
3416 if ExhSwitch is False: |
|
|
3417 NewShowWord = Char1[g] + Char1[e] + Char1[c] + Char1[a] +Char1[b] + Char1[d] + Char1[f] + Char1[h] + ShowWord[x] |
|
|
3418 print(NewShowWord.replace(" ", "")) |
|
|
3419 |
|
|
3420 NewShowWord = ShowWord[x] + Char1[h] + Char1[f] + Char1[d] + Char1[b] + Char1[a] + Char1[c] + Char1[e] + Char1[g] |
|
|
3421 print(NewShowWord.replace(" ", "")) |
|
|
3422 |
|
|
3423 def SBF10(): |
|
|
3424 WordCount = 0 |
|
|
3425 for CountWords in ShowWord: |
|
|
3426 WordCount += 1 |
|
|
3427 if NoChar is True: |
|
|
3428 sys.exit(0) |
|
|
3429 for u in range(StateU, UserCount): |
|
|
3430 if length_start > 9: |
|
|
3431 break |
|
|
3432 if length_end < 9: |
|
|
3433 sys.exit(0) |
|
|
3434 for a in range(StateA, EndCount): |
|
|
3435 for b in range(StateB, EndCount): |
|
|
3436 for c in range(StateC, EndCount): |
|
|
3437 for d in range(StateD, EndCount): |
|
|
3438 for e in range(StateE, EndCount): |
|
|
3439 for f in range(StateF, EndCount): |
|
|
3440 for g in range(StateG, EndCount): |
|
|
3441 for h in range(StateH, EndCount): |
|
|
3442 for i in range(StateI, EndCount): |
|
|
3443 for x in range(StateW, WordCount): |
|
|
3444 if SaveSwitch is True: |
|
|
3445 WriteSave = [] |
|
|
3446 FILE = open(save, 'w') |
|
|
3447 WriteSave.append(str(cmd)) |
|
|
3448 WriteSave.append(str(dictionary)) |
|
|
3449 WriteSave.append(str(MixCustom)) |
|
|
3450 WriteSave.append(str(Custom)) |
|
|
3451 WriteSave.append(str(ExhSwitch)) |
|
|
3452 WriteSave.append(str(StdoutSwitch)) |
|
|
3453 WriteSave.append(str(usernames)) |
|
|
3454 WriteSave.append(str(UserSwitch)) |
|
|
3455 WriteSave.append(str(AlphaSwitch)) |
|
|
3456 WriteSave.append(str(BWSwitch)) |
|
|
3457 WriteSave.append(str(CapsSwitch)) |
|
|
3458 WriteSave.append(str(L337Switch)) |
|
|
3459 WriteSave.append(str(MD5Switch)) |
|
|
3460 WriteSave.append(str(NumberSwitch)) |
|
|
3461 WriteSave.append(str(RegularSwitch)) |
|
|
3462 WriteSave.append(str(SpecialSwitch)) |
|
|
3463 WriteSave.append(str(Letters)) |
|
|
3464 WriteSave.append(str(Numbers)) |
|
|
3465 WriteSave.append(str(Specials)) |
|
|
3466 WriteSave.append(str(wep5)) |
|
|
3467 WriteSave.append(str(wep13)) |
|
|
3468 WriteSave.append(str(SESwitch)) |
|
|
3469 WriteSave.append(str(u)) |
|
|
3470 WriteSave.append(str(x)) |
|
|
3471 WriteSave.append(str(a)) |
|
|
3472 WriteSave.append(str(b)) |
|
|
3473 WriteSave.append(str(c)) |
|
|
3474 WriteSave.append(str(d)) |
|
|
3475 WriteSave.append(str(e)) |
|
|
3476 WriteSave.append(str(f)) |
|
|
3477 WriteSave.append(str(g)) |
|
|
3478 WriteSave.append(str(h)) |
|
|
3479 WriteSave.append(str(i)) |
|
|
3480 for WriteStates in WriteSave: |
|
|
3481 FILE.write(WriteStates + "\n") |
|
|
3482 FILE.close() |
|
|
3483 NewShowWord = Char1[i] + Char1[g] + Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] + Char1[f] + Char1[h] |
|
|
3484 print(NewShowWord.replace(" ", "")) |
|
|
3485 |
|
|
3486 if ExhSwitch is False: |
|
|
3487 NewShowWord = Char1[h] + Char1[f] + Char1[d] + Char1[b] + ShowWord[x] + Char1[a] + Char1[c] + Char1[e] + Char1[g] + Char1[i] |
|
|
3488 print(NewShowWord.replace(" ", "")) |
|
|
3489 |
|
|
3490 NewShowWord = Char1[i] + Char1[g] + Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] + Char1[f] + Char1[h] + ShowWord[x] |
|
|
3491 print(NewShowWord.replace(" ", "")) |
|
|
3492 |
|
|
3493 NewShowWord = ShowWord[x] + Char1[h] + Char1[f] + Char1[d] + Char1[b] + Char1[a] + Char1[c] + Char1[e] + Char1[g] + Char1[i] |
|
|
3494 print(NewShowWord.replace(" ", "")) |
|
|
3495 |
|
|
3496 def SBF11(): |
|
|
3497 WordCount = 0 |
|
|
3498 for CountWords in ShowWord: |
|
|
3499 WordCount += 1 |
|
|
3500 if NoChar is True: |
|
|
3501 sys.exit(0) |
|
|
3502 for u in range(StateU, UserCount): |
|
|
3503 if length_start > 10: |
|
|
3504 break |
|
|
3505 if length_end < 10: |
|
|
3506 sys.exit(0) |
|
|
3507 for a in range(StateA, EndCount): |
|
|
3508 for b in range(StateB, EndCount): |
|
|
3509 for c in range(StateC, EndCount): |
|
|
3510 for d in range(StateD, EndCount): |
|
|
3511 for e in range(StateE, EndCount): |
|
|
3512 for f in range(StateF, EndCount): |
|
|
3513 for g in range(StateG, EndCount): |
|
|
3514 for h in range(StateH, EndCount): |
|
|
3515 for i in range(StateI, EndCount): |
|
|
3516 for j in range(StateJ, EndCount): |
|
|
3517 for x in range(StateW, WordCount): |
|
|
3518 if SaveSwitch is True: |
|
|
3519 WriteSave = [] |
|
|
3520 FILE = open(save, 'w') |
|
|
3521 WriteSave.append(str(cmd)) |
|
|
3522 WriteSave.append(str(dictionary)) |
|
|
3523 WriteSave.append(str(MixCustom)) |
|
|
3524 WriteSave.append(str(Custom)) |
|
|
3525 WriteSave.append(str(ExhSwitch)) |
|
|
3526 WriteSave.append(str(StdoutSwitch)) |
|
|
3527 WriteSave.append(str(usernames)) |
|
|
3528 WriteSave.append(str(UserSwitch)) |
|
|
3529 WriteSave.append(str(AlphaSwitch)) |
|
|
3530 WriteSave.append(str(BWSwitch)) |
|
|
3531 WriteSave.append(str(CapsSwitch)) |
|
|
3532 WriteSave.append(str(L337Switch)) |
|
|
3533 WriteSave.append(str(MD5Switch)) |
|
|
3534 WriteSave.append(str(NumberSwitch)) |
|
|
3535 WriteSave.append(str(RegularSwitch)) |
|
|
3536 WriteSave.append(str(SpecialSwitch)) |
|
|
3537 WriteSave.append(str(Letters)) |
|
|
3538 WriteSave.append(str(Numbers)) |
|
|
3539 WriteSave.append(str(Specials)) |
|
|
3540 WriteSave.append(str(wep5)) |
|
|
3541 WriteSave.append(str(wep13)) |
|
|
3542 WriteSave.append(str(SESwitch)) |
|
|
3543 WriteSave.append(str(u)) |
|
|
3544 WriteSave.append(str(x)) |
|
|
3545 WriteSave.append(str(a)) |
|
|
3546 WriteSave.append(str(b)) |
|
|
3547 WriteSave.append(str(c)) |
|
|
3548 WriteSave.append(str(d)) |
|
|
3549 WriteSave.append(str(e)) |
|
|
3550 WriteSave.append(str(f)) |
|
|
3551 WriteSave.append(str(g)) |
|
|
3552 WriteSave.append(str(h)) |
|
|
3553 WriteSave.append(str(i)) |
|
|
3554 WriteSave.append(str(j)) |
|
|
3555 for WriteStates in WriteSave: |
|
|
3556 FILE.write(WriteStates + "\n") |
|
|
3557 FILE.close() |
|
|
3558 NewShowWord = Char1[i] + Char1[g] + Char1[e] + Char1[c] + Char1[a] + ShowWord[x] + Char1[b] + Char1[d] + Char1[f] + Char1[h] + Char1[j] |
|
|
3559 print(NewShowWord.replace(" ", "")) |
|
|
3560 |
|
|
3561 if ExhSwitch is False: |
|
|
3562 NewShowWord = Char1[i] + Char1[g] + Char1[e] + Char1[c] + Char1[a] + Char1[b] + Char1[d] + Char1[f] + Char1[h] + Char1[j] + ShowWord[x] |
|
|
3563 print(NewShowWord.replace(" ", "")) |
|
|
3564 |
|
|
3565 NewShowWord = ShowWord[x] + Char1[j] + Char1[h] + Char1[f] + Char1[d] + Char1[b] + Char1[a] + Char1[c] + Char1[e] + Char1[g] + Char1[i] |
|
|
3566 print(NewShowWord.replace(" ", "")) |
|
|
3567 |
|
|
3568 if Create is True: |
|
|
3569 CFILE = open("splicex.create", 'w') |
|
|
3570 for WCreate in ShowWord: |
|
|
3571 CFILE.write(WCreate + "\n") |
|
|
3572 CFILE.close() |
|
|
3573 sys.exit(0) |
|
|
3574 |
|
|
3575 if RestoreSwitch is False: |
|
|
3576 StateCount = 0 |
|
|
3577 if RestoreSwitch is False and StdoutSwitch is False: |
|
|
3578 StateU = 0 |
|
|
3579 StateW = 0 |
|
|
3580 StateA = 0 |
|
|
3581 StateB = 0 |
|
|
3582 StateC = 0 |
|
|
3583 StateD = 0 |
|
|
3584 StateE = 0 |
|
|
3585 StateF = 0 |
|
|
3586 StateG = 0 |
|
|
3587 StateH = 0 |
|
|
3588 StateI = 0 |
|
|
3589 StateJ = 0 |
|
|
3590 BF1() |
|
|
3591 BF2() |
|
|
3592 BF3() |
|
|
3593 BF4() |
|
|
3594 BF5() |
|
|
3595 BF6() |
|
|
3596 BF7() |
|
|
3597 BF8() |
|
|
3598 BF9() |
|
|
3599 BF10() |
|
|
3600 BF11() |
|
689
|
3601 sys.exit(SpliceX + " unable to find password") |
|
688
|
3602 |
|
|
3603 if StateCount == 22 and RestoreSwitch is True and StdoutSwitch is False: |
|
|
3604 StateU = int(State[22]) |
|
|
3605 StateW = 0 |
|
|
3606 StateA = 0 |
|
|
3607 StateB = 0 |
|
|
3608 StateC = 0 |
|
|
3609 StateD = 0 |
|
|
3610 StateE = 0 |
|
|
3611 StateF = 0 |
|
|
3612 StateG = 0 |
|
|
3613 StateH = 0 |
|
|
3614 StateI = 0 |
|
|
3615 StateJ = 0 |
|
|
3616 BF1() |
|
|
3617 StateW = 0 |
|
|
3618 StateA = 0 |
|
|
3619 StateB = 0 |
|
|
3620 StateC = 0 |
|
|
3621 StateD = 0 |
|
|
3622 StateE = 0 |
|
|
3623 StateF = 0 |
|
|
3624 StateG = 0 |
|
|
3625 StateH = 0 |
|
|
3626 StateI = 0 |
|
|
3627 StateJ = 0 |
|
|
3628 BF2() |
|
|
3629 BF3() |
|
|
3630 BF4() |
|
|
3631 BF5() |
|
|
3632 BF6() |
|
|
3633 BF7() |
|
|
3634 BF8() |
|
|
3635 BF9() |
|
|
3636 BF10() |
|
|
3637 BF11() |
|
689
|
3638 sys.exit(SpliceX + " unable to find password") |
|
688
|
3639 if StateCount == 21 and RestoreSwitch is True and StdoutSwitch is False: |
|
|
3640 StateU = int(State[22]) |
|
|
3641 StateW = int(State[23]) |
|
|
3642 StateA = 0 |
|
|
3643 StateB = 0 |
|
|
3644 StateC = 0 |
|
|
3645 StateD = 0 |
|
|
3646 StateE = 0 |
|
|
3647 StateF = 0 |
|
|
3648 StateG = 0 |
|
|
3649 StateH = 0 |
|
|
3650 StateI = 0 |
|
|
3651 StateJ = 0 |
|
|
3652 BF1() |
|
|
3653 StateW = 0 |
|
|
3654 StateA = 0 |
|
|
3655 StateB = 0 |
|
|
3656 StateC = 0 |
|
|
3657 StateD = 0 |
|
|
3658 StateE = 0 |
|
|
3659 StateF = 0 |
|
|
3660 StateG = 0 |
|
|
3661 StateH = 0 |
|
|
3662 StateI = 0 |
|
|
3663 StateJ = 0 |
|
|
3664 BF2() |
|
|
3665 BF3() |
|
|
3666 BF4() |
|
|
3667 BF5() |
|
|
3668 BF6() |
|
|
3669 BF7() |
|
|
3670 BF8() |
|
|
3671 BF9() |
|
|
3672 BF10() |
|
|
3673 BF11() |
|
689
|
3674 sys.exit(SpliceX + " unable to find password") |
|
688
|
3675 elif StateCount == 24 and RestoreSwitch is True and StdoutSwitch is False: |
|
|
3676 StateU = int(State[22]) |
|
|
3677 StateW = int(State[23]) |
|
|
3678 StateA = int(State[24]) |
|
|
3679 StateB = 0 |
|
|
3680 StateC = 0 |
|
|
3681 StateD = 0 |
|
|
3682 StateE = 0 |
|
|
3683 StateF = 0 |
|
|
3684 StateG = 0 |
|
|
3685 StateH = 0 |
|
|
3686 StateI = 0 |
|
|
3687 StateJ = 0 |
|
|
3688 BF2() |
|
|
3689 StateW = 0 |
|
|
3690 StateA = 0 |
|
|
3691 StateB = 0 |
|
|
3692 StateC = 0 |
|
|
3693 StateD = 0 |
|
|
3694 StateE = 0 |
|
|
3695 StateF = 0 |
|
|
3696 StateG = 0 |
|
|
3697 StateH = 0 |
|
|
3698 StateI = 0 |
|
|
3699 StateJ = 0 |
|
|
3700 BF3() |
|
|
3701 BF4() |
|
|
3702 BF5() |
|
|
3703 BF6() |
|
|
3704 BF7() |
|
|
3705 BF8() |
|
|
3706 BF9() |
|
|
3707 BF10() |
|
|
3708 BF11() |
|
689
|
3709 sys.exit(SpliceX + " unable to find password") |
|
688
|
3710 elif StateCount == 25 and RestoreSwitch is True and StdoutSwitch is False: |
|
|
3711 StateU = int(State[22]) |
|
|
3712 StateW = int(State[23]) |
|
|
3713 StateA = int(State[24]) |
|
|
3714 StateB = int(State[25]) |
|
|
3715 StateC = 0 |
|
|
3716 StateD = 0 |
|
|
3717 StateE = 0 |
|
|
3718 StateF = 0 |
|
|
3719 StateG = 0 |
|
|
3720 StateH = 0 |
|
|
3721 StateI = 0 |
|
|
3722 StateJ = 0 |
|
|
3723 BF3() |
|
|
3724 StateW = 0 |
|
|
3725 StateA = 0 |
|
|
3726 StateB = 0 |
|
|
3727 StateC = 0 |
|
|
3728 StateD = 0 |
|
|
3729 StateE = 0 |
|
|
3730 StateF = 0 |
|
|
3731 StateG = 0 |
|
|
3732 StateH = 0 |
|
|
3733 StateI = 0 |
|
|
3734 StateJ = 0 |
|
|
3735 BF4() |
|
|
3736 BF5() |
|
|
3737 BF6() |
|
|
3738 BF7() |
|
|
3739 BF8() |
|
|
3740 BF9() |
|
|
3741 BF10() |
|
|
3742 BF11() |
|
689
|
3743 sys.exit(SpliceX + " unable to find password") |
|
688
|
3744 elif StateCount == 26 and RestoreSwitch is True and StdoutSwitch is False: |
|
|
3745 StateU = int(State[22]) |
|
|
3746 StateW = int(State[23]) |
|
|
3747 StateA = int(State[24]) |
|
|
3748 StateB = int(State[25]) |
|
|
3749 StateC = int(State[26]) |
|
|
3750 StateD = 0 |
|
|
3751 StateE = 0 |
|
|
3752 StateF = 0 |
|
|
3753 StateG = 0 |
|
|
3754 StateH = 0 |
|
|
3755 StateI = 0 |
|
|
3756 StateJ = 0 |
|
|
3757 BF4() |
|
|
3758 StateW = 0 |
|
|
3759 StateA = 0 |
|
|
3760 StateB = 0 |
|
|
3761 StateC = 0 |
|
|
3762 StateD = 0 |
|
|
3763 StateE = 0 |
|
|
3764 StateF = 0 |
|
|
3765 StateG = 0 |
|
|
3766 StateH = 0 |
|
|
3767 StateI = 0 |
|
|
3768 StateJ = 0 |
|
|
3769 BF5() |
|
|
3770 BF6() |
|
|
3771 BF7() |
|
|
3772 BF8() |
|
|
3773 BF9() |
|
|
3774 BF10() |
|
|
3775 BF11() |
|
689
|
3776 sys.exit(SpliceX + " unable to find password") |
|
688
|
3777 elif StateCount == 27 and RestoreSwitch is True and StdoutSwitch is False: |
|
|
3778 StateU = int(State[22]) |
|
|
3779 StateW = int(State[23]) |
|
|
3780 StateA = int(State[24]) |
|
|
3781 StateB = int(State[25]) |
|
|
3782 StateC = int(State[26]) |
|
|
3783 StateD = int(State[27]) |
|
|
3784 StateE = 0 |
|
|
3785 StateF = 0 |
|
|
3786 StateG = 0 |
|
|
3787 StateH = 0 |
|
|
3788 StateI = 0 |
|
|
3789 StateJ = 0 |
|
|
3790 BF5() |
|
|
3791 StateW = 0 |
|
|
3792 StateA = 0 |
|
|
3793 StateB = 0 |
|
|
3794 StateC = 0 |
|
|
3795 StateD = 0 |
|
|
3796 StateE = 0 |
|
|
3797 StateF = 0 |
|
|
3798 StateG = 0 |
|
|
3799 StateH = 0 |
|
|
3800 StateI = 0 |
|
|
3801 StateJ = 0 |
|
|
3802 BF6() |
|
|
3803 BF7() |
|
|
3804 BF8() |
|
|
3805 BF9() |
|
|
3806 BF10() |
|
|
3807 BF11() |
|
689
|
3808 sys.exit(SpliceX + " unable to find password") |
|
688
|
3809 elif StateCount == 28 and RestoreSwitch is True and StdoutSwitch is False: |
|
|
3810 StateU = int(State[22]) |
|
|
3811 StateW = int(State[23]) |
|
|
3812 StateA = int(State[24]) |
|
|
3813 StateB = int(State[25]) |
|
|
3814 StateC = int(State[26]) |
|
|
3815 StateD = int(State[27]) |
|
|
3816 StateE = int(State[28]) |
|
|
3817 StateF = 0 |
|
|
3818 StateG = 0 |
|
|
3819 StateH = 0 |
|
|
3820 StateI = 0 |
|
|
3821 StateJ = 0 |
|
|
3822 BF6() |
|
|
3823 StateW = 0 |
|
|
3824 StateA = 0 |
|
|
3825 StateB = 0 |
|
|
3826 StateC = 0 |
|
|
3827 StateD = 0 |
|
|
3828 StateE = 0 |
|
|
3829 StateF = 0 |
|
|
3830 StateG = 0 |
|
|
3831 StateH = 0 |
|
|
3832 StateI = 0 |
|
|
3833 StateJ = 0 |
|
|
3834 BF7() |
|
|
3835 BF8() |
|
|
3836 BF9() |
|
|
3837 BF10() |
|
|
3838 BF11() |
|
689
|
3839 sys.exit(SpliceX + " unable to find password") |
|
688
|
3840 elif StateCount == 29 and RestoreSwitch is True and StdoutSwitch is False: |
|
|
3841 StateU = int(State[22]) |
|
|
3842 StateW = int(State[23]) |
|
|
3843 StateA = int(State[24]) |
|
|
3844 StateB = int(State[25]) |
|
|
3845 StateC = int(State[26]) |
|
|
3846 StateD = int(State[27]) |
|
|
3847 StateE = int(State[28]) |
|
|
3848 StateF = int(State[29]) |
|
|
3849 StateG = 0 |
|
|
3850 StateH = 0 |
|
|
3851 StateI = 0 |
|
|
3852 StateJ = 0 |
|
|
3853 BF7() |
|
|
3854 StateW = 0 |
|
|
3855 StateA = 0 |
|
|
3856 StateB = 0 |
|
|
3857 StateC = 0 |
|
|
3858 StateD = 0 |
|
|
3859 StateE = 0 |
|
|
3860 StateF = 0 |
|
|
3861 StateG = 0 |
|
|
3862 StateH = 0 |
|
|
3863 StateI = 0 |
|
|
3864 StateJ = 0 |
|
|
3865 BF8() |
|
|
3866 BF9() |
|
|
3867 BF10() |
|
|
3868 BF11() |
|
689
|
3869 sys.exit(SpliceX + " unable to find password") |
|
688
|
3870 elif StateCount == 30 and RestoreSwitch is True and StdoutSwitch is False: |
|
|
3871 StateU = int(State[22]) |
|
|
3872 StateW = int(State[23]) |
|
|
3873 StateA = int(State[24]) |
|
|
3874 StateB = int(State[25]) |
|
|
3875 StateC = int(State[26]) |
|
|
3876 StateD = int(State[27]) |
|
|
3877 StateE = int(State[28]) |
|
|
3878 StateF = int(State[29]) |
|
|
3879 StateG = int(State[30]) |
|
|
3880 StateH = 0 |
|
|
3881 StateI = 0 |
|
|
3882 StateJ = 0 |
|
|
3883 BF8() |
|
|
3884 StateW = 0 |
|
|
3885 StateA = 0 |
|
|
3886 StateB = 0 |
|
|
3887 StateC = 0 |
|
|
3888 StateD = 0 |
|
|
3889 StateE = 0 |
|
|
3890 StateF = 0 |
|
|
3891 StateG = 0 |
|
|
3892 StateH = 0 |
|
|
3893 StateI = 0 |
|
|
3894 StateJ = 0 |
|
|
3895 BF9() |
|
|
3896 BF10() |
|
|
3897 BF11() |
|
689
|
3898 sys.exit(SpliceX + " unable to find password") |
|
688
|
3899 elif StateCount == 30 and RestoreSwitch is True and StdoutSwitch is False: |
|
|
3900 StateU = int(State[22]) |
|
|
3901 StateW = int(State[23]) |
|
|
3902 StateA = int(State[24]) |
|
|
3903 StateB = int(State[25]) |
|
|
3904 StateC = int(State[26]) |
|
|
3905 StateD = int(State[27]) |
|
|
3906 StateE = int(State[28]) |
|
|
3907 StateF = int(State[29]) |
|
|
3908 StateG = int(State[30]) |
|
|
3909 StateH = int(State[31]) |
|
|
3910 StateI = 0 |
|
|
3911 StateJ = 0 |
|
|
3912 BF9() |
|
|
3913 StateW = 0 |
|
|
3914 StateA = 0 |
|
|
3915 StateB = 0 |
|
|
3916 StateC = 0 |
|
|
3917 StateD = 0 |
|
|
3918 StateE = 0 |
|
|
3919 StateF = 0 |
|
|
3920 StateG = 0 |
|
|
3921 StateH = 0 |
|
|
3922 StateI = 0 |
|
|
3923 StateJ = 0 |
|
|
3924 BF10() |
|
|
3925 BF11() |
|
689
|
3926 sys.exit(SpliceX + " unable to find password") |
|
688
|
3927 elif StateCount == 32 and RestoreSwitch is True and StdoutSwitch is False: |
|
|
3928 StateU = int(State[22]) |
|
|
3929 StateW = int(State[23]) |
|
|
3930 StateA = int(State[24]) |
|
|
3931 StateB = int(State[25]) |
|
|
3932 StateC = int(State[26]) |
|
|
3933 StateD = int(State[27]) |
|
|
3934 StateE = int(State[28]) |
|
|
3935 StateF = int(State[29]) |
|
|
3936 StateG = int(State[30]) |
|
|
3937 StateH = int(State[31]) |
|
|
3938 StateI = int(State[32]) |
|
|
3939 StateJ = 0 |
|
|
3940 BF10() |
|
|
3941 StateW = 0 |
|
|
3942 StateA = 0 |
|
|
3943 StateB = 0 |
|
|
3944 StateC = 0 |
|
|
3945 StateD = 0 |
|
|
3946 StateE = 0 |
|
|
3947 StateF = 0 |
|
|
3948 StateG = 0 |
|
|
3949 StateH = 0 |
|
|
3950 StateI = 0 |
|
|
3951 StateJ = 0 |
|
|
3952 BF11() |
|
689
|
3953 sys.exit(SpliceX + " unable to find password") |
|
688
|
3954 elif StateCount == 33 and RestoreSwitch is True and StdoutSwitch is False: |
|
|
3955 StateU = int(State[22]) |
|
|
3956 StateW = int(State[23]) |
|
|
3957 StateA = int(State[24]) |
|
|
3958 StateB = int(State[25]) |
|
|
3959 StateC = int(State[26]) |
|
|
3960 StateD = int(State[27]) |
|
|
3961 StateE = int(State[28]) |
|
|
3962 StateF = int(State[29]) |
|
|
3963 StateG = int(State[30]) |
|
|
3964 StateH = int(State[31]) |
|
|
3965 StateI = int(State[32]) |
|
|
3966 StateJ = int(State[33]) |
|
|
3967 BF11() |
|
689
|
3968 sys.exit(SpliceX + " unable to find password") |
|
688
|
3969 |
|
|
3970 if RestoreSwitch is False and StdoutSwitch is True: |
|
|
3971 StateU = 0 |
|
|
3972 StateW = 0 |
|
|
3973 StateA = 0 |
|
|
3974 StateB = 0 |
|
|
3975 StateC = 0 |
|
|
3976 StateD = 0 |
|
|
3977 StateE = 0 |
|
|
3978 StateF = 0 |
|
|
3979 StateG = 0 |
|
|
3980 StateH = 0 |
|
|
3981 StateI = 0 |
|
|
3982 StateJ = 0 |
|
|
3983 SBF1() |
|
|
3984 SBF2() |
|
|
3985 SBF3() |
|
|
3986 SBF4() |
|
|
3987 SBF5() |
|
|
3988 SBF6() |
|
|
3989 SBF7() |
|
|
3990 SBF8() |
|
|
3991 SBF9() |
|
|
3992 SBF10() |
|
|
3993 SBF11() |
|
|
3994 sys.exit(0) |
|
|
3995 |
|
|
3996 if StateCount == 22 and RestoreSwitch is True and StdoutSwitch is True: |
|
|
3997 StateU = int(State[22]) |
|
|
3998 StateW = 0 |
|
|
3999 StateA = 0 |
|
|
4000 StateB = 0 |
|
|
4001 StateC = 0 |
|
|
4002 StateD = 0 |
|
|
4003 StateE = 0 |
|
|
4004 StateF = 0 |
|
|
4005 StateG = 0 |
|
|
4006 StateH = 0 |
|
|
4007 StateI = 0 |
|
|
4008 StateJ = 0 |
|
|
4009 SBF1() |
|
|
4010 StateW = 0 |
|
|
4011 StateA = 0 |
|
|
4012 StateB = 0 |
|
|
4013 StateC = 0 |
|
|
4014 StateD = 0 |
|
|
4015 StateE = 0 |
|
|
4016 StateF = 0 |
|
|
4017 StateG = 0 |
|
|
4018 StateH = 0 |
|
|
4019 StateI = 0 |
|
|
4020 StateJ = 0 |
|
|
4021 SBF2() |
|
|
4022 SBF3() |
|
|
4023 SBF4() |
|
|
4024 SBF5() |
|
|
4025 SBF6() |
|
|
4026 SBF7() |
|
|
4027 SBF8() |
|
|
4028 SBF9() |
|
|
4029 SBF10() |
|
|
4030 SBF11() |
|
|
4031 sys.exit(0) |
|
|
4032 if StateCount == 23 and RestoreSwitch is True and StdoutSwitch is True: |
|
|
4033 StateU = int(State[22]) |
|
|
4034 StateW = int(State[23]) |
|
|
4035 StateA = 0 |
|
|
4036 StateB = 0 |
|
|
4037 StateC = 0 |
|
|
4038 StateD = 0 |
|
|
4039 StateE = 0 |
|
|
4040 StateF = 0 |
|
|
4041 StateG = 0 |
|
|
4042 StateH = 0 |
|
|
4043 StateI = 0 |
|
|
4044 StateJ = 0 |
|
|
4045 SBF1() |
|
|
4046 StateW = 0 |
|
|
4047 StateA = 0 |
|
|
4048 StateB = 0 |
|
|
4049 StateC = 0 |
|
|
4050 StateD = 0 |
|
|
4051 StateE = 0 |
|
|
4052 StateF = 0 |
|
|
4053 StateG = 0 |
|
|
4054 StateH = 0 |
|
|
4055 StateI = 0 |
|
|
4056 StateJ = 0 |
|
|
4057 SBF2() |
|
|
4058 SBF3() |
|
|
4059 SBF4() |
|
|
4060 SBF5() |
|
|
4061 SBF6() |
|
|
4062 SBF7() |
|
|
4063 SBF8() |
|
|
4064 SBF9() |
|
|
4065 SBF10() |
|
|
4066 SBF11() |
|
|
4067 sys.exit(0) |
|
|
4068 elif StateCount == 24 and RestoreSwitch is True and StdoutSwitch is True: |
|
|
4069 StateU = int(State[22]) |
|
|
4070 StateW = int(State[23]) |
|
|
4071 StateA = int(State[24]) |
|
|
4072 StateB = 0 |
|
|
4073 StateC = 0 |
|
|
4074 StateD = 0 |
|
|
4075 StateE = 0 |
|
|
4076 StateF = 0 |
|
|
4077 StateG = 0 |
|
|
4078 StateH = 0 |
|
|
4079 StateI = 0 |
|
|
4080 StateJ = 0 |
|
|
4081 SBF2() |
|
|
4082 StateW = 0 |
|
|
4083 StateA = 0 |
|
|
4084 StateB = 0 |
|
|
4085 StateC = 0 |
|
|
4086 StateD = 0 |
|
|
4087 StateE = 0 |
|
|
4088 StateF = 0 |
|
|
4089 StateG = 0 |
|
|
4090 StateH = 0 |
|
|
4091 StateI = 0 |
|
|
4092 StateJ = 0 |
|
|
4093 SBF3() |
|
|
4094 SBF4() |
|
|
4095 SBF5() |
|
|
4096 SBF6() |
|
|
4097 SBF7() |
|
|
4098 SBF8() |
|
|
4099 SBF9() |
|
|
4100 SBF10() |
|
|
4101 SBF11() |
|
|
4102 sys.exit(0) |
|
|
4103 elif StateCount == 25 and RestoreSwitch is True and StdoutSwitch is True: |
|
|
4104 StateU = int(State[22]) |
|
|
4105 StateW = int(State[23]) |
|
|
4106 StateA = int(State[24]) |
|
|
4107 StateB = int(State[25]) |
|
|
4108 StateC = 0 |
|
|
4109 StateD = 0 |
|
|
4110 StateE = 0 |
|
|
4111 StateF = 0 |
|
|
4112 StateG = 0 |
|
|
4113 StateH = 0 |
|
|
4114 StateI = 0 |
|
|
4115 StateJ = 0 |
|
|
4116 SBF3() |
|
|
4117 StateW = 0 |
|
|
4118 StateA = 0 |
|
|
4119 StateB = 0 |
|
|
4120 StateC = 0 |
|
|
4121 StateD = 0 |
|
|
4122 StateE = 0 |
|
|
4123 StateF = 0 |
|
|
4124 StateG = 0 |
|
|
4125 StateH = 0 |
|
|
4126 StateI = 0 |
|
|
4127 StateJ = 0 |
|
|
4128 SBF4() |
|
|
4129 SBF5() |
|
|
4130 SBF6() |
|
|
4131 SBF7() |
|
|
4132 SBF8() |
|
|
4133 SBF9() |
|
|
4134 SBF10() |
|
|
4135 SBF11() |
|
|
4136 sys.exit(0) |
|
|
4137 elif StateCount == 25 and RestoreSwitch is True and StdoutSwitch is True: |
|
|
4138 StateU = int(State[22]) |
|
|
4139 StateW = int(State[23]) |
|
|
4140 StateA = int(State[24]) |
|
|
4141 StateB = int(State[25]) |
|
|
4142 StateC = int(State[26]) |
|
|
4143 StateD = 0 |
|
|
4144 StateE = 0 |
|
|
4145 StateF = 0 |
|
|
4146 StateG = 0 |
|
|
4147 StateH = 0 |
|
|
4148 StateI = 0 |
|
|
4149 StateJ = 0 |
|
|
4150 SBF4() |
|
|
4151 StateW = 0 |
|
|
4152 StateA = 0 |
|
|
4153 StateB = 0 |
|
|
4154 StateC = 0 |
|
|
4155 StateD = 0 |
|
|
4156 StateE = 0 |
|
|
4157 StateF = 0 |
|
|
4158 StateG = 0 |
|
|
4159 StateH = 0 |
|
|
4160 StateI = 0 |
|
|
4161 StateJ = 0 |
|
|
4162 SBF5() |
|
|
4163 SBF6() |
|
|
4164 SBF7() |
|
|
4165 SBF8() |
|
|
4166 SBF9() |
|
|
4167 SBF10() |
|
|
4168 SBF11() |
|
|
4169 sys.exit(0) |
|
|
4170 elif StateCount == 27 and RestoreSwitch is True and StdoutSwitch is True: |
|
|
4171 StateU = int(State[22]) |
|
|
4172 StateW = int(State[23]) |
|
|
4173 StateA = int(State[24]) |
|
|
4174 StateB = int(State[25]) |
|
|
4175 StateC = int(State[26]) |
|
|
4176 StateD = int(State[27]) |
|
|
4177 StateE = 0 |
|
|
4178 StateF = 0 |
|
|
4179 StateG = 0 |
|
|
4180 StateH = 0 |
|
|
4181 StateI = 0 |
|
|
4182 StateJ = 0 |
|
|
4183 SBF5() |
|
|
4184 StateW = 0 |
|
|
4185 StateA = 0 |
|
|
4186 StateB = 0 |
|
|
4187 StateC = 0 |
|
|
4188 StateD = 0 |
|
|
4189 StateE = 0 |
|
|
4190 StateF = 0 |
|
|
4191 StateG = 0 |
|
|
4192 StateH = 0 |
|
|
4193 StateI = 0 |
|
|
4194 StateJ = 0 |
|
|
4195 SBF6() |
|
|
4196 SBF7() |
|
|
4197 SBF8() |
|
|
4198 SBF9() |
|
|
4199 SBF10() |
|
|
4200 SBF11() |
|
|
4201 sys.exit(0) |
|
|
4202 elif StateCount == 28 and RestoreSwitch is True and StdoutSwitch is True: |
|
|
4203 StateU = int(State[22]) |
|
|
4204 StateW = int(State[23]) |
|
|
4205 StateA = int(State[24]) |
|
|
4206 StateB = int(State[25]) |
|
|
4207 StateC = int(State[26]) |
|
|
4208 StateD = int(State[27]) |
|
|
4209 StateE = int(State[28]) |
|
|
4210 StateF = 0 |
|
|
4211 StateG = 0 |
|
|
4212 StateH = 0 |
|
|
4213 StateI = 0 |
|
|
4214 StateJ = 0 |
|
|
4215 SBF6() |
|
|
4216 StateW = 0 |
|
|
4217 StateA = 0 |
|
|
4218 StateB = 0 |
|
|
4219 StateC = 0 |
|
|
4220 StateD = 0 |
|
|
4221 StateE = 0 |
|
|
4222 StateF = 0 |
|
|
4223 StateG = 0 |
|
|
4224 StateH = 0 |
|
|
4225 StateI = 0 |
|
|
4226 StateJ = 0 |
|
|
4227 SBF7() |
|
|
4228 SBF8() |
|
|
4229 SBF9() |
|
|
4230 SBF10() |
|
|
4231 SBF11() |
|
|
4232 sys.exit(0) |
|
|
4233 elif StateCount == 29 and RestoreSwitch is True and StdoutSwitch is True: |
|
|
4234 StateU = int(State[22]) |
|
|
4235 StateW = int(State[23]) |
|
|
4236 StateA = int(State[24]) |
|
|
4237 StateB = int(State[25]) |
|
|
4238 StateC = int(State[26]) |
|
|
4239 StateD = int(State[27]) |
|
|
4240 StateE = int(State[28]) |
|
|
4241 StateF = int(State[29]) |
|
|
4242 StateG = 0 |
|
|
4243 StateH = 0 |
|
|
4244 StateI = 0 |
|
|
4245 StateJ = 0 |
|
|
4246 SBF7() |
|
|
4247 StateW = 0 |
|
|
4248 StateA = 0 |
|
|
4249 StateB = 0 |
|
|
4250 StateC = 0 |
|
|
4251 StateD = 0 |
|
|
4252 StateE = 0 |
|
|
4253 StateF = 0 |
|
|
4254 StateG = 0 |
|
|
4255 StateH = 0 |
|
|
4256 StateI = 0 |
|
|
4257 StateJ = 0 |
|
|
4258 SBF8() |
|
|
4259 SBF9() |
|
|
4260 SBF10() |
|
|
4261 SBF11() |
|
|
4262 sys.exit(0) |
|
|
4263 elif StateCount == 30 and RestoreSwitch is True and StdoutSwitch is True: |
|
|
4264 StateU = int(State[22]) |
|
|
4265 StateW = int(State[23]) |
|
|
4266 StateA = int(State[24]) |
|
|
4267 StateB = int(State[25]) |
|
|
4268 StateC = int(State[26]) |
|
|
4269 StateD = int(State[27]) |
|
|
4270 StateE = int(State[28]) |
|
|
4271 StateF = int(State[29]) |
|
|
4272 StateG = int(State[30]) |
|
|
4273 StateH = 0 |
|
|
4274 StateI = 0 |
|
|
4275 StateJ = 0 |
|
|
4276 SBF8() |
|
|
4277 StateW = 0 |
|
|
4278 StateA = 0 |
|
|
4279 StateB = 0 |
|
|
4280 StateC = 0 |
|
|
4281 StateD = 0 |
|
|
4282 StateE = 0 |
|
|
4283 StateF = 0 |
|
|
4284 StateG = 0 |
|
|
4285 StateH = 0 |
|
|
4286 StateI = 0 |
|
|
4287 StateJ = 0 |
|
|
4288 SBF9() |
|
|
4289 SBF10() |
|
|
4290 SBF11() |
|
|
4291 sys.exit(0) |
|
|
4292 elif StateCount == 31 and RestoreSwitch is True and StdoutSwitch is True: |
|
|
4293 StateU = int(State[22]) |
|
|
4294 StateW = int(State[23]) |
|
|
4295 StateA = int(State[24]) |
|
|
4296 StateB = int(State[25]) |
|
|
4297 StateC = int(State[26]) |
|
|
4298 StateD = int(State[27]) |
|
|
4299 StateE = int(State[28]) |
|
|
4300 StateF = int(State[29]) |
|
|
4301 StateG = int(State[30]) |
|
|
4302 StateH = int(State[31]) |
|
|
4303 StateI = 0 |
|
|
4304 StateJ = 0 |
|
|
4305 SBF9() |
|
|
4306 StateW = 0 |
|
|
4307 StateA = 0 |
|
|
4308 StateB = 0 |
|
|
4309 StateC = 0 |
|
|
4310 StateD = 0 |
|
|
4311 StateE = 0 |
|
|
4312 StateF = 0 |
|
|
4313 StateG = 0 |
|
|
4314 StateH = 0 |
|
|
4315 StateI = 0 |
|
|
4316 StateJ = 0 |
|
|
4317 SBF10() |
|
|
4318 SBF11() |
|
|
4319 sys.exit(0) |
|
|
4320 elif StateCount == 32 and RestoreSwitch is True and StdoutSwitch is True: |
|
|
4321 StateU = int(State[22]) |
|
|
4322 StateW = int(State[23]) |
|
|
4323 StateA = int(State[24]) |
|
|
4324 StateB = int(State[25]) |
|
|
4325 StateC = int(State[26]) |
|
|
4326 StateD = int(State[27]) |
|
|
4327 StateE = int(State[28]) |
|
|
4328 StateF = int(State[29]) |
|
|
4329 StateG = int(State[30]) |
|
|
4330 StateH = int(State[31]) |
|
|
4331 StateI = int(State[32]) |
|
|
4332 StateJ = 0 |
|
|
4333 SBF10() |
|
|
4334 StateW = 0 |
|
|
4335 StateA = 0 |
|
|
4336 StateB = 0 |
|
|
4337 StateC = 0 |
|
|
4338 StateD = 0 |
|
|
4339 StateE = 0 |
|
|
4340 StateF = 0 |
|
|
4341 StateG = 0 |
|
|
4342 StateH = 0 |
|
|
4343 StateI = 0 |
|
|
4344 StateJ = 0 |
|
|
4345 SBF11() |
|
|
4346 sys.exit(0) |
|
|
4347 elif StateCount == 33 and RestoreSwitch is True and StdoutSwitch is True: |
|
|
4348 StateU = int(State[22]) |
|
|
4349 StateW = int(State[23]) |
|
|
4350 StateA = int(State[24]) |
|
|
4351 StateB = int(State[25]) |
|
|
4352 StateC = int(State[26]) |
|
|
4353 StateD = int(State[27]) |
|
|
4354 StateE = int(State[28]) |
|
|
4355 StateF = int(State[29]) |
|
|
4356 StateG = int(State[30]) |
|
|
4357 StateH = int(State[31]) |
|
|
4358 StateI = int(State[32]) |
|
|
4359 StateJ = int(State[33]) |
|
|
4360 SBF11() |
|
|
4361 sys.exit(0) |
|
|
4362 |
|
689
|
4363 sys.exit(SpliceX + " unknown error: please report bug to author") |
