def uniqifer_enter(original_file_path, from_combiner=False):
    dict_prefix = pystrs.UNIQIFER_prefix
    if from_combiner:
        dict_prefix = pystrs.UNIQBINER_prefix
    storepath = finalsavepath(paths.results_path, dict_prefix, mybuildtime(), pyoptions.filextension,
                              paths.results_file_name)
    with open(original_file_path) as o_f:
        with open(storepath, "a") as s_f:
            for item in unique(o_f.readlines()):
                item = filterforfun(item.strip(), head=pyoptions.head, tail=pyoptions.tail,
                                    lenght_is_filter=pyoptions.args_pick,
                                    minlen=pyoptions.minlen, maxlen=pyoptions.maxlen,
                                    regex_is_filter=True, regex=pyoptions.filter_regex,
                                    encode_is_filter=True, encode=pyoptions.encode,
                                    occur_is_filter=True,
                                    letter_occur=pyoptions.letter_occur,
                                    digital_occur=pyoptions.digital_occur,
                                    special_occur=pyoptions.special_occur,
                                    types_is_filter=True,
                                    letter_types=pyoptions.letter_types,
                                    digital_types=pyoptions.digital_types,
                                    special_types=pyoptions.special_types,
                                    )
                if item:
                    s_f.write(item + pyoptions.CRLF)
    print("[+] Source of  :{0} lines".format(cool.orange(finishcounter(original_file_path))))
    finishprinter(finishcounter(storepath), storepath)
def comparer_magic(*args):
    """[minuend_file] [subtrahend_file]"""
    args = list(args[0])

    if len(args) != 3:
        exit(pyoptions.CRLF + cool.fuchsia("[!] Usage: {} {}".format(
            args[0], pyoptions.tools_info.get(args[0]))))
    storepath = finalsavepath(fun_name())

    minuend_file = args[1]
    subtrahend_file = args[2]
    if not os.path.isfile(os.path.abspath(pyoptions.args_tool[1])):
        exit(pyoptions.CRLF +
             cool.red("[-] file: {} don't exists".format(minuend_file)))
    if not os.path.isfile(os.path.abspath(pyoptions.args_tool[2])):
        exit(pyoptions.CRLF +
             cool.red("[-] file: {} don't exists".format(subtrahend_file)))

    minuend_list = walk_pure_file(minuend_file)
    subtrahend_list = walk_pure_file(subtrahend_file)
    with open(storepath, "a") as f:
        for item in minuend_list:
            if item not in subtrahend_list:
                item = filterforfun(item)
                if item:
                    f.write(item + pyoptions.CRLF)

    finishprinter(storepath)
Exemple #3
0
def get_handler_dic(path):
    if not os.path.isfile(path):
        exit(cool.red("[-] File don't exits" + pyoptions.CRLF))
    storepath = finalsavepath(paths.results_path, pystrs.HANDLER_prefix, mybuildtime(), pyoptions.filextension,
                              paths.results_file_name)
    handles = []
    with open(path, 'r') as f:
        for item in f.readlines():
            handles.append(item.strip())

    with open(storepath, 'a') as save:
        for item in handles:
            item = filterforfun("".join(item), head=pyoptions.head, tail=pyoptions.tail,
                                lenght_is_filter=pyoptions.args_pick,
                                minlen=pyoptions.minlen, maxlen=pyoptions.maxlen,
                                regex_is_filter=True, regex=pyoptions.filter_regex,
                                encode_is_filter=True, encode=pyoptions.encode,
                                occur_is_filter=True,
                                letter_occur=pyoptions.letter_occur,
                                digital_occur=pyoptions.digital_occur,
                                special_occur=pyoptions.special_occur,
                                types_is_filter=True,
                                letter_types=pyoptions.letter_types,
                                digital_types=pyoptions.digital_types,
                                special_types=pyoptions.special_types,
                                )
            if item:
                save.write(item + pyoptions.CRLF)
    finishprinter(finishcounter(storepath), storepath)
Exemple #4
0
def magic(func):
    storepath = finalsavepath(func.__name__)
    try:
        with open(storepath, "a") as f:
            for item in unique(func()):
                item = filterforfun(
                    item,
                    head=pyoptions.head,
                    tail=pyoptions.tail,
                    lenght_is_filter=pyoptions.args_pick,
                    minlen=pyoptions.minlen,
                    maxlen=pyoptions.maxlen,
                    regex_is_filter=True,
                    regex=pyoptions.filter_regex,
                    encode_is_filter=True,
                    encode=pyoptions.encode,
                    occur_is_filter=True,
                    letter_occur=pyoptions.letter_occur,
                    digital_occur=pyoptions.digital_occur,
                    special_occur=pyoptions.special_occur,
                    types_is_filter=True,
                    letter_types=pyoptions.letter_types,
                    digital_types=pyoptions.digital_types,
                    special_types=pyoptions.special_types,
                )
                if item:
                    f.write(item + pyoptions.CRLF)
        finishprinter(storepath)
    except Exception as e:
        print(cool.red('[-] Exception as following:') + pyoptions.CRLF)
        print(traceback.print_exc())
Exemple #5
0
def get_chunk_dic(objflag):
    countchecker(len(objflag))
    storepath = finalsavepath(paths.results_path, pystrs.CHUNK_prefix,
                              mybuildtime(), pyoptions.filextension,
                              paths.results_file_name)
    with open(storepath, "a") as f:
        for item in itertools.permutations(objflag, len(objflag)):
            item = filterforfun(
                item,
                head=pyoptions.head,
                tail=pyoptions.tail,
                lenght_is_filter=pyoptions.args_pick,
                minlen=pyoptions.minlen,
                maxlen=pyoptions.maxlen,
                regex_is_filter=True,
                regex=pyoptions.filter_regex,
                encode_is_filter=True,
                encode=pyoptions.encode,
                occur_is_filter=True,
                letter_occur=pyoptions.letter_occur,
                digital_occur=pyoptions.digital_occur,
                special_occur=pyoptions.special_occur,
                types_is_filter=True,
                letter_types=pyoptions.letter_types,
                digital_types=pyoptions.digital_types,
                special_types=pyoptions.special_types,
            )
            if item:
                f.write(item + pyoptions.CRLF)
    finishprinter(finishcounter(storepath), storepath)
Exemple #6
0
def build_conf_dic(source="", file_prefix=pystrs.CONF_prefix):
    storepath = finalsavepath(paths.results_path, file_prefix, mybuildtime(),
                              pyoptions.filextension, paths.results_file_name)
    with open(storepath, "a") as f:
        for item in confcore(source):
            item = filterforfun(
                item,
                head=pyoptions.head,
                tail=pyoptions.tail,
                lenght_is_filter=pyoptions.args_pick,
                minlen=pyoptions.minlen,
                maxlen=pyoptions.maxlen,
                regex_is_filter=True,
                regex=pyoptions.filter_regex,
                encode_is_filter=True,
                encode=pyoptions.encode,
                occur_is_filter=True,
                letter_occur=pyoptions.letter_occur,
                digital_occur=pyoptions.digital_occur,
                special_occur=pyoptions.special_occur,
                types_is_filter=True,
                letter_types=pyoptions.letter_types,
                digital_types=pyoptions.digital_types,
                special_types=pyoptions.special_types,
            )
            if item:
                f.write(item + pyoptions.CRLF)
    finishprinter(finishcounter(storepath), storepath)
Exemple #7
0
def birthday_magic(begin_date, end_date):
    def check_date(dt, desc="datetime"):
        if len(dt) != 8 or not dt.isdigit():
            exit(
                cool.fuchsia(
                    "[!] {} format:[YYYYMMDD], such as:19900512{}".format(
                        desc, pyoptions.CRLF)))
        elif int(dt[4:6]) > 12 or int(dt[4:6]) < 1 or int(dt[6:8]) > 31 or int(
                dt[6:8]) < 1:
            exit(
                cool.fuchsia(
                    "[!] {} date format: 1<= month <=12 and 1<= day <=31{}".
                    format(desc, pyoptions.CRLF)))
        else:
            return int(dt[:4]), int(dt[4:6]), int(dt[6:])

    def check_range(s, e):
        if s[0] > e[0] or (s[0] == e[0] and s[1] > e[1]) or (s[1] == e[1]
                                                             and s[2] > e[2]):
            exit(
                cool.fuchsia("[!] Start date should later than End date" +
                             pyoptions.CRLF))
        else:
            return True

    start_valid = check_date(begin_date, desc="Start datetime")
    end_valid = check_date(end_date, desc="End datetime")
    valid = check_range(start_valid,
                        end_valid) if start_valid and end_valid else False
    storepath = finalsavepath(paths.results_path, pystrs.BIRTHDAY_prefix,
                              mybuildtime(), pyoptions.filextension,
                              paths.results_file_name)
    if valid:
        res = []
        begin = datetime.datetime.strptime(begin_date, "%Y%m%d")
        end = datetime.datetime.strptime(end_date, "%Y%m%d")
        while begin <= end:
            date_str = begin.strftime("%Y%m%d")
            res.extend(dateshaper(date_str))
            begin += datetime.timedelta(days=1)
        with open(storepath, "a") as f:
            for item in unique(res):
                item = filterforfun(
                    item,
                    head=pyoptions.head,
                    tail=pyoptions.tail,
                    lenght_is_filter=pyoptions.args_pick,
                    minlen=pyoptions.minlen,
                    maxlen=pyoptions.maxlen,
                    encode_is_filter=True,
                    encode=pyoptions.encode,
                )
                if item:
                    f.write(item + pyoptions.CRLF)
        finishprinter(finishcounter(storepath), storepath)
def magic(func):
    storepath = finalsavepath(func.__name__)
    try:
        with open(storepath, "a") as f:
            for item in unique(func()):
                item = filterforfun(item)
                if item:
                    f.write(item + pyoptions.CRLF)
        finishprinter(storepath)
    except Exception as e:
        print(cool.red('[-] Exception as following:') + pyoptions.CRLF)
        print(traceback.print_exc())
Exemple #9
0
def comparer_magic(*args):
    """[minuend_file] [subtrahend_file]"""
    args = list(args[0])

    if len(args) != 3:
        exit(pyoptions.CRLF + cool.fuchsia("[!] Usage: {} {}".format(
            args[0], pyoptions.tools_info.get(args[0]))))
    storepath = finalsavepath(fun_name())

    minuend_file = args[1]
    subtrahend_file = args[2]
    if not os.path.isfile(os.path.abspath(pyoptions.args_tool[1])):
        exit(pyoptions.CRLF +
             cool.red("[-] file: {} don't exists".format(minuend_file)))
    if not os.path.isfile(os.path.abspath(pyoptions.args_tool[2])):
        exit(pyoptions.CRLF +
             cool.red("[-] file: {} don't exists".format(subtrahend_file)))

    minuend_list = walk_pure_file(minuend_file)
    subtrahend_list = walk_pure_file(subtrahend_file)
    with open(storepath, "a") as f:
        for item in minuend_list:
            if item not in subtrahend_list:
                item = filterforfun(
                    item,
                    head=pyoptions.head,
                    tail=pyoptions.tail,
                    lenght_is_filter=pyoptions.args_pick,
                    minlen=pyoptions.minlen,
                    maxlen=pyoptions.maxlen,
                    regex_is_filter=True,
                    regex=pyoptions.filter_regex,
                    encode_is_filter=True,
                    encode=pyoptions.encode,
                    occur_is_filter=True,
                    letter_occur=pyoptions.letter_occur,
                    digital_occur=pyoptions.digital_occur,
                    special_occur=pyoptions.special_occur,
                    types_is_filter=True,
                    letter_types=pyoptions.letter_types,
                    digital_types=pyoptions.digital_types,
                    special_types=pyoptions.special_types,
                )
                if item:
                    f.write(item + pyoptions.CRLF)

    finishprinter(storepath)
def counter_operator(original_file_path,
                     justsave,
                     justview,
                     encodeflag,
                     head,
                     tail,
                     vs_count=pyoptions.default_vs_items):
    items = Counter(
        open(original_file_path,
             'r').read().replace(string.punctuation, "").split(
                 pyoptions.counter_split)).most_common(vs_count)
    items_length = len(items)
    storepath = finalsavepath(paths.results_path, pystrs.COUNTER_prefix,
                              mybuildtime(), pyoptions.filextension,
                              paths.results_file_name)
    if vs_count > pyoptions.vs_counter_switcher:
        exit(pyoptions.CRLF +
             cool.fuchsia("[!] view items should Leq {0}".format(
                 pyoptions.vs_counter_switcher)))
    elif items_length < vs_count:
        exit(pyoptions.CRLF +
             cool.fuchsia("[!] max items is {0}".format(items_length)))
    print("{0}Welcome to the COUNTER tool".format("   " * 8))
    if justsave:
        with open(storepath, "a") as f:
            for _ in items:
                item = filterforfun(
                    _[0],
                    head=pyoptions.head,
                    tail=pyoptions.tail,
                    lenght_is_filter=pyoptions.args_pick,
                    minlen=pyoptions.minlen,
                    maxlen=pyoptions.maxlen,
                    regex_is_filter=True,
                    regex=pyoptions.filter_regex,
                    encode_is_filter=True,
                    encode=pyoptions.encode,
                    occur_is_filter=True,
                    letter_occur=pyoptions.letter_occur,
                    digital_occur=pyoptions.digital_occur,
                    special_occur=pyoptions.special_occur,
                    types_is_filter=True,
                    letter_types=pyoptions.letter_types,
                    digital_types=pyoptions.digital_types,
                    special_types=pyoptions.special_types,
                )
                if item:
                    f.write(item + pyoptions.CRLF)
        finishprinter(finishcounter(storepath), storepath)
    elif justview:
        print(pyoptions.CRLF * 2)
        for item in items:
            print("{0}Word:{2:20} -> {1:10} times".format(
                "     " * 5, cool.orange(item[1]), cool.orange(item[0])))
        print("[+] Cost:{} seconds".format(
            cool.orange(str(time.time() - pystrs.startime)[:6])))
    else:
        print(pyoptions.CRLF * 2)
        for item in items:
            print("{0}Word:{2:20} -> {1:10} times".format(
                "     " * 5, cool.orange(item[1]), cool.orange(item[0])))
        print(pyoptions.CRLF)
        with open(storepath, 'a') as f:
            for _ in items:
                f.write(
                    pyoptions.operator.get(encodeflag)(head + _[0] + tail) +
                    pyoptions.CRLF)
        finishprinter(finishcounter(storepath), storepath)
Exemple #11
0
def extend_magic(rawlist, need_extendscratch=False):
    prefix = pystrs.EXTEND_prefix
    if rawlist == []:
        exit(pyoptions.CRLF +
             cool.red("[-] raw extend resource cannot be empty"))

    leet = pyoptions.extend_leet
    if need_extendscratch:
        prefix = pystrs.PASSCRAPER_prefix
        leet = pyoptions.passcraper_leet

    storepath = finalsavepath(paths.results_path, prefix, mybuildtime(),
                              pyoptions.filextension, paths.results_file_name)
    with open(storepath, "a") as f:
        for _ in walks_all_files(paths.weblist_path):
            item = filterforfun(
                "".join(_),
                head=pyoptions.head,
                tail=pyoptions.tail,
                lenght_is_filter=pyoptions.args_pick,
                minlen=pyoptions.minlen,
                maxlen=pyoptions.maxlen,
                regex_is_filter=True,
                regex=pyoptions.filter_regex,
                encode_is_filter=True,
                encode=pyoptions.encode,
                occur_is_filter=True,
                letter_occur=pyoptions.letter_occur,
                digital_occur=pyoptions.digital_occur,
                special_occur=pyoptions.special_occur,
                types_is_filter=True,
                letter_types=pyoptions.letter_types,
                digital_types=pyoptions.digital_types,
                special_types=pyoptions.special_types,
            )
            if item:
                f.write(item + pyoptions.CRLF)
        if pyoptions.level <= 1:
            for _ in walks_all_files(paths.syslist_path):
                item = filterforfun(
                    "".join(_),
                    head=pyoptions.head,
                    tail=pyoptions.tail,
                    lenght_is_filter=pyoptions.args_pick,
                    minlen=pyoptions.minlen,
                    maxlen=pyoptions.maxlen,
                    regex_is_filter=True,
                    regex=pyoptions.filter_regex,
                    encode_is_filter=True,
                    encode=pyoptions.encode,
                    occur_is_filter=True,
                    letter_occur=pyoptions.letter_occur,
                    digital_occur=pyoptions.digital_occur,
                    special_occur=pyoptions.special_occur,
                    types_is_filter=True,
                    letter_types=pyoptions.letter_types,
                    digital_types=pyoptions.digital_types,
                    special_types=pyoptions.special_types,
                )
                if item:
                    f.write(item + pyoptions.CRLF)
        for _ in extend_enter(rawlist, leet=leet):
            item = filterforfun(
                "".join(_),
                head=pyoptions.head,
                tail=pyoptions.tail,
                lenght_is_filter=pyoptions.args_pick,
                minlen=pyoptions.minlen,
                maxlen=pyoptions.maxlen,
                regex_is_filter=True,
                regex=pyoptions.filter_regex,
                encode_is_filter=True,
                encode=pyoptions.encode,
                occur_is_filter=True,
                letter_occur=pyoptions.letter_occur,
                digital_occur=pyoptions.digital_occur,
                special_occur=pyoptions.special_occur,
                types_is_filter=True,
                letter_types=pyoptions.letter_types,
                digital_types=pyoptions.digital_types,
                special_types=pyoptions.special_types,
            )
            if item:
                f.write(item + pyoptions.CRLF)

    finishprinter(finishcounter(storepath), storepath)
    def do_run(self, args):
        pystrs.startime = time.time()
        results = []
        storepath = finalsavepath(paths.results_path, pystrs.SEDB_prefix,
                                  mybuildtime(), pyoptions.filextension,
                                  paths.results_file_name)
        paths.results_file_name = None
        # SingleRule
        for single in SingleRule(pystrs.sedb_dict[pystrs.sedb_range[0]],
                                 pystrs.sedb_dict[pystrs.sedb_range[1]],
                                 pystrs.sedb_dict[pystrs.sedb_range[2]],
                                 pystrs.sedb_dict[pystrs.sedb_range[3]],
                                 pystrs.sedb_dict[pystrs.sedb_range[4]],
                                 pystrs.sedb_dict[pystrs.sedb_range[5]],
                                 pystrs.sedb_dict[pystrs.sedb_range[6]],
                                 pystrs.sedb_dict[pystrs.sedb_range[7]],
                                 pystrs.sedb_dict[pystrs.sedb_range[8]],
                                 pystrs.sedb_dict[pystrs.sedb_range[9]],
                                 pystrs.sedb_dict[pystrs.sedb_range[10]],
                                 pystrs.sedb_dict[pystrs.sedb_range[11]],
                                 pystrs.sedb_dict[pystrs.sedb_range[12]],
                                 pystrs.sedb_dict[pystrs.sedb_range[13]],
                                 pystrs.sedb_dict[pystrs.sedb_range[14]]):
            results.append(single)
        # SDrule
        for sd in SDrule(pystrs.sedb_dict[pystrs.sedb_range[0]],
                         pystrs.sedb_dict[pystrs.sedb_range[3]]):
            results.append(sd)
        for sd in SDrule(pystrs.sedb_dict[pystrs.sedb_range[0]],
                         pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(sd)
        # EB
        for eb in EB(pystrs.sedb_dict[pystrs.sedb_range[1]],
                     pystrs.sedb_dict[pystrs.sedb_range[3]]):
            results.append(eb)
        for eb in EB(pystrs.sedb_dict[pystrs.sedb_range[1]],
                     pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(eb)
        # Mailrule
        for mr in Mailrule(pystrs.sedb_dict[pystrs.sedb_range[8]],
                           pystrs.sedb_dict[pystrs.sedb_range[0]]):
            results.append(mr)
        for mr in Mailrule(pystrs.sedb_dict[pystrs.sedb_range[8]],
                           pystrs.sedb_dict[pystrs.sedb_range[1]]):
            results.append(mr)
        for mr in Mailrule(pystrs.sedb_dict[pystrs.sedb_range[8]],
                           pystrs.sedb_dict[pystrs.sedb_range[2]]):
            results.append(mr)
        for mr in Mailrule(pystrs.sedb_dict[pystrs.sedb_range[8]],
                           pystrs.sedb_dict[pystrs.sedb_range[4]]):
            results.append(mr)
        for mr in Mailrule(pystrs.sedb_dict[pystrs.sedb_range[8]],
                           pystrs.sedb_dict[pystrs.sedb_range[10]]):
            results.append(mr)
        for mr in Mailrule(pystrs.sedb_dict[pystrs.sedb_range[8]],
                           pystrs.sedb_dict[pystrs.sedb_range[14]]):
            results.append(mr)
        for mr in Mailrule(pystrs.sedb_dict[pystrs.sedb_range[8]],
                           pystrs.sedb_dict[pystrs.sedb_range[3]],
                           isstrs=False):
            results.append(mr)
        for mr in Mailrule(pystrs.sedb_dict[pystrs.sedb_range[8]],
                           pystrs.sedb_dict[pystrs.sedb_range[13]],
                           isstrs=False):
            results.append(mr)
        # NB
        for nn in NB(pystrs.sedb_dict[pystrs.sedb_range[10]],
                     pystrs.sedb_dict[pystrs.sedb_range[3]]):
            results.append(nn)
        for nn in NB(pystrs.sedb_dict[pystrs.sedb_range[10]],
                     pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(nn)

        # SB
        for sb in SB(pystrs.sedb_dict[pystrs.sedb_range[2]],
                     pystrs.sedb_dict[pystrs.sedb_range[3]]):
            results.append(sb)
        for sb in SB(pystrs.sedb_dict[pystrs.sedb_range[2]],
                     pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(sb)

        # NNrule
        for nn in NNrule(pystrs.sedb_dict[pystrs.sedb_range[3]],
                         pystrs.sedb_dict[pystrs.sedb_range[5]]):
            results.append(nn)
        for nn in NNrule(pystrs.sedb_dict[pystrs.sedb_range[3]],
                         pystrs.sedb_dict[pystrs.sedb_range[6]]):
            results.append(nn)
        for nn in NNrule(pystrs.sedb_dict[pystrs.sedb_range[5]],
                         pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(nn)
        for nn in NNrule(pystrs.sedb_dict[pystrs.sedb_range[6]],
                         pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(nn)
        for nn in NNrule(pystrs.sedb_dict[pystrs.sedb_range[7]],
                         pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(nn)
        for nn in NNrule(pystrs.sedb_dict[pystrs.sedb_range[9]],
                         pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(nn)
        for nn in NNrule(pystrs.sedb_dict[pystrs.sedb_range[12]],
                         pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(nn)
        for nn in NNrule(pystrs.sedb_dict[pystrs.sedb_range[3]],
                         pystrs.sedb_dict[pystrs.sedb_range[7]]):
            results.append(nn)
        for nn in NNrule(pystrs.sedb_dict[pystrs.sedb_range[3]],
                         pystrs.sedb_dict[pystrs.sedb_range[9]]):
            results.append(nn)
        for nn in NNrule(pystrs.sedb_dict[pystrs.sedb_range[3]],
                         pystrs.sedb_dict[pystrs.sedb_range[11]]):
            results.append(nn)
        for nn in NNrule(pystrs.sedb_dict[pystrs.sedb_range[3]],
                         pystrs.sedb_dict[pystrs.sedb_range[12]]):
            results.append(nn)
        for nn in NNrule(pystrs.sedb_dict[pystrs.sedb_range[3]],
                         pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(nn)

        # SNrule
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[4]],
                         pystrs.sedb_dict[pystrs.sedb_range[3]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[4]],
                         pystrs.sedb_dict[pystrs.sedb_range[5]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[4]],
                         pystrs.sedb_dict[pystrs.sedb_range[6]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[4]],
                         pystrs.sedb_dict[pystrs.sedb_range[7]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[4]],
                         pystrs.sedb_dict[pystrs.sedb_range[9]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[4]],
                         pystrs.sedb_dict[pystrs.sedb_range[11]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[4]],
                         pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(sn)

        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[10]],
                         pystrs.sedb_dict[pystrs.sedb_range[3]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[10]],
                         pystrs.sedb_dict[pystrs.sedb_range[5]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[10]],
                         pystrs.sedb_dict[pystrs.sedb_range[6]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[10]],
                         pystrs.sedb_dict[pystrs.sedb_range[7]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[10]],
                         pystrs.sedb_dict[pystrs.sedb_range[9]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[10]],
                         pystrs.sedb_dict[pystrs.sedb_range[11]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[10]],
                         pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(sn)

        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[14]],
                         pystrs.sedb_dict[pystrs.sedb_range[3]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[14]],
                         pystrs.sedb_dict[pystrs.sedb_range[5]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[14]],
                         pystrs.sedb_dict[pystrs.sedb_range[6]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[14]],
                         pystrs.sedb_dict[pystrs.sedb_range[7]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[14]],
                         pystrs.sedb_dict[pystrs.sedb_range[9]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[14]],
                         pystrs.sedb_dict[pystrs.sedb_range[11]]):
            results.append(sn)
        for sn in SNrule(pystrs.sedb_dict[pystrs.sedb_range[14]],
                         pystrs.sedb_dict[pystrs.sedb_range[13]]):
            results.append(sn)

        # SSrule
        for ss in SSrule(pystrs.sedb_dict[pystrs.sedb_range[0]],
                         pystrs.sedb_dict[pystrs.sedb_range[1]]):
            results.append(ss)
        for ss in SSrule(pystrs.sedb_dict[pystrs.sedb_range[0]],
                         pystrs.sedb_dict[pystrs.sedb_range[4]]):
            results.append(ss)
        for ss in SSrule(pystrs.sedb_dict[pystrs.sedb_range[0]],
                         pystrs.sedb_dict[pystrs.sedb_range[8]]):
            results.append(ss)
        for ss in SSrule(pystrs.sedb_dict[pystrs.sedb_range[0]],
                         pystrs.sedb_dict[pystrs.sedb_range[10]]):
            results.append(ss)
        for ss in SSrule(pystrs.sedb_dict[pystrs.sedb_range[0]],
                         pystrs.sedb_dict[pystrs.sedb_range[14]]):
            results.append(ss)
        for ss in SSrule(pystrs.sedb_dict[pystrs.sedb_range[1]],
                         pystrs.sedb_dict[pystrs.sedb_range[4]]):
            results.append(ss)
        for ss in SSrule(pystrs.sedb_dict[pystrs.sedb_range[1]],
                         pystrs.sedb_dict[pystrs.sedb_range[8]]):
            results.append(ss)
        for ss in SSrule(pystrs.sedb_dict[pystrs.sedb_range[1]],
                         pystrs.sedb_dict[pystrs.sedb_range[10]]):
            results.append(ss)
        for ss in SSrule(pystrs.sedb_dict[pystrs.sedb_range[1]],
                         pystrs.sedb_dict[pystrs.sedb_range[14]]):
            results.append(ss)
        for ss in SSrule(pystrs.sedb_dict[pystrs.sedb_range[8]],
                         pystrs.sedb_dict[pystrs.sedb_range[10]]):
            results.append(ss)
        for ss in SSrule(pystrs.sedb_dict[pystrs.sedb_range[8]],
                         pystrs.sedb_dict[pystrs.sedb_range[14]]):
            results.append(ss)
        for ss in SSrule(pystrs.sedb_dict[pystrs.sedb_range[10]],
                         pystrs.sedb_dict[pystrs.sedb_range[14]]):
            results.append(ss)

        # WeakPass
        for weakpwd in walks_all_files(paths.sedblist_path):
            results.append(weakpwd)
        readylist = []
        readylist.extend(pystrs.sedb_dict[pystrs.sedb_range[0]])
        readylist.extend(pystrs.sedb_dict[pystrs.sedb_range[1]])
        readylist.extend(pystrs.sedb_dict[pystrs.sedb_range[2]])
        readylist.extend(pystrs.sedb_dict[pystrs.sedb_range[4]])
        readylist.extend(pystrs.sedb_dict[pystrs.sedb_range[10]])
        readylist.extend(pystrs.sedb_dict[pystrs.sedb_range[14]])
        # Using extend_enter plug
        for extendstr in extend_enter(readylist, leet=pyoptions.sedb_leet):
            results.append(extendstr)
        with open(storepath, "a") as f:
            for ur in unique(results):
                item = filterforfun(
                    "".join(ur),
                    head=pyoptions.head,
                    tail=pyoptions.tail,
                    lenght_is_filter=pyoptions.args_pick,
                    minlen=pyoptions.minlen,
                    maxlen=pyoptions.maxlen,
                    regex_is_filter=True,
                    regex=pyoptions.filter_regex,
                    encode_is_filter=True,
                    encode=pyoptions.encode,
                    occur_is_filter=True,
                    letter_occur=pyoptions.letter_occur,
                    digital_occur=pyoptions.digital_occur,
                    special_occur=pyoptions.special_occur,
                    types_is_filter=True,
                    letter_types=pyoptions.letter_types,
                    digital_types=pyoptions.digital_types,
                    special_types=pyoptions.special_types,
                )
                if item:
                    f.write(item + pyoptions.CRLF)

        finishprinter(finishcounter(storepath), storepath)