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