Upload 67 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+img/activation_with_account_5.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+*.exe
+*.pyc
+*.txt
+.DS_STORE

Commands.txt

@@ -0,0 +1 @@
+python .\main.py --skip-webdriver-menu --chrome --vpn-codes --email-api fakemail --custom-browser-location "C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe"

main.py

@@ -0,0 +1,735 @@
+import contextlib
+import logging
+import pathlib
+import json
+import sys
+import io
+
+I_AM_EXECUTABLE = (True if (getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS')) else False)
+PATH_TO_SELF = sys.executable if I_AM_EXECUTABLE else __file__
+CONFIG_PATH = pathlib.Path(PATH_TO_SELF).parent.resolve().joinpath('eset-keygen-config.json')
+LOG_PATH = pathlib.Path(PATH_TO_SELF).parent.resolve().joinpath('ESET-KeyGen.log')
+SILENT_MODE = '--silent' in sys.argv
+MBCI_MODE = len(sys.argv) == 1
+
+def enable_logging():
+    logging.basicConfig(
+        level=logging.INFO,
+        filemode='w',
+        filename=LOG_PATH,
+        format='%(asctime)s - %(levelname)s - %(message)s'
+    )
+
+if ('--disable-logging' not in sys.argv and not MBCI_MODE) or ('--disable-logging' in sys.argv and SILENT_MODE):
+    enable_logging()
+
+from modules.EmailAPIs import *
+
+# ---- Quick settings ----
+VERSION = ['v1.5.5.3', 1553]
+LOGO = f"""
+███████╗███████╗███████╗████████╗   ██╗  ██╗███████╗██╗   ██╗ ██████╗ ███████╗███╗   ██╗
+██╔════╝██╔════╝██╔════╝╚══██╔══╝   ██║ ██╔╝██╔════╝╚██╗ ██╔╝██╔════╝ ██╔════╝████╗  ██║
+█████╗  ███████╗█████╗     ██║      █████╔╝ █████╗   ╚████╔╝ ██║  ███╗█████╗  ██╔██╗ ██║
+██╔══╝  ╚════██║██╔══╝     ██║      ██╔═██╗ ██╔══╝    ╚██╔╝  ██║   ██║██╔══╝  ██║╚██╗██║   
+███████╗███████║███████╗   ██║      ██║  ██╗███████╗   ██║   ╚██████╔╝███████╗██║ ╚████║   
+╚══════╝╚══════╝╚══════╝   ╚═╝      ╚═╝  ╚═╝╚══════╝   ╚═╝    ╚═════╝ ╚══════╝╚═╝  ╚═══╝                                                                      
+                                                Project Version: {VERSION[0]}
+                                                Project Dev: Parv Ashwani (ZARWIN)
+                                                Dev Website: https://zarwin.is-a.dev
+"""
+if '--no-logo' in sys.argv:
+    LOGO = f"ESET KeyGen {VERSION[0]} by rzc0d3r\n"
+
+DEFAULT_PATH_TO_PROXY_FILE = 'proxies.txt'
+DEFAULT_EMAIL_API = 'guerrillamail'
+AVAILABLE_EMAIL_APIS = ('1secmail', 'guerrillamail', 'developermail', 'mailticking', 'fakemail', 'inboxes', 'incognitomail')
+WEB_WRAPPER_EMAIL_APIS = ('guerrillamail', 'mailticking', 'fakemail', 'inboxes', 'incognitomail')
+EMAIL_API_CLASSES = {
+    'guerrillamail': GuerRillaMailAPI,    
+    '1secmail': OneSecEmailAPI,
+    'developermail': DeveloperMailAPI,
+    'mailticking': MailTickingAPI,
+    'fakemail': FakeMailAPI,
+    'inboxes': InboxesAPI,
+    'incognitomail': IncognitoMailAPI
+}
+
+args = {
+    'auto_detect_browser': True,
+    'chrome': False,
+    'firefox': False,
+    'edge': False,
+    'safari': False,
+
+    'key': True,
+    'small_business_key': False,
+    'advanced_key': False,
+    'vpn_codes': False,
+    'account': False,
+    'protecthub_account': False,
+    'only_webdriver_update': False,
+    'update': False,
+    'reset_eset_vpn': False,
+    'install': False,
+    'return_exit_code': 0,
+
+    'skip_webdriver_menu': False,
+    'no_headless': False,
+    'custom_browser_location': '',
+    'email_api': DEFAULT_EMAIL_API,
+    'custom_email_api': False,
+    'skip_update_check': False,
+    'no_logo': False,
+    'disable_progress_bar': False,
+    'disable_output_file': False,
+    'repeat': 1,
+    'proxy_file': DEFAULT_PATH_TO_PROXY_FILE,
+    
+    'silent': False,
+    'disable_logging': False
+}
+
+MBCI_BROWSERS_ARGS = ['auto-detect-browser', 'chrome', 'firefox', 'edge', 'safari']
+MBCI_MODES_OF_OPERATION_ARGS = [
+    'key', 'small-business-key', 'advanced-key', 'vpn-codes', 'account',
+    'protecthub-account', 'only-webdriver-update', 'reset-eset-vpn', 'update', 'install'
+]
+MBCI_OTHER_ARGS = [
+    'skip_webdriver_menu', 'no_headless', 'custom_browser_location', 'custom_email_api',
+    'skip_update_check', 'disable_progress_bar', 'disable_output_file', 'repeat', 'disable_logging',
+    'proxy_file'
+]
+MBCI_ARGS = MBCI_BROWSERS_ARGS + MBCI_MODES_OF_OPERATION_ARGS + MBCI_OTHER_ARGS
+
+from modules.WebDriverInstaller import *
+from modules.EsetTools import EsetRegister as ER
+from modules.EsetTools import EsetKeygen as EK
+from modules.EsetTools import EsetVPN as EV
+from modules.EsetTools import EsetProtectHubRegister as EPHR
+from modules.EsetTools import EsetProtectHubKeygen as EPHK
+from modules.EsetTools import EsetVPNResetWindows as EVRW
+from modules.EsetTools import EsetVPNResetMacOS as EVRM
+from modules.EsetTools import IPBlockedException
+from modules.SharedTools import *
+from modules.MBCI import *
+from modules.Updater import Updater
+
+import traceback
+import colorama
+import platform
+import datetime
+import argparse
+import re
+import os
+
+PATH_TO_SELF = sys.executable if I_AM_EXECUTABLE else __file__
+DRIVER = None
+PROXIES = []
+PROXIES_LEN = 0
+PROXY_COUNTER = 1
+PROXY_ERROR_COUNTER = 0
+PROXY_ERROR_COUNTER_LIMIT = 3
+CHROME_PROXY_EXTENSION_PATH = ""
+
+class MBCIConfigManager:
+    def __init__(self, path=CONFIG_PATH):
+        self.path = path
+
+    def save(self, args):
+        config = {
+            'Browser': [key for key in MBCI_BROWSERS_ARGS if args[key.replace('-', '_')]][0],
+            'Mode of operation': [key for key in MBCI_MODES_OF_OPERATION_ARGS if args[key.replace('-', '_')]][0],
+            'Email API': args['email_api']
+        }
+        
+        for key in MBCI_OTHER_ARGS:
+            config[key] = args[key]
+        
+        json.dump(config, open(CONFIG_PATH, 'w'), indent=4)
+    
+    def load(self):
+        config = json.load(open(self.path))
+        try:
+            filtered_config = {}
+            browser = config.pop('Browser')
+            mode_of_operation = config.pop('Mode of operation')
+            email_api = config.pop('Email API')
+            if browser in MBCI_BROWSERS_ARGS:
+                filtered_config[browser] = True
+            if mode_of_operation in MBCI_MODES_OF_OPERATION_ARGS:
+                filtered_config[mode_of_operation] = True
+            if email_api in AVAILABLE_EMAIL_APIS:
+                filtered_config['email_api'] = email_api
+            for key in config:
+                if key in MBCI_OTHER_ARGS:
+                    filtered_config[key] = config[key]
+            return filtered_config
+        except:
+            return False
+    
+    @property
+    def is_exists(self):
+        return os.path.isfile(self.path)
+
+def RunMenu():
+    MainMenu = ViewMenu(LOGO+'\n---- Main Menu ----')
+
+    SettingMenu = ViewMenu(LOGO+'\n---- Settings Menu ----')
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='Browsers',
+            action='store_true',
+            args_names=MBCI_BROWSERS_ARGS,
+            default_value=[key for key in MBCI_BROWSERS_ARGS if args[key.replace('-', '_')]][0]
+        )
+    )
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='Modes of operation',
+            action='store_true',
+            args_names=MBCI_MODES_OF_OPERATION_ARGS,
+            default_value=[key for key in MBCI_MODES_OF_OPERATION_ARGS if args[key.replace('-', '_')]][0]
+        )
+    )
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='Email APIs',
+            action='choice',
+            args_names='email-api',
+            choices=AVAILABLE_EMAIL_APIS,
+            default_value=args['email_api']
+        )
+    )
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='--skip-webdriver-menu',
+            action='bool_switch',
+            args_names='skip-webdriver-menu'
+        )
+    )
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='--no-headless',
+            action='bool_switch',
+            args_names='no-headless'
+        )
+    )
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='--custom-browser-location',
+            action='manual_input',
+            args_names='custom-browser-location',
+            default_value=args['custom_browser_location']
+        )
+    )
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='--custom-email-api',
+            action='bool_switch',
+            args_names='custom-email-api'
+        )
+    )
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='--skip-update-check',
+            action='bool_switch',
+            args_names='skip_update_check'
+        )
+    )
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='--disable-progress-bar',
+            action='bool_switch',
+            args_names='disable_progress_bar'
+        )
+    )
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='--disable-output-file',
+            action='bool_switch',
+            args_names='disable_output_file'
+        )
+    )
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='--disable-logging',
+            action='bool_switch',
+            args_names='disable_logging'
+        )
+    )
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='--repeat',
+            action='manual_input',
+            args_names='repeat',
+            default_value=args['repeat'],
+            data_type=int
+        )
+    )
+    SettingMenu.add_item(
+        OptionAction(
+            args,
+            title='--proxy-file',
+            action='manual_input',
+            args_names='proxy-file',
+            default_value=args['proxy_file']
+        )
+    )
+
+    def exit_with_save_config():
+        MBCIConfigManager().save(args)
+        sys.exit()
+
+    SettingMenu.add_item(MenuAction('Back', SettingMenu.close))
+    MainMenu.add_item(MenuAction('Settings', SettingMenu))
+    MainMenu.add_item(MenuAction('Start', MainMenu.close))
+    MainMenu.add_item(MenuAction('Exit', exit_with_save_config))
+    MainMenu.view()
+
+def parse_argv(sys_argv=None):
+    if '--return-exit-code' not in sys.argv and not SILENT_MODE and sys_argv is None:
+        print(LOGO)
+    if MBCI_MODE and sys_argv is None:
+        RunMenu()
+    else:
+        args_parser = argparse.ArgumentParser()
+        ENABLE_REQUIRED_ARGUMENTS = True
+        GLOBAL_OVERRIDE_ARGUMENTS = ['--reset-eset-vpn', '--update', '--install', '--return-exit-code']
+        for argv in GLOBAL_OVERRIDE_ARGUMENTS:
+            ENABLE_REQUIRED_ARGUMENTS = (argv not in sys.argv)
+            if not ENABLE_REQUIRED_ARGUMENTS:
+                break
+        
+        args_browsers = args_parser.add_mutually_exclusive_group(required=ENABLE_REQUIRED_ARGUMENTS)   
+        args_browsers.add_argument('--chrome', action='store_true', help='Launching the program via Google Chrome browser')
+        args_browsers.add_argument('--firefox', action='store_true', help='Launching the program via Mozilla Firefox browser')
+        args_browsers.add_argument('--edge', action='store_true', help='Launching the program via Microsoft Edge browser')
+        args_browsers.add_argument('--safari', action='store_true', help='Launching the program via Apple Safari browser')
+        args_browsers.add_argument('--auto-detect-browser', action='store_true', help='The program itself will determine which browser to use (from the list of supported browsers)')
+        
+        args_modes = args_parser.add_mutually_exclusive_group(required=ENABLE_REQUIRED_ARGUMENTS)
+        args_modes.add_argument('--key', action='store_true', help='muimerP ytiruceS tramS TESE rof yek esnecil a gnitaerC'[::-1])
+        args_modes.add_argument('--small-business-key', action='store_true', help=')secived 5 - yek 1( ytiruceS ssenisuB llamS TESE rof yek esnecil a gnitaerC'[::-1])
+        args_modes.add_argument('--advanced-key', action='store_true', help=')secived 52 - yek 1( decnavdA TCETORP TESE rof yek esnecil a gnitaerC'[::-1])
+        args_modes.add_argument('--vpn-codes', action='store_true', help='yek ytiruceS ssenisuB llamS TESE 1 + NPV TESE rof sedoc 01 gnitaerC'[::-1])
+        args_modes.add_argument('--account', action='store_true', help=')noisrev lairt eerf eht etavitca ot( tnuoccA EMOH TESE a gnitaerC'[::-1])
+        args_modes.add_argument('--protecthub-account', action='store_true', help=')noisrev lairt eerf eht etavitca ot( tnuoccA buHtcetorP TESE a gnitaerC'[::-1])
+        args_modes.add_argument('--only-webdriver-update', action='store_true', help='yek esnecil dna tnuocca gnitareneg tuohtiw sresworb dna srevirdbew sllatsni/setadpU'[::-1])
+        args_modes.add_argument('--reset-eset-vpn', action='store_true', help='!!!elbaliava era taht stnemugra lla sedirrevO - )ylno SOcam & swodniW( noitacilppa NPV TESE eht ni esnecil eht teser ot gniyrT'[::-1])
+        args_modes.add_argument('--update', action='store_true', help='Switching to program update mode - Overrides all arguments that are available!!!')
+        args_modes.add_argument('--install', action='store_true', help='Installs the program and adds it to the environment variable (Windows & macOS only) - Overrides all arguments that are available!!!')   
+        args_modes.add_argument('--return-exit-code', type=int, default=0, help='[For developers] Will make the program return the exit code you requested - Overrides all arguments that are available!!!')
+        
+        args_parser.add_argument('--skip-webdriver-menu', action='store_true', help='Skips installation/upgrade webdrivers through the my custom wrapper (the built-in selenium-manager will be used)')
+        args_parser.add_argument('--no-headless', action='store_true', help='Shows the browser at runtime (the browser is hidden by default, but on Windows 7 this option is enabled by itself)')
+        args_parser.add_argument('--custom-browser-location', type=str, default='', help='Set path to the custom browser (to the binary file, useful when using non-standard releases, for example, Firefox Developer Edition)')
+        args_parser.add_argument('--email-api', choices=AVAILABLE_EMAIL_APIS, default=DEFAULT_EMAIL_API, help=f'Specify which api to use for mail, default - {DEFAULT_EMAIL_API}')
+        args_parser.add_argument('--custom-email-api', action='store_true', help='Allows you to manually specify any email, and all work will go through it. But you will also have to manually read inbox and do what is described in the documentation for this argument')
+        args_parser.add_argument('--skip-update-check', action='store_true', help='Skips checking for program updates')
+        args_parser.add_argument('--no-logo', action='store_true', help='Replaces ASCII-Art with plain text')
+        args_parser.add_argument('--disable-progress-bar', action='store_true', help='Disables the webdriver download progress bar')
+        args_parser.add_argument('--disable-output-file', action='store_true', help='Disables the output txt file generation')
+        args_parser.add_argument('--repeat', type=int, default=1, help='Specifies how many times to repeat generation')
+        args_parser.add_argument('--proxy-file', type=str, default=DEFAULT_PATH_TO_PROXY_FILE, help=f'Specifies the path from where the list of proxies will be read from, default - {DEFAULT_PATH_TO_PROXY_FILE}')
+
+        args_logging = args_parser.add_mutually_exclusive_group()
+        args_logging.add_argument('--silent', action='store_true', help='Disables message output, output called by the --custom-email-api argument will still be output!')
+        args_logging.add_argument('--disable-logging', action='store_true', help='Disables logging')
+
+        parsed_args = None
+        captured_stderr = io.StringIO()
+        with contextlib.redirect_stderr(captured_stderr):
+            try:
+                parsed_args = vars(args_parser.parse_args(sys_argv))
+                parsed_args['repeat'] = abs(parsed_args['repeat'])
+                if sys_argv is None:
+                    logging.info(f'Parsed arguments: {parsed_args}')
+            except SystemExit:
+                captured_stderr = captured_stderr.getvalue().strip()
+                if captured_stderr != '':
+                    if sys_argv is None:
+                        logging.error(captured_stderr)
+                    console_log(captured_stderr, silent_mode=SILENT_MODE)
+                if sys_argv is None:
+                    exit_program(-1)
+        return parsed_args
+
+def exit_program(exit_code, driver=None):
+    if MBCI_MODE and not SILENT_MODE:
+        input('\nPress Enter to exit...')
+    if driver is not None:
+        driver.quit()
+    sys.exit(exit_code)
+
+def update():
+    Updater().updater_menu(I_AM_EXECUTABLE, PATH_TO_SELF)
+    exit_program(0)
+
+def main(disable_exit=False):
+    global PROXY_ERROR_COUNTER_LIMIT
+    global PROXY_ERROR_COUNTER
+    global DRIVER
+    if args['return_exit_code'] != 0:
+        sys.exit(args['return_exit_code'])
+    if MBCI_MODE and not disable_exit:
+        print()
+    try:
+        if not args['update'] and not args['install'] and not args['reset_eset_vpn']:
+            if platform.release() == '7' and sys.platform.startswith('win'):
+                args['no_headless'] = True
+            elif args['advanced_key'] or args['protecthub_account']:
+                args['no_headless'] = True
+                if not args['custom_email_api']:
+                    if args['email_api'] not in ['mailticking', 'fakemail', 'inboxes', 'incognitomail']:
+                        raise RuntimeError('--advanced-key, --protecthub-account works ONLY if you use the --custom-email-api argument or the following Email APIs: mailticking, fakemail, inboxes!!!')
+        elif args['update']:
+            logging.info('-- Updater --')
+            console_log(f'{Fore.LIGHTMAGENTA_EX}-- Updater --{Fore.RESET}\n', silent_mode=SILENT_MODE)
+            update()
+        elif args['reset_eset_vpn']:
+            logging.info('-- Reset ESET VPN --')
+            console_log(f'{Fore.LIGHTMAGENTA_EX}-- Reset ESET VPN --{Fore.RESET}\n', silent_mode=SILENT_MODE)
+            if sys.platform.startswith('win'):
+                EVRW()
+            elif sys.platform == "darwin":
+                EVRM()
+            else:
+                logging.error('This feature is for Windows and macOS only!!!')
+                console_log('This feature is for Windows and macOS only!!!', ERROR, silent_mode=SILENT_MODE)
+            exit_program(-2)
+        elif args['install']:
+            logging.info('-- Installer --')
+            console_log(f'{Fore.LIGHTMAGENTA_EX}-- Installer --{Fore.RESET}\n', silent_mode=SILENT_MODE)
+            Installer().install()
+            exit_program(0)
+        if not args['skip_update_check'] and not args['update']:
+            try:
+                logging.info('-- Updater --')
+                console_log(f'{Fore.LIGHTMAGENTA_EX}-- Updater --{Fore.RESET}\n', silent_mode=SILENT_MODE)
+                updater = Updater()
+                latest_cloud_version = list(updater.get_releases().keys())[0]
+                latest_cloud_version_int = latest_cloud_version[1:].split('.')
+                latest_cloud_version_int = int(''.join(latest_cloud_version_int[:-1])+latest_cloud_version_int[-1][0])
+                if VERSION[1] > latest_cloud_version_int:
+                    logging.warning(f'The project has an unreleased version, maybe you are using a build from the developer?')
+                    console_log(f'The project has an unreleased version, maybe you are using a build from the developer?\n', WARN, True, SILENT_MODE)
+                elif latest_cloud_version_int > VERSION[1]:
+                    logging.info(f'Project update is available up to version: {latest_cloud_version}')
+                    if not SILENT_MODE:
+                        console_log(f'Project update is available up to version: {colorama.Fore.GREEN}{latest_cloud_version}{colorama.Fore.RESET}', WARN)
+                        update_now = input(f'[  {colorama.Fore.YELLOW}INPT{colorama.Fore.RESET}  ] {colorama.Fore.CYAN}Do you want to update right now? (y/n): {colorama.Fore.RESET}').strip().lower()
+                        if update_now == 'y':
+                            update()
+                        else:
+                            console_log(f'The update has been ignored\n', INFO)
+                else:
+                    logging.info('Project up to date!!!')
+                    console_log('Project up to date!!!\n', OK, silent_mode=SILENT_MODE)
+            except Exception as e:
+                logging.error("EXC_INFO:", exc_info=True)
+        
+        webdriver_path = None
+        browser_name = GOOGLE_CHROME
+        custom_browser_location = None if args['custom_browser_location'] == '' else args['custom_browser_location']
+        webdriver_installer = WebDriverInstaller(browser_name, custom_browser_location)
+
+        if args['auto_detect_browser']:
+            result = webdriver_installer.detect_installed_browser()
+            if result is not None:
+                browser_name = result[0]
+                webdriver_installer = WebDriverInstaller(browser_name, custom_browser_location)
+            else:
+                args['skip_webdriver_menu'] = True 
+        else:
+            if args['chrome']:
+                browser_name = GOOGLE_CHROME
+                global CHROME_PROXY_EXTENSION_PATH
+                if PROXIES != []:
+                    CHROME_PROXY_EXTENSION_PATH = ChromeProxyExtensionManager.create_extension(*PROXIES[0])
+                else:
+                    CHROME_PROXY_EXTENSION_PATH = ''
+            elif args['firefox']:
+                browser_name = MOZILLA_FIREFOX
+            elif args['edge']:
+                browser_name = MICROSOFT_EDGE
+            elif args['safari']:
+                browser_name = APPLE_SAFARI
+            webdriver_installer = WebDriverInstaller(browser_name, custom_browser_location)
+
+        if browser_name == APPLE_SAFARI:
+            args['skip_webdriver_menu'] = True
+
+        if not args['skip_webdriver_menu']:
+            webdriver_path, custom_browser_location = webdriver_installer.menu(args['disable_progress_bar'])
+        if not args['only_webdriver_update']:
+            DRIVER = initSeleniumWebDriver(browser_name, webdriver_path, custom_browser_location, CHROME_PROXY_EXTENSION_PATH, (not args['no_headless']))
+            if DRIVER is None:
+                raise RuntimeError(f'{browser_name} initialization error!')
+            if PROXIES != []:
+                scheme, host, port, username, password = PROXIES[0]
+                global PROXY_COUNTER
+                if username != '' or password != '':
+                    logging.info(f'[{PROXY_COUNTER}/{PROXIES_LEN}] Using proxy with authentication: {host}:{port}')
+                    console_log(f'[{PROXY_COUNTER}/{PROXIES_LEN}] Using proxy with authentication: {host}:{port}', INFO, silent_mode=SILENT_MODE)
+                else:
+                    logging.info(f'[{PROXY_COUNTER}/{PROXIES_LEN}] Using proxy: {host}:{port}')
+                    console_log(f'[{PROXY_COUNTER}/{PROXIES_LEN}] Using proxy: {host}:{port}', INFO, silent_mode=SILENT_MODE)
+        else:
+            sys.exit(0)
+
+        logging.info(f'-- KeyGen --')
+        console_log(f'\n{Fore.LIGHTMAGENTA_EX}-- KeyGen --{Fore.RESET}\n', silent_mode=SILENT_MODE)
+        if not args['custom_email_api']:
+            logging.info(f'[{args["email_api"]}] Mail registration...')
+            console_log(f'[{args["email_api"]}] Mail registration...', INFO, silent_mode=SILENT_MODE)
+            if args['email_api'] in WEB_WRAPPER_EMAIL_APIS:
+                email_obj = EMAIL_API_CLASSES[args['email_api']](DRIVER)
+            else:
+                email_obj = EMAIL_API_CLASSES[args['email_api']]()
+            try:
+                email_obj.init()
+                if email_obj.email is not None:
+                    logging.info('Mail registration completed successfully!')
+                    console_log('Mail registration completed successfully!', OK, silent_mode=SILENT_MODE)
+            except:
+                pass
+            if email_obj.email is None:
+                logging.critical('Mail registration was not completed, try using a different Email API!')
+                console_log('Mail registration was not completed, try using a different Email API!\n', ERROR, silent_mode=SILENT_MODE)
+                PROXY_ERROR_COUNTER += 1
+        else:
+            email_obj = CustomEmailAPI()
+            while True:
+                email = input(f'[  {colorama.Fore.YELLOW}INPT{colorama.Fore.RESET}  ] {colorama.Fore.CYAN}Enter the email address you have access to: {colorama.Fore.RESET}').strip()
+                try:
+                    matched_email = re.match(r'[-a-z0-9+.]+@[a-z]+(\.[a-z]+)+', email).group()
+                    if matched_email == email:
+                        email_obj.email = matched_email
+                        console_log('Mail has the correct syntax!', OK)
+                        break
+                    else:
+                        raise RuntimeError
+                except:
+                    console_log('Invalid email syntax!!!', ERROR)
+        
+        if email_obj.email is not None:
+            e_passwd = dataGenerator(10)
+            l_key = None
+            obtained_from_site = False
+            
+            if args['account'] or args['key'] or args['small_business_key'] or args['vpn_codes']:
+                ER_obj = ER(email_obj, e_passwd, DRIVER)
+                ER_obj.createAccount()
+                ER_obj.confirmAccount()
+                output_line = '\n'.join([
+                    '',
+                    '-------------------------------------------------',
+                    '}{ :liamE tnuoccA'[::-1].format(email_obj.email),
+                    '}{ :drowssaP tnuoccA'[::-1].format(e_passwd),
+                    '-------------------------------------------------',
+                    ''
+                ])
+                output_filename = 'ESET ACCOUNTS.txt'
+                if args['key'] or args['small_business_key'] or args['vpn_codes']:
+                    output_filename = 'ESET KEYS.txt'
+                    EK_obj = EK(email_obj, DRIVER, 'ESET HOME' if args['key'] else 'SMALL BUSINESS')
+                    EK_obj.sendRequestForKey()
+                    l_name, l_key, l_out_date = EK_obj.getLD()
+                    output_line = '\n'.join([
+                        '',
+                        '-------------------------------------------------',
+                        '}{ :liamE tnuoccA'[::-1].format(email_obj.email),
+                        '}{ :drowssaP tnuoccA'[::-1].format(e_passwd),
+                        '',
+                        '}{ :emaN esneciL'[::-1].format(l_name),
+                        '}{ :yeK esneciL'[::-1].format(l_key),
+                        '}{ :etaD tuO esneciL'[::-1].format(l_out_date),
+                        '-------------------------------------------------',
+                        ''
+                    ])
+                    if args['vpn_codes']:
+                        EV_obj = EV(email_obj, DRIVER, ER_obj.window_handle)
+                        EV_obj.sendRequestForVPNCodes()
+                        vpn_codes = EV_obj.getVPNCodes()
+                        if not args['custom_email_api']:
+                            vpn_codes_line = ', '.join(vpn_codes)
+                            output_line = '\n'.join([
+                                '',
+                                '-------------------------------------------------',
+                                '}{ :liamE tnuoccA'[::-1].format(email_obj.email),
+                                '}{ :drowssaP tnuoccA'[::-1].format(e_passwd),
+                                '',
+                                '}{ :emaN esneciL'[::-1].format(l_name),
+                                '}{ :yeK esneciL'[::-1].format(l_key),
+                                '}{ :etaD tuO esneciL'[::-1].format(l_out_date),
+                                '',
+                                '}{ :sedoC NPV'[::-1].format(vpn_codes_line),
+                                '-------------------------------------------------',
+                                ''
+                            ])
+
+            elif args['protecthub_account'] or args['advanced_key']:
+                EPHR_obj = EPHR(email_obj, e_passwd, DRIVER)
+                EPHR_obj.createAccount()
+                EPHR_obj.confirmAccount()
+                EPHR_obj.activateAccount()
+                output_line = '\n'.join([
+                    '',
+                    '---------------------------------------------------------------------',
+                    '}{ :liamE tnuoccA buHtcetorP TESE'[::-1].format(email_obj.email),
+                    '}{ :drowssaP tnuoccA buHtcetorP TESE'[::-1].format(e_passwd),
+                    '---------------------------------------------------------------------',
+                    ''
+                ])    
+                output_filename = 'ESET ACCOUNTS.txt'
+                if args['advanced_key']:
+                    output_filename = 'ESET KEYS.txt'
+                    EPHK_obj = EPHK(email_obj, e_passwd, DRIVER)
+                    l_name, l_key, l_out_date, obtained_from_site = EPHK_obj.getLD()
+                    if l_name is not None:
+                        output_line = '\n'.join([
+                            '',
+                            '---------------------------------------------------------------------',
+                            '}{ :liamE tnuoccA buHtcetorP TESE'[::-1].format(email_obj.email),
+                            '}{ :drowssaP tnuoccA buHtcetorP TESE'[::-1].format(e_passwd),
+                            '',
+                            '}{ :emaN esneciL'[::-1].format(l_name),
+                            '}{ :yeK esneciL'[::-1].format(l_key),
+                            '}{ :etaD tuO esneciL'[::-1].format(l_out_date),
+                            '---------------------------------------------------------------------',
+                            ''
+                        ])
+
+            logging.info(output_line)
+            console_log(output_line, silent_mode=SILENT_MODE)
+            if not args['disable_output_file']:
+                date = datetime.datetime.now()
+                f = open(f"{str(date.day)}.{str(date.month)}.{str(date.year)} - "+output_filename, 'a')
+                f.write(output_line)
+                f.close()
+            
+            if l_key is not None and args['advanced_key'] and obtained_from_site:
+                if not SILENT_MODE:
+                    unbind_key = input(f'[  {colorama.Fore.YELLOW}INPT{colorama.Fore.RESET}  ] {colorama.Fore.CYAN}Do you want to unbind the key from this account? (y/n): {colorama.Fore.RESET}').strip().lower()
+                    if unbind_key == 'y':
+                        EPHK_obj.removeLicense()
+                else:
+                    EPHK_obj.removeLicense()
+    except IPBlockedException:
+        logging.critical("EXC_INFO:", exc_info=True)
+        traceback_string = traceback.format_exc()
+        if PROXIES != []:
+            PROXIES.remove(PROXIES[0])
+            if PROXY_COUNTER < PROXIES_LEN:
+                PROXY_COUNTER += 1
+        console_log(traceback_string, ERROR, silent_mode=SILENT_MODE)
+    except Exception as E:
+        PROXY_ERROR_COUNTER_LIMIT += 1
+        logging.critical("EXC_INFO:", exc_info=True)
+        traceback_string = traceback.format_exc()
+        if str(type(E)).find('selenium') and traceback_string.find('Stacktrace:') != -1:
+            traceback_string = traceback_string.split('Stacktrace:', 1)[0]
+        console_log(traceback_string, ERROR, silent_mode=SILENT_MODE)
+
+    if PROXIES != [] and PROXY_ERROR_COUNTER == PROXY_ERROR_COUNTER_LIMIT:
+        PROXY_ERROR_COUNTER = 0
+        PROXIES.remove(PROXIES[0])
+        if PROXY_COUNTER < PROXIES_LEN:
+            PROXY_COUNTER += 1
+
+    if globals().get('DRIVER', None) is not None:
+        DRIVER.quit()
+    if not disable_exit:
+        exit_program(0)
+
+if __name__ == '__main__':
+    if MBCI_MODE:
+        config_manager = MBCIConfigManager()
+        if config_manager.is_exists:
+            try:
+                config_args = config_manager.load()
+                config_sys_argv = []
+                for key, value in config_args.items():
+                    if isinstance(value, bool) and not value:
+                        continue
+                    config_sys_argv.append('--'+key.replace('_', '-'))
+                    if not isinstance(value, bool):
+                        config_sys_argv.append(str(value))
+                parsed_args = parse_argv(config_sys_argv)
+                if parsed_args is not None:
+                    args = parsed_args
+                else:
+                    raise RuntimeError
+            except:
+                console_log("\nError loading the config, check its integrity!!!", WARN)
+                input('\nPress Enter to continue...')
+        parse_argv()
+        args['repeat'] = abs(args['repeat'])
+        try:
+            config_manager.save(args)
+        except:
+            console_log("\nError saving configuration, check write access!!!", WARN)
+            input('\nPress Enter to continue...')
+    else:
+        args = parse_argv()
+    
+    if args['disable_logging']:
+        logging.basicConfig(level=logging.CRITICAL+1)
+    else:
+        enable_logging()
+
+    logging.info(f'ESET-KeyGen Version: text={VERSION[0]}, index={VERSION[1]}')
+    logging.info(f'I_AM_EXECUTABLE={I_AM_EXECUTABLE}, OS={os.name}')
+    logging.info(f'sys.argv: {sys.argv}')
+
+    # Determine browser name for proxy loading
+    browser_name = None
+    if args['auto_detect_browser']:
+        result = WebDriverInstaller(None, None).detect_installed_browser()
+        if result is not None:
+            browser_name = result[0]
+    else:
+        if args['chrome']:
+            browser_name = GOOGLE_CHROME
+        elif args['firefox']:
+            browser_name = MOZILLA_FIREFOX
+        elif args['edge']:
+            browser_name = MICROSOFT_EDGE
+        elif args['safari']:
+            browser_name = APPLE_SAFARI
+
+    # Load proxies only if using Chrome and proxy file exists
+    if browser_name == GOOGLE_CHROME and os.path.exists(args['proxy_file']) and os.path.isfile(args['proxy_file']):
+        PROXIES = ChromeProxyExtensionManager.parse_proxies_from_file(args['proxy_file'])
+        PROXIES_LEN = len(PROXIES)
+
+    if args['repeat'] == 1 or args['repeat'] == 0:
+        main()
+    else:
+        args['skip_update_check'] = True
+        for i in range(args['repeat']):
+            try:
+                logging.info(f'------------ Initializing of {i+1} start ------------')
+                console_log(f'\n{Fore.MAGENTA}------------ Initializing of {Fore.YELLOW}{i+1} {Fore.MAGENTA}start ------------{Fore.RESET}\n', silent_mode=SILENT_MODE)
+                if i == 0:
+                    main(disable_exit=True)
+                    args['skip_webdriver_menu'] = True
+                elif i+1 == args['repeat']:
+                    main()
+                else:
+                    main(disable_exit=True)
+            except KeyboardInterrupt:
+                exit_program(0, DRIVER)

modules/EmailAPIs.py

@@ -0,0 +1,384 @@
+from .SharedTools import *
+
+from email import policy, parser
+
+import requests
+import time
+
+DEFINE_PARSE_10MINUTEMAIL_INBOX_FUNCTION = """function parse_10minutemail_inbox() {
+    updatemailbox()
+    let mails = Array.from(document.getElementsByTagName('tr')).slice(1)
+    let inbox = []
+    for(let i=0; i < mails.length; i++) {
+        let id = mails[i].children[0].children[0].href
+        let from = mails[i].children[0].innerText
+        let subject = mails[i].children[1].innerText
+        inbox.push([id, from, subject]) }
+    return inbox }"""
+PARSE_GUERRILLAMAIL_INBOX = """
+var email_list = document.getElementById('email_list').children
+var inbox = []
+for(var i=0; i < email_list.length-1; i++) {
+    var mail = email_list[i].children
+    var from = mail[1].innerText
+    var subject = mail[2].innerText
+    var mail_id = mail[0].children[0].value
+    inbox.push([mail_id, from, subject])
+}
+return inbox
+"""
+GET_GUERRILLAMAIL_DOMAINS = """
+var domains_options = document.getElementById('gm-host-select').options
+var domains = [] 
+for(var i=0; i < domains_options.length-1; i++) {
+    domains.push(domains_options[i].value)
+}
+return domains
+"""
+PARSE_MAILTICKING_INBOX = """function MailTickingParse() {
+    var inbox = []
+    var mlist = document.getElementById("message-list").children
+    for(i=0; i<mlist.length-1; i++) {
+        var mfields = mlist[i].children
+        var mail_id = mfields[0].children[0].href
+        var from = mfields[0].innerText
+        var subject = mfields[1].innerText
+        inbox.push([mail_id, from, subject])
+    }
+    return inbox;
+}
+return MailTickingParse()"""
+PARSE_FAKEMAIL_INBOX = """
+let raw_inbox = Array.from(document.getElementById('schranka').children).slice(0, -3)
+let inbox = []
+for(let i=0; i < raw_inbox.length; i++) {
+    let id = raw_inbox[i].dataset.href
+    let from = raw_inbox[i].children[0].children[1].tagName.toLowerCase()
+    let subject = raw_inbox[i].children[1].innerText.trim()
+    inbox.push([id, from, subject])
+}
+return inbox
+"""
+PARSE_1SECMAILPRO_INBOX = """
+let iframes = document.getElementsByTagName('iframe')
+let message_iframes = []
+for (let i = 0; i < iframes.length; i++) {
+    if (iframes[i].className.search('flex') !== -1)
+        message_iframes.push(iframes[i])
+}
+
+let messages = []
+let mailbox = document.getElementsByClassName('list')[0].children[1].children
+for(let i = 0; i < mailbox.length; i++) {
+    let temp = mailbox[i].innerText.split('\n')
+    messages.push([temp[1].trim(), temp[2].trim(), message_iframes[i].srcdoc])
+}
+return messages
+"""
+PARSE_INCOGNITOMAIL_INBOX = """
+let li_elements = document.getElementsByTagName('li')
+let messages_header = []
+for (let i = 0; i < li_elements.length; i++) {
+    let headers = li_elements[i].querySelectorAll('p')
+    try {
+        if (headers[0].title != '' && headers[1].title != '')
+            messages_header.push([headers[0], headers[0].title, headers[1].title])
+    } catch (error) { }
+}
+return messages_header
+"""
+
+class OneSecEmailAPI:
+    def __init__(self):
+        self.class_name = '1secmail'
+        self.__login = None
+        self.__domain = None
+        self.email = None
+        self.__api = 'https://www.1secmail.com/api/v1/'
+        
+    def init(self):
+        url = f'{self.__api}?action=genRandomMailbox&count=1'
+        try:
+            r = requests.get(url)
+        except:
+            raise RuntimeError('SecEmailAPI: API access error!')
+        if r.status_code != 200:
+            raise RuntimeError('SecEmailAPI: API access error!')
+        self.__login, self.__domain = str(r.content, 'utf-8')[2:-2].split('@')
+        self.email = self.__login+'@'+self.__domain
+    
+    def login(self, login, domain):
+        self.__login = login
+        self.__domain = domain
+    
+    def read_email(self):
+        url = f'{self.__api}?action=getMessages&login={self.__login}&domain={self.__domain}'
+        print(url)
+        try:
+            r = requests.get(url)
+        except:
+            raise RuntimeError('SecEmailAPI: API access error!')
+        if r.status_code != 200:
+            raise RuntimeError('SecEmailAPI: API access error!')
+        return r.json()
+    
+    def get_message(self, message_id):
+        url = f'{self.__api}?action=readMessage&login={self.__login}&domain={self.__domain}&id={message_id}'
+        print(url)
+        try:
+            r = requests.get(url)
+        except:
+            raise RuntimeError('SecEmailAPI: API access error!')
+        if r.status_code != 200:
+            raise RuntimeError('SecEmailAPI: API access error!')
+        return r.json()
+
+class DeveloperMailAPI:
+    def __init__(self):
+        self.class_name = 'developermail'
+        self.email = None
+        self.email_name = ''
+        self.headers = {}
+        self.api_url = 'https://www.developermail.com/api/v1'
+    
+    def init(self):
+        r = requests.put(f'{self.api_url}/mailbox')
+        self.email_name, token = list(r.json()['result'].values())
+        self.email = self.email_name+'@developermail.com'
+        self.headers = {'X-MailboxToken': token}
+
+    def __parse_message(self, raw_message_body):
+        message_bytes = raw_message_body.encode('utf-8')
+        msg = parser.BytesParser(policy=policy.default).parsebytes(message_bytes)
+        message_subject = msg['subject']
+        message_from = msg['from']
+        message_body = str(msg.get_payload(decode=True).decode(msg.get_content_charset())) # decoding MIME-Type to html
+        return {'subject':message_subject, 'from':message_from, 'body':message_body}
+
+    def get_messages(self):
+        # get message IDs
+        r = requests.get(
+            f'{self.api_url}/mailbox/{self.email_name}',
+            headers=self.headers
+        )
+        message_ids = r.json()['result']
+        if message_ids == []:
+            return None
+        # parse messages
+        messages = []
+        for message_id in message_ids:
+            try:
+                r = requests.get(f'{self.api_url}/mailbox/{self.email_name}/messages/{message_id}', headers=self.headers)
+                raw_message_body = r.json()['result']
+                messages.append(self.__parse_message(raw_message_body))
+            except:
+                continue
+        if messages == []:
+            messages = None
+        return messages
+    
+class GuerRillaMailAPI:
+    def __init__(self, driver: Chrome):
+        self.class_name = 'guerrillamail'
+        self.driver = driver
+        self.email = None
+        self.window_handle = None
+
+    def init(self):     
+        self.driver.get('https://www.guerrillamail.com/')
+        self.window_handle = self.driver.current_window_handle
+        untilConditionExecute(self.driver, f'return {GET_EBID}("email-widget") != null')
+        self.email = self.driver.execute_script(f'return {GET_EBID}("email-widget").innerText')
+        # change to random available domain
+        self.email = self.email.split('@')[0]+'@'+random.choice(self.driver.execute_script(GET_GUERRILLAMAIL_DOMAINS))
+    
+    def parse_inbox(self):
+        self.driver.switch_to.window(self.window_handle)
+        self.driver.get('https://www.guerrillamail.com/')
+        inbox = self.driver.execute_script(PARSE_GUERRILLAMAIL_INBOX)
+        return inbox
+
+    def open_mail(self, id):
+        self.driver.switch_to.window(self.window_handle)
+        self.driver.get(f'https://www.guerrillamail.com/inbox?mail_id={id}')
+
+class MailTickingAPI:
+    def __init__(self, driver: Chrome):
+        self.class_name = 'mailticking'
+        self.driver = driver
+        self.email = None
+        self.window_handle = None
+
+    def init(self):
+        try:
+            self.driver.get('https://www.mailticking.com')
+            self.window_handle = self.driver.current_window_handle
+            untilConditionExecute(self.driver, f'return {CLICK_WITH_BOOL}({GET_EBCN}("modal-footer text-center")[1].children[0])')
+            untilConditionExecute(self.driver, f'return {GET_EBID}("active-mail") != null')
+            time.sleep(3)
+            self.email = self.driver.execute_script(f'return {GET_EBID}("active-mail").value')
+            return True
+        except:
+            raise RuntimeError("MailTickingAPI.init Error!")
+    
+    def parse_inbox(self):
+        self.driver.switch_to.window(self.window_handle)
+        self.driver.get('https://www.mailticking.com')
+        try:
+            self.driver.execute_script(f'return {GET_EBID}("refresh-button")').click()
+            time.sleep(1)
+            inbox = self.driver.execute_script(PARSE_MAILTICKING_INBOX)
+        except:
+            inbox = []
+        return inbox
+
+    def open_mail(self, id):
+        self.driver.switch_to.window(self.window_handle)
+        self.driver.get(id)
+
+class FakeMailAPI:
+    def __init__(self, driver: Chrome):
+        self.class_name = 'fakemail'
+        self.driver = driver
+        self.email = None
+        self.window_handle = None
+
+    def init(self):     
+        self.driver.get('https://www.fakemail.net')
+        self.window_handle = self.driver.current_window_handle
+        untilConditionExecute(self.driver, f'return {GET_EBID}("email").innerText != null')
+        self.email = self.driver.execute_script(f'return {GET_EBID}("email").innerText')
+    
+    def parse_inbox(self):
+        self.driver.switch_to.window(self.window_handle)
+        self.driver.get('https://www.fakemail.net')
+        inbox = self.driver.execute_script(PARSE_FAKEMAIL_INBOX)
+        return inbox
+
+    def open_mail(self, id):
+        self.driver.switch_to.window(self.window_handle)
+        self.driver.get(f'https://www.fakemail.net/email/id/{id}')
+
+class InboxesAPI:
+    def __init__(self, driver: Chrome):
+        self.class_name = 'inboxes'
+        self.driver = driver
+        self.email = None
+        self.window_handle = None
+    
+    def init(self):
+        self.driver.get('https://inboxes.com')
+        self.window_handle = self.driver.current_window_handle
+        button = None
+        for _ in range(DEFAULT_MAX_ITER):
+            try:
+                button = self.driver.find_element('xpath', '//button[contains(text(), "Get my first inbox!")]')
+                break
+            except:
+                pass
+            time.sleep(DEFAULT_DELAY)
+        if button is not None:
+            button.click()
+            time.sleep(1)
+            for button in self.driver.execute_script(f'return {GET_EBTN}("button")'):
+                if button.text.strip().lower() == 'choose for me':
+                    button.click()
+                    break
+            time.sleep(2)
+            for element in self.driver.execute_script(f'return {GET_EBTN}("span")'):
+                new_email = ''.join(element.text.split())
+                if new_email is not None:
+                    new_email = re.match(r'[-a-z0-9+.]+@[a-z]+(\.[a-z]+)+', new_email)
+                    if new_email is not None:
+                        self.email = new_email.group()
+                        break
+    
+    def get_messages(self):
+        r = requests.get(f'https://inboxes.com/api/v2/inbox/{self.email}')
+        raw_inbox = r.json()['msgs']
+        messages = []
+        for message in raw_inbox:
+            r = requests.get(f'https://inboxes.com/api/v2/message/{message["uid"]}').json()
+            messages.append({
+                'from': r['ff'][0]['address'],
+                'subject': message['s'],
+                'body': r['html']
+            })
+        return messages
+
+"""class OneSecMailProAPI:
+    def __init__(self, driver: Chrome):
+        self.class_name = '1secmailpro'
+        self.driver = driver
+        self.email = None
+        self.window_handle = None
+    
+    def init(self):
+        self.driver.get("https://1secmail.pro")
+        self.window_handle = self.driver.current_window_handle
+        untilConditionExecute(self.driver, f"return {CLICK_WITH_BOOL}(document.querySelectorAll('input.block')[3])")
+        for _ in range(5):
+            if self.driver.page_source.lower().find('you have reached daily limit of maximum 5 temp mail addresses') != -1:
+                console_log('[1secmailpro]: Daily limit reached!', ERROR)
+                return False
+            time.sleep(DEFAULT_DELAY)
+        untilConditionExecute(self.driver, f"return {GET_EBID}('email_id').innerText != ''", delay=0.5, max_iter=20)
+        self.email = self.driver.execute_script(f"return {GET_EBID}('email_id').innerText")
+
+    def get_messages(self):
+        self.driver.switch_to.window(self.window_handle)
+        self.driver.get("https://1secmail.pro/mailbox")
+        for _ in range(5):
+            try:
+                messages_list = self.driver.execute_script(PARSE_1SECMAILPRO_INBOX)
+                print(messages_list)
+                if messages_list is not None:
+                    messages = []
+                    for message in messages_list:
+                        messages.append({
+                            'from': message[0],
+                            'subject': message[1],
+                            'body': message[2]
+                        })
+                    return messages
+            except Exception as E:
+                pass
+            time.sleep(DEFAULT_DELAY)"""
+
+class IncognitoMailAPI:
+    def __init__(self, driver: Chrome):
+        self.class_name = 'incognitomail'
+        self.driver = driver
+        self.email = None
+        self.window_handle = None
+    
+    def init(self):
+        self.driver.get("https://incognitomail.co/")
+        self.window_handle = self.driver.current_window_handle
+        untilConditionExecute(self.driver, f"return {GET_EBAV}('button', 'aria-label', 'Email dropdown').textContent != 'Creating...'")
+        self.email = self.driver.execute_script(f"return {GET_EBAV}('button', 'aria-label', 'Email dropdown').textContent")
+
+    def parse_inbox(self):
+        self.driver.switch_to.window(self.window_handle)
+        self.driver.get("https://incognitomail.co")
+        for _ in range(3):
+            try:
+                inbox_headers = self.driver.execute_script(PARSE_INCOGNITOMAIL_INBOX)
+                if inbox_headers != [] and inbox_headers is not None:
+                    return inbox_headers
+            except Exception as E:
+                pass
+            time.sleep(DEFAULT_DELAY)
+        return []
+
+    def open_mail(self, web_element):
+        self.driver.switch_to.window(self.window_handle)
+        web_element.click()
+
+
+class CustomEmailAPI:
+    def __init__(self):
+        self.class_name = 'custom'
+        self.email = None
+
+WEB_WRAPPER_EMAIL_APIS_CLASSES = (GuerRillaMailAPI, MailTickingAPI, FakeMailAPI, InboxesAPI, IncognitoMailAPI)

modules/EsetTools.py

@@ -0,0 +1,515 @@
+from .EmailAPIs import *
+
+from pathlib import Path
+
+import subprocess
+import colorama
+import logging
+import time
+import sys
+
+SILENT_MODE = '--silent' in sys.argv
+
+class IPBlockedException(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+
+class EsetRegister(object):
+    def __init__(self, registered_email_obj: OneSecEmailAPI, eset_password: str, driver: Chrome):
+        self.email_obj = registered_email_obj
+        self.eset_password = eset_password
+        self.driver = driver
+        self.window_handle = None
+
+    def createAccount(self):
+        exec_js = self.driver.execute_script
+        uCE = untilConditionExecute
+        
+        logging.info('[EMAIL] Register page loading...')
+        console_log('\n[EMAIL] Register page loading...', INFO, silent_mode=SILENT_MODE)
+        if isinstance(self.email_obj, WEB_WRAPPER_EMAIL_APIS_CLASSES):
+            self.driver.switch_to.new_window('tab')
+            self.window_handle = self.driver.current_window_handle
+        self.driver.get('https://login.eset.com/Register')
+        uCE(self.driver, f"return {GET_EBID}('email') != null")
+        logging.info('[EMAIL] Register page is loaded!')
+        console_log('[EMAIL] Register page is loaded!', OK, silent_mode=SILENT_MODE)
+
+        logging.info('Bypassing cookies...')
+        console_log('\nBypassing cookies...', INFO, silent_mode=SILENT_MODE)
+        if uCE(self.driver, f"return {CLICK_WITH_BOOL}({GET_EBAV}('button', 'id', 'cc-accept'))", max_iter=10, raise_exception_if_failed=False):
+            logging.info('Cookies successfully bypassed!')
+            console_log('Cookies successfully bypassed!', OK, silent_mode=SILENT_MODE)
+            time.sleep(1) # Once pressed, you have to wait a little while. If code do not do this, the site does not count the acceptance of cookies
+        else:
+            logging.info('Cookies were not bypassed (it doesn\'t affect the algorithm, I think :D)')
+            console_log("Cookies were not bypassed (it doesn't affect the algorithm, I think :D)", ERROR, silent_mode=SILENT_MODE)
+
+        exec_js(f"return {GET_EBID}('email')").send_keys(self.email_obj.email)
+        uCE(self.driver, f"return {CLICK_WITH_BOOL}({DEFINE_GET_EBAV_FUNCTION}('button', 'data-label', 'register-continue-button'))")
+
+        logging.info('[PASSWD] Register page loading...')
+        console_log('\n[PASSWD] Register page loading...', INFO, silent_mode=SILENT_MODE)
+        uCE(self.driver, f"return typeof {GET_EBAV}('button', 'data-label', 'register-create-account-button') === 'object'")
+        logging.info('[PASSWD] Register page is loaded!')
+        console_log('[PASSWD] Register page is loaded!', OK, silent_mode=SILENT_MODE)
+        exec_js(f"return {GET_EBID}('password')").send_keys(self.eset_password)
+        
+        # Select Ukraine country
+        logging.info('Selecting the country...')
+        if exec_js(f"return {GET_EBCN}('select__single-value ltr-1dimb5e-singleValue')[0]").text != 'Ukraine':
+            exec_js(f"return {GET_EBCN}('select__control ltr-13cymwt-control')[0]").click()
+            for country in exec_js(f"return {GET_EBCN}('select__option ltr-uhiml7-option')"):
+                if country.text == 'Ukraine':
+                    country.click()
+                    logging.info('Country selected!')
+                    break
+
+        uCE(self.driver, f"return {CLICK_WITH_BOOL}({DEFINE_GET_EBAV_FUNCTION}('button', 'data-label', 'register-create-account-button'))")
+        
+        for _ in range(DEFAULT_MAX_ITER):
+            title = exec_js('return document.title')
+            if title == 'Service not available':
+                raise IPBlockedException('\nESET temporarily blocked your IP, try again later!!! Try to use VPN/Proxy or try to change Email API!!!')
+            url = exec_js('return document.URL')
+            if url == 'https://home.eset.com/':
+                return True
+            time.sleep(DEFAULT_DELAY)
+        raise IPBlockedException('\nESET temporarily blocked your IP, try again later!!! Try to use VPN/Proxy or try to change Email API!!!')
+
+    def confirmAccount(self):
+        uCE = untilConditionExecute
+        #uCE(self.driver, f'return {CLICK_WITH_BOOL}({GET_EBAV}("ion-button", "data-r", "account-verification-email-modal-resend-email-btn"))') # accelerating the receipt of an eset token
+        
+        if isinstance(self.email_obj, CustomEmailAPI):
+            token = parseToken(self.email_obj, max_iter=100, delay=3)
+        else:
+            logging.info(f'[{self.email_obj.class_name}] ESET-HOME-Token interception...')
+            console_log(f'\n[{self.email_obj.class_name}] ESET-HOME-Token interception...', INFO, silent_mode=SILENT_MODE)
+            if isinstance(self.email_obj, WEB_WRAPPER_EMAIL_APIS_CLASSES):
+                token = parseToken(self.email_obj, self.driver, max_iter=100, delay=3)
+                self.driver.switch_to.window(self.window_handle)
+            else:
+                token = parseToken(self.email_obj, max_iter=100, delay=3) # 1secmail, developermail
+        logging.info(f'ESET-HOME-Token: {token}')
+        logging.info('Account confirmation is in progress...')
+        console_log(f'ESET-HOME-Token: {token}', OK, silent_mode=SILENT_MODE)
+        console_log('\nAccount confirmation is in progress...', INFO, silent_mode=SILENT_MODE)
+        self.driver.get(f'https://login.eset.com/link/confirmregistration?token={token}')
+        uCE(self.driver, 'return document.title === "ESET HOME"')
+        try:
+            uCE(self.driver, f'return {GET_EBCN}("verification-email_p").length === 0')
+        except:
+            self.driver.get(f'https://login.eset.com/link/confirmregistration?token={token}')
+            uCE(self.driver, 'return document.title === "ESET HOME"')
+            uCE(self.driver, f'return {GET_EBCN}("verification-email_p").length === 0')
+        logging.info('Account successfully confirmed!')
+        console_log('Account successfully confirmed!', OK, silent_mode=SILENT_MODE)
+        return True
+
+class EsetKeygen(object):
+    def __init__(self, registered_email_obj: OneSecEmailAPI, driver: Chrome, mode='ESET HOME'):
+        self.email_obj = registered_email_obj
+        self.driver = driver
+        self.mode = mode.upper()
+        if self.mode not in ['ESET HOME', 'SMALL BUSINESS']:
+            raise RuntimeError('Undefined keygen mode!')
+        
+    def sendRequestForKey(self):
+        uCE = untilConditionExecute
+
+        logging.info(f'[{self.mode}] Request sending...')
+        console_log(f'\n[{self.mode}] Request sending...', INFO, silent_mode=SILENT_MODE)
+        self.driver.get('https://home.eset.com/subscriptions/choose-trial')
+        uCE(self.driver, f"return {GET_EBAV}('button', 'data-label', 'subscription-choose-trial-ehsp-card-button') != null")
+        if self.mode == 'ESET HOME':
+            uCE(self.driver, f"return {CLICK_WITH_BOOL}({GET_EBAV}('button', 'data-label', 'subscription-choose-trial-ehsp-card-button'))")
+        elif self.mode == 'SMALL BUSINESS':
+            uCE(self.driver, f"return {CLICK_WITH_BOOL}({GET_EBAV}('button', 'data-label', 'subscription-choose-trial-esbs-card-button'))")
+        try:
+            for button in self.driver.find_elements('tag name', 'button'):
+                if button.get_attribute('innerText').strip().lower() == 'continue':
+                    button.click()
+                    break
+                time.sleep(0.05)
+            else:
+                raise RuntimeError('Continue button error!')
+            uCE(self.driver, f"return {CLICK_WITH_BOOL}({GET_EBAV}('button', 'data-label', 'subscription-choose-trial-esbs-card-button'))")
+            time.sleep(1)
+            for button in self.driver.find_elements('tag name', 'button'):
+                if button.get_attribute('innerText').strip().lower() == 'continue':
+                    button.click()
+                    break
+                time.sleep(0.05)
+            else:
+                raise RuntimeError('Continue button error!')
+            logging.info(f'[{self.mode}] Request successfully sent!')
+            console_log(f'[{self.mode}] Request successfully sent!', OK, silent_mode=SILENT_MODE)
+        except:
+            raise RuntimeError('Request sending error!!!')
+
+    def getLD(self):
+        exec_js = self.driver.execute_script
+        uCE = untilConditionExecute
+        logging.info(f'License uploads...')
+        console_log('\nLicense uploads...', INFO, silent_mode=SILENT_MODE)
+        uCE(self.driver, f"return {GET_EBAV}('div', 'data-label', 'license-detail-info') != null", raise_exception_if_failed=False)
+        if self.driver.current_url.find('detail') != -1:
+            logging.info(f'License ID: {self.driver.current_url[-11:]}')
+            console_log(f'License ID: {self.driver.current_url[-11:]}', OK, silent_mode=SILENT_MODE)
+        uCE(self.driver, f"return {GET_EBAV}('div', 'data-label', 'license-detail-product-name') != null", max_iter=10)
+        uCE(self.driver, f"return {GET_EBAV}('div', 'data-label', 'license-detail-license-model-additional-info') != null", max_iter=10)
+        uCE(self.driver, f"return {GET_EBAV}('div', 'data-label', 'license-detail-license-key') != null", max_iter=10)
+        license_name = exec_js(f"return {GET_EBAV}('div', 'data-label', 'license-detail-product-name').innerText")
+        license_out_date = exec_js(f"return {GET_EBAV}('div', 'data-label', 'license-detail-license-model-additional-info').innerText")
+        license_key = exec_js(f"return {GET_EBAV}('div', 'data-label', 'license-detail-license-key').innerText")
+        logging.info('Information successfully received!')
+        console_log('Information successfully received!', OK, silent_mode=SILENT_MODE)
+        return license_name, license_key, license_out_date
+
+class EsetVPN(object):
+    def __init__(self, registered_email_obj: OneSecEmailAPI, driver: Chrome, EsetRegister_window_handle=None):
+        self.email_obj = registered_email_obj
+        self.driver = driver
+        self.window_handle = EsetRegister_window_handle
+        
+    def sendRequestForVPNCodes(self):
+        exec_js = self.driver.execute_script
+        uCE = untilConditionExecute
+        
+        logging.info('Sending a request for VPN subscriptions...')
+        console_log('\nSending a request for VPN subscriptions...', INFO, silent_mode=SILENT_MODE)
+        self.driver.get("https://home.eset.com/security-features")
+        try:
+            uCE(self.driver, f'return {CLICK_WITH_BOOL}({GET_EBAV}("button", "data-label", "security-feature-explore-button"))', max_iter=10)
+        except:
+            raise RuntimeError('Explore-feature-button error!')
+        time.sleep(0.5)
+        for profile in exec_js(f'return {GET_EBAV}("button", "data-label", "choose-profile-tile-button", -1)'): # choose Me profile
+            if profile.get_attribute("innerText").find(self.email_obj.email) != -1: # Me profile contains an email address
+                profile.click()
+        uCE(self.driver, f'return {CLICK_WITH_BOOL}({GET_EBAV}("button", "data-label", "choose-profile-continue-btn"))', max_iter=5)
+        uCE(self.driver, f'return {GET_EBAV}("ion-button", "robot", "choose-device-counter-increment-button") != null', max_iter=10)
+        for _ in range(9): # increasing 'Number of devices' (to 10)
+            exec_js(f'{GET_EBAV}("ion-button", "robot", "choose-device-counter-increment-button").click()')
+        exec_js(f'{GET_EBAV}("button", "data-label", "choose-device-count-submit-button").click()')
+        uCE(self.driver, f'return {GET_EBAV}("button", "data-label", "pwm-instructions-sent-download-button") != null', max_iter=15)
+        logging.info('Request successfully sent!')
+        console_log('Request successfully sent!', OK, silent_mode=SILENT_MODE)
+        return True
+    
+    def getVPNCodes(self):
+        if isinstance(self.email_obj, CustomEmailAPI):
+            logging.warning('Wait for a message to your e-mail about instructions on how to set up the VPN!!!')
+            console_log('\nWait for a message to your e-mail about instructions on how to set up the VPN!!!', WARN, True, SILENT_MODE)
+            return None
+        else:
+            logging.info(f'[{self.email_obj.class_name}] VPN Codes interception...')
+            console_log(f'\n[{self.email_obj.class_name}] VPN Codes interception...', INFO, silent_mode=SILENT_MODE) # timeout 1.5m
+            if isinstance(self.email_obj, WEB_WRAPPER_EMAIL_APIS_CLASSES):
+                vpn_codes = parseVPNCodes(self.email_obj, self.driver, delay=2, max_iter=45)
+                self.driver.switch_to.window(self.window_handle)
+            else:
+                vpn_codes = parseVPNCodes(self.email_obj, self.driver, delay=2, max_iter=45) # 1secmail, developermail
+                logging.info('Information successfully received!')
+                console_log('Information successfully received!', OK, silent_mode=SILENT_MODE)
+        return vpn_codes
+
+class EsetProtectHubRegister(object):
+    def __init__(self, registered_email_obj: OneSecEmailAPI, eset_password: str, driver: Chrome):
+        self.email_obj = registered_email_obj
+        self.driver = driver
+        self.eset_password = eset_password
+        self.window_handle = None
+        
+    def createAccount(self):
+        exec_js = self.driver.execute_script
+        uCE = untilConditionExecute
+        # STEP 0
+
+        logging.info('Loading ESET ProtectHub Page...')
+        console_log('\nLoading ESET ProtectHub Page...', INFO, silent_mode=SILENT_MODE)
+        if isinstance(self.email_obj, WEB_WRAPPER_EMAIL_APIS_CLASSES):
+            self.driver.switch_to.new_window('tab')
+            self.window_handle = self.driver.current_window_handle
+        self.driver.get('https://protecthub.eset.com/public/registration?culture=en-US')
+        uCE(self.driver, f'return {GET_EBID}("continue") != null')
+        logging.info('Successfully!')
+        console_log('Successfully!', OK, silent_mode=SILENT_MODE)
+
+        # STEP 1
+        logging.info('Data filling...')
+        console_log('\nData filling...', INFO, silent_mode=SILENT_MODE)
+        exec_js(f'return {GET_EBID}("email-input")').send_keys(self.email_obj.email)
+        exec_js(f'return {GET_EBID}("company-name-input")').send_keys(dataGenerator(10))
+        # Select country
+        exec_js(f"return {GET_EBID}('country-select')").click()
+        selected_country = 'Ukraine'
+        logging.info('Selecting the country...')
+        for country in self.driver.find_elements('xpath', '//div[starts-with(@class, "select")]'):
+            if country.text == selected_country:
+                country.click()
+                logging.info('Country selected!')
+                break
+        exec_js(f'return {GET_EBID}("company-vat-input")').send_keys(dataGenerator(10, True))
+        exec_js(f'return {GET_EBID}("company-crn-input")').send_keys(dataGenerator(10, True))
+        logging.warning('Solve the captcha on the page manually!!!')
+        console_log(f'\n{colorama.Fore.CYAN}Solve the captcha on the page manually!!!{colorama.Fore.RESET}', INFO, False, SILENT_MODE)
+        while True: # captcha
+            try:
+                mtcaptcha_solved_token = exec_js(f'return {GET_EBCN}("mtcaptcha-verifiedtoken")[0].value')
+                if mtcaptcha_solved_token.strip() != '':
+                    break
+            except Exception as E:
+                pass
+            time.sleep(1)
+        exec_js(f'return {GET_EBID}("continue").click()')
+        try:
+            uCE(self.driver, f'return {GET_EBID}("registration-email-sent").innerText === "We sent you a verification email"', max_iter=10)
+            logging.info('Successfully!')
+            console_log('Successfully!', OK, silent_mode=SILENT_MODE)
+        except:
+            raise IPBlockedException('\nESET temporarily blocked your IP, try again later!!! Try to use VPN/Proxy or try to change Email API!!!')
+        return True
+
+    def activateAccount(self):
+        exec_js = self.driver.execute_script
+        uCE = untilConditionExecute
+
+        # STEP 1
+        logging.info('Data filling...')
+        console_log('\nData filling...', INFO, silent_mode=SILENT_MODE)
+        exec_js(f'return {GET_EBID}("first-name-input")').send_keys(dataGenerator(10))
+        exec_js(f'return {GET_EBID}("last-name-input")').send_keys(dataGenerator(10))
+        exec_js(f'return {GET_EBID}("first-name-input")').send_keys(dataGenerator(10))
+        exec_js(f'return {GET_EBID}("password-input")').send_keys(self.eset_password)
+        exec_js(f'return {GET_EBID}("password-repeat-input")').send_keys(self.eset_password)
+        exec_js(f'return {GET_EBID}("continue").click()')
+
+        # STEP 2
+        uCE(self.driver, f'return {GET_EBID}("phone-input") != null')
+        exec_js(f'return {GET_EBID}("phone-input")').send_keys(dataGenerator(10, True))
+        exec_js(f'{GET_EBID}("tou-checkbox").click()')
+        time.sleep(0.3)
+        exec_js(f'return {GET_EBID}("continue").click()')
+        uCE(self.driver, f'return {GET_EBID}("activated-user-title").innerText === "Your account has been successfully activated"', max_iter=15)
+        logging.info('Successfully!')
+        console_log('Successfully!', OK, silent_mode=SILENT_MODE)
+
+    def confirmAccount(self):
+        if isinstance(self.email_obj, CustomEmailAPI):
+            token = parseToken(self.email_obj, eset_business=True, max_iter=100, delay=3)
+        else:
+            logging.info(f'[{self.email_obj.class_name}] ProtectHub-Token interception...')
+            console_log(f'\n[{self.email_obj.class_name}] ProtectHub-Token interception...', INFO, silent_mode=SILENT_MODE)
+            if isinstance(self.email_obj, WEB_WRAPPER_EMAIL_APIS_CLASSES):
+                token = parseToken(self.email_obj, self.driver, True, max_iter=100, delay=3)
+                self.driver.switch_to.window(self.window_handle)
+            else:
+                token = parseToken(self.email_obj, eset_business=True, max_iter=100, delay=3) # 1secmail
+        logging.info(f'ProtectHub-Token: {token}')
+        logging.info('Account confirmation is in progress...')
+        console_log(f'ProtectHub-Token: {token}', OK, silent_mode=SILENT_MODE)
+        console_log('\nAccount confirmation is in progress...', INFO, silent_mode=SILENT_MODE)
+        self.driver.get(f'https://protecthub.eset.com/public/activation/{token}/?culture=en-US')
+        untilConditionExecute(self.driver, f'return {GET_EBID}("first-name-input") != null')
+        logging.info('Account successfully confirmed!')
+        console_log('Account successfully confirmed!', OK, silent_mode=SILENT_MODE)
+
+class EsetProtectHubKeygen(object):
+    def __init__(self, registered_email_obj: OneSecEmailAPI, eset_password: str, driver: Chrome):
+        self.email_obj = registered_email_obj
+        self.eset_password = eset_password
+        self.driver = driver
+
+    def getLD(self):
+        exec_js = self.driver.execute_script
+        uCE = untilConditionExecute
+
+        # Log in
+        logging.info('Logging in to the created account...')
+        console_log('\nLogging in to the created account...', INFO, silent_mode=SILENT_MODE)
+        self.driver.get('https://protecthub.eset.com')
+        uCE(self.driver, f'return {GET_EBID}("username") != null')
+        exec_js(f'return {GET_EBID}("username")').send_keys(self.email_obj.email)
+        exec_js(f'return {GET_EBID}("password")').send_keys(self.eset_password)
+        exec_js(f'return {GET_EBID}("btn-login").click()')
+        
+        # Start free trial
+        uCE(self.driver, f'return {GET_EBID}("welcome-dialog-generate-trial-license") != null', delay=3)
+        logging.info('Successfully!')
+        logging.info('Sending a request for a get license...')
+        console_log('Successfully!', OK, silent_mode=SILENT_MODE)
+        console_log('\nSending a request for a get license...', INFO, silent_mode=SILENT_MODE)
+        try:
+            exec_js(f'return {GET_EBID}("welcome-dialog-generate-trial-license").click()')
+            exec_js(f'return {GET_EBID}("welcome-dialog-generate-trial-license")').click()
+        except:
+            pass
+        
+        # Waiting for a response from the site
+        license_is_being_generated = False
+        for _ in range(DEFAULT_MAX_ITER):
+            try:
+                r = exec_js(f"return {GET_EBCN}('Toastify__toast-body toastBody')[0].innerText").lower()
+                if r.find('is being generated') != -1:
+                    license_is_being_generated = True
+                    logging.info('Request successfully sent!')
+                    console_log('Request successfully sent!', OK, silent_mode=SILENT_MODE)
+                    try:
+                        exec_js(f'return {GET_EBID}("welcome-dialog-skip-button").click()')
+                        exec_js(f'return {GET_EBID}("welcome-dialog-skip-button")').click()
+                    except:
+                        pass
+                    break
+            except Exception as E:
+                pass
+            time.sleep(DEFAULT_DELAY)
+        
+        if not license_is_being_generated:
+            raise RuntimeError('The request has not been sent!')
+        
+        logging.info('Waiting for a back response...')
+        console_log('\nWaiting for a back response...', INFO, silent_mode=SILENT_MODE)
+        license_was_generated = False
+        for _ in range(DEFAULT_MAX_ITER*10): # 5m
+            try:
+                r = exec_js(f"return {GET_EBCN}('Toastify__toast-body toastBody')[0].innerText").lower()
+                if r.find('couldn\'t be generated') != -1:
+                    break
+                elif r.find('was generated') != -1:
+                    logging.info('Successfully!')
+                    console_log('Successfully!', OK, silent_mode=SILENT_MODE)
+                    license_was_generated = True
+                    break
+            except Exception as E:
+                pass
+            time.sleep(DEFAULT_DELAY)
+
+        if not license_was_generated:
+            raise RuntimeError('The license cannot be generated, try again later!')
+
+        # Obtaining license data from the site
+        logging.info('[Site] License uploads...')
+        console_log('\n[Site] License uploads...', INFO, silent_mode=SILENT_MODE)
+        license_name = 'ESET PROTECT Advanced'
+        try:
+            self.driver.get('https://protecthub.eset.com/licenses')
+            uCE(self.driver, f'return {GET_EBAV}("div", "data-label", "license-list-body-cell-renderer-row-0-column-0").innerText != ""')
+            license_id = exec_js(f'{DEFINE_GET_EBAV_FUNCTION}\nreturn {GET_EBAV}("div", "data-label", "license-list-body-cell-renderer-row-0-column-0").innerText')
+            logging.info(f'License ID: {license_id}')
+            logging.info('Getting information from the license...')
+            console_log(f'License ID: {license_id}', OK, silent_mode=SILENT_MODE)
+            console_log('\nGetting information from the license...', INFO, silent_mode=SILENT_MODE)
+            self.driver.get(f'https://protecthub.eset.com/licenses/details/2/{license_id}/overview')
+            uCE(self.driver, f'return {GET_EBAV}("div", "data-label", "license-overview-validity-value") != null')
+            license_out_date = exec_js(f'{DEFINE_GET_EBAV_FUNCTION}\nreturn {GET_EBAV}("div", "data-label", "license-overview-validity-value").children[0].children[0].innerText')
+            # Obtaining license key
+            exec_js(f'{DEFINE_GET_EBAV_FUNCTION}\n{GET_EBAV}("div", "data-label", "license-overview-key-value").children[0].children[0].click()')
+            uCE(self.driver, f'return {GET_EBID}("show-license-key-auth-modal-password-input") != null')
+            exec_js(f'return {GET_EBID}("show-license-key-auth-modal-password-input")').send_keys(self.eset_password)
+            try:
+                exec_js(f'return {GET_EBID}("show-license-key-auth-modal-authenticate").click()')
+                exec_js(f'return {GET_EBID}("show-license-key-auth-modal-authenticate")').click()
+            except:
+                pass
+            for _ in range(DEFAULT_MAX_ITER):
+                try:
+                    license_key = exec_js(f'return {GET_EBAV}("div", "data-label", "license-overview-key-value").children[0].textContent.trim()')
+                    if license_key is not None and not license_key.startswith('XXXX-XXXX-XXXX-XXXX-XXXX'): # ignoring XXXX-XXXX-XXXX-XXXX-XXXX
+                        license_key = license_key.split(' ')[0]
+                        logging.info('Information successfully received!')
+                        console_log('Information successfully received!', OK, silent_mode=SILENT_MODE)
+                        return license_name, license_key, license_out_date, True # True - License key obtained from the site
+                except:
+                    pass
+                time.sleep(DEFAULT_DELAY)
+        except Exception as E:
+            logging.critical("EXC_INFO:", exc_info=True)
+            console_log('Error when obtaining a license key from the site!!!', ERROR, silent_mode=SILENT_MODE)
+        # Obtaining license data from the email
+        logging.info('[Email] License uploads...')
+        console_log('\n[Email] License uploads...', INFO, silent_mode=SILENT_MODE)
+        if self.email_obj.class_name == 'custom':
+            logging.warning('Wait for a message to your e-mail about successful key generation!!!')
+            console_log('\nWait for a message to your e-mail about successful key generation!!!', WARN, True, SILENT_MODE)
+            return None, None, None, None
+        else:    
+            license_key, license_out_date, license_id = parseEPHKey(self.email_obj, self.driver, delay=5, max_iter=30) # 2.5m 
+            logging.info(f'License ID: {license_id}')
+            logging.info('Getting information from the license...')
+            logging.info('Information successfully received!')
+            console_log(f'License ID: {license_id}', OK, silent_mode=SILENT_MODE)
+            console_log('\nGetting information from the license...', INFO, silent_mode=SILENT_MODE)
+            console_log('Information successfully received!', OK, silent_mode=SILENT_MODE)
+            return license_name, license_key, license_out_date, False # False - License key obtained from the email
+    
+    def removeLicense(self):
+        logging.info('Deleting the key from the account, the key will still work...')
+        console_log('Deleting the key from the account, the key will still work...', INFO, silent_mode=SILENT_MODE)
+        try:
+            self.driver.execute_script(f'return {GET_EBID}("license-actions-button")').click()
+            time.sleep(1)
+            button = self.driver.find_element('xpath', '//a[.//div[text()="Remove license"]]')
+            if button is not None:
+                button.click()
+            untilConditionExecute(self.driver, f'return {CLICK_WITH_BOOL}({GET_EBID}("remove-license-dlg-remove-btn"))', max_iter=15)
+            time.sleep(2)
+            for _ in range(DEFAULT_MAX_ITER//2):
+                try:
+                    self.driver.execute_script(f'return {GET_EBID}("remove-license-dlg-remove-btn")').click()
+                except:
+                    pass
+                if self.driver.page_source.lower().find('to keep the solutions up to date') == -1:
+                    time.sleep(1)
+                    logging.info('Key successfully deleted!!!')
+                    console_log('Key successfully deleted!!!', OK, silent_mode=SILENT_MODE)
+                    return True
+                time.sleep(DEFAULT_DELAY)
+        except:
+            pass
+        logging.error('Failed to delete key, this error has no effect on the operation of the key!!!')
+        console_log('Failed to delete key, this error has no effect on the operation of the key!!!', ERROR, silent_mode=SILENT_MODE)
+
+def EsetVPNResetWindows(key_path='SOFTWARE\\ESET\\ESET VPN', value_name='authHash'):
+    """Deletes the authHash value of ESET VPN"""
+    try:
+        subprocess.check_output(['taskkill', '/f', '/im', 'esetvpn.exe'], stderr=subprocess.DEVNULL)
+    except:
+        pass
+    try:
+        import winreg
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path, 0, winreg.KEY_ALL_ACCESS) as key:
+            winreg.DeleteValue(key, value_name)
+        logging.info('ESET VPN has been successfully reset!!!')
+        console_log('ESET VPN has been successfully reset!!!', OK, silent_mode=SILENT_MODE)
+    except FileNotFoundError:
+        logging.error(f'The registry value or key does not exist: {key_path}\\{value_name}')
+        console_log(f'The registry value or key does not exist: {key_path}\\{value_name}', ERROR, silent_mode=SILENT_MODE)
+    except PermissionError:
+        logging.error(f'Permission denied while accessing: {key_path}\\{value_name}')
+        console_log(f'Permission denied while accessing: {key_path}\\{value_name}', ERROR, silent_mode=SILENT_MODE)
+    except Exception as e:
+        raise RuntimeError(e)
+
+def EsetVPNResetMacOS(app_name='ESET VPN', file_name='Preferences/com.eset.ESET VPN.plist'):
+    try:
+        # Use AppleScript to quit the application
+        script = f'tell application "{app_name}" to quit'
+        subprocess.run(["osascript", "-e", script], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except:
+        pass
+    try:
+        time.sleep(2)
+        # Get the full path to the file in the Library folder
+        library_path = Path.home() / "Library" / file_name
+        # Check if the file exists and remove it
+        if library_path.is_file():
+            library_path.unlink()
+            logging.info('ESET VPN has been successfully reset!!!')
+            console_log('ESET VPN has been successfully reset!!!', OK, silent_mode=SILENT_MODE)
+        else:
+            logging.error(f"File '{file_name}' does not exist!!!")
+            console_log(f"File '{file_name}' does not exist!!!", ERROR, silent_mode=SILENT_MODE)
+    except Exception as e:
+        raise RuntimeError(e)

modules/MBCI.py

@@ -0,0 +1,122 @@
+from colorama import Fore
+
+import os
+
+def clear_console():
+    if os.name == 'nt':
+        os.system('cls')
+    else:
+        os.system('clear')
+
+class MenuAction(object):
+    def __init__(self, title, func):
+        self.title = title
+        self.function = func
+
+    def render_title(self):
+        return self.title
+    
+    def run(self):
+        if isinstance(self.function, ViewMenu):
+            self.function.view()
+        else:
+            self.function()
+
+class OptionAction(object):
+    def __init__(self, args, title, action, args_names, choices=[], default_value=None, data_type=str, data_range=None):
+        self.args = args
+        self.title = title
+        self.action = action
+        self.value = default_value
+        self.choices = choices
+        self.args_names = args_names
+        self.data_type = data_type
+        self.data_range = data_range
+
+    def render_title(self):
+        if self.action in ['store_true', 'choice']:
+            return f'{self.title} (selected: {Fore.YELLOW}{self.value}{Fore.RESET})'
+        elif self.action == 'manual_input':
+            return f'{self.title} (saved: {Fore.YELLOW}{self.value}{Fore.RESET})'
+        elif self.action == 'bool_switch':
+            if self.args[self.args_names.replace('-', '_')]:
+                return f'{self.title} {Fore.GREEN}(enabled){Fore.RESET}'
+            return f'{self.title} {Fore.RED}(disabled){Fore.RESET}'
+        
+    def run(self):
+        if self.action == 'bool_switch':
+            self.args[self.args_names.replace('-', '_')] = not self.args[self.args_names.replace('-', '_')]
+            return True
+        execution = True
+        while True:
+            clear_console()
+            print(self.title+'\n')
+            menu_items = []
+            if self.choices != []:
+                menu_items = self.choices
+            else:
+                menu_items = self.args_names
+            if self.action != 'manual_input':
+                for index in range(0, len(menu_items)):
+                    menu_item = menu_items[index]
+                    print(f'{index+1} - {menu_item}')
+                print()
+            try:
+                if self.action == 'manual_input':
+                    while True:
+                        if self.data_range is not None:
+                            print('Allowed values: '+str(self.data_range)+'\n')
+                        self.value = input('>>> ').strip()
+                        try:
+                            self.value = self.data_type(self.value)
+                            if self.data_range is not None:
+                                if self.value not in self.data_range:
+                                    raise
+                            self.args[self.args_names.replace('-', '_')] = self.value # self.args_names is str
+                            execution = False
+                            break
+                        except:
+                            clear_console()
+                            print(self.title+'\n')
+                if not execution:
+                    break
+                index = int(input('>>> ').strip()) - 1
+                self.value = menu_items[index]
+                if index in range(0, len(menu_items)):
+                    if self.action == 'store_true':
+                        for args_name in self.args_names: # self.args_names is list
+                            self.args[args_name.replace('-', '_')] = False
+                        self.args[self.value.replace('-', '_')] = True # self.value == args_name
+                    elif self.action == 'choice':
+                        self.args[self.args_names.replace('-', '_')] = self.value # self.args_names is str
+                    break
+            except ValueError:
+                pass
+
+class ViewMenu(object):
+    def __init__(self, title):
+        self.title = title
+        self.items = []
+        self.execution = True
+
+    def add_item(self, menu_action_object: MenuAction):
+        self.items.append(menu_action_object)
+    
+    def view(self):
+        self.execution = True
+        while self.execution:
+            clear_console()
+            print(self.title+'\n')
+            for item_index in range(0, len(self.items)):
+                item = self.items[item_index]
+                print(f'{item_index+1} - {item.render_title()}')
+            print()
+            try:
+                selected_item_index = int(input('>>> ')) - 1
+                if selected_item_index in range(0, len(self.items)):
+                    self.items[selected_item_index].run()
+            except ValueError:
+                pass
+    
+    def close(self):
+        self.execution = False

modules/ProgressBar.py

@@ -0,0 +1,55 @@
+from colorama import Fore, init as colorama_init
+
+import decimal
+import platform
+import sys
+
+colorama_init()
+
+class ProgressBarStyle:
+    def __init__(self, advance_char='█', empty_advance_char='▓', progressbar_length=30):
+        self.advance_char = advance_char
+        self.empty_advance_char = empty_advance_char
+        self.progressbar_length = progressbar_length
+
+DEFAULT_STYLE = ProgressBarStyle()
+DEFAULT_RICH_STYLE = ProgressBarStyle(f'{Fore.GREEN}━{Fore.RESET}', f'{Fore.LIGHTBLACK_EX}━{Fore.RESET}', 41)
+CLASSIC_STYLE = ProgressBarStyle(f'{Fore.GREEN}█{Fore.RESET}', f'{Fore.LIGHTBLACK_EX}▓{Fore.RESET}')
+DRACULA_STYLE = ProgressBarStyle(f'{Fore.RED}█{Fore.RESET}', f'{Fore.LIGHTRED_EX}▓{Fore.RESET}')
+GIRL_STYLE    = ProgressBarStyle(f'{Fore.LIGHTMAGENTA_EX}█{Fore.RESET}', f'{Fore.MAGENTA}▓{Fore.RESET}')
+DARK_STYLE    = ProgressBarStyle(f'{Fore.LIGHTBLACK_EX}█{Fore.RESET}', ' ')
+RAINBOW_STYLE = ProgressBarStyle(f'{Fore.RED}█{Fore.CYAN}█{Fore.YELLOW}█{Fore.GREEN}█{Fore.BLUE}█{Fore.MAGENTA}█{Fore.RESET}', '', 10)
+
+class ProgressBar:
+    def __init__(self, total, description: str, progress_bar_style=DEFAULT_STYLE):
+        self.advance = 0
+        self.total = total
+        self.description = description
+        self.progressbar_length = progress_bar_style.progressbar_length
+        self.advance_char = progress_bar_style.advance_char
+        self.empty_advance_char = progress_bar_style.empty_advance_char
+        self.advance_char_coef = round(self.total/self.progressbar_length, 2)
+
+    @property
+    def is_finished(self):
+        return self.advance == self.total
+    
+    def force_finish(self):
+        self.advance = self.total
+
+    def render(self):
+        if self.is_finished:
+            advance_char_count = self.progressbar_length
+        else:
+            advance_char_count = int(self.advance/self.advance_char_coef)
+        advance_percent = round(decimal.Decimal(self.advance/self.total), 2)*100
+        if platform.release() == '7' and sys.platform.startswith('win'): # disable rendering for windows 7 (cmd.exe does not support ASCII control characters)
+            pass
+        else:
+            print(f'{self.description}{self.advance_char*advance_char_count}{self.empty_advance_char*(self.progressbar_length-advance_char_count)} {advance_percent}%')
+            print('\033[F', end='')
+            if self.is_finished:
+                print()
+            
+    def update(self, count):
+        self.advance += count

modules/SharedTools.py

@@ -0,0 +1,539 @@
+from selenium.webdriver import Chrome, ChromeOptions, ChromeService
+from selenium.webdriver import Firefox, FirefoxOptions, FirefoxService
+from selenium.webdriver import Edge, EdgeOptions, EdgeService
+from selenium.webdriver import Safari, SafariOptions, SafariService
+
+import subprocess
+import traceback
+import tempfile
+import colorama
+import logging
+import pathlib
+import random
+import string
+import shutil
+import time
+import sys
+import os
+import re
+
+I_AM_EXECUTABLE = (True if (getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS')) else False)
+PATH_TO_SELF = sys.executable if I_AM_EXECUTABLE else __file__
+SILENT_MODE = '--silent' in sys.argv
+
+DEFAULT_MAX_ITER = 30
+DEFAULT_DELAY = 1
+GET_EBCN = 'document.getElementsByClassName'
+GET_EBID = 'document.getElementById'
+GET_EBTN = 'document.getElementsByTagName'
+GET_EBAV = 'getElementByAttrValue'
+CLICK_WITH_BOOL = 'clickWithBool'
+DEFINE_GET_EBAV_FUNCTION = """
+function getElementByAttrValue(tagName, attrName, attrValue, index=1) {
+    let eindex = 0
+    let elements = []
+    for (let element of document.getElementsByTagName(tagName)) {
+        if(element.getAttribute(attrName) === attrValue) {
+            eindex += 1
+            if (index == -1)
+                elements.push(element)
+            else if (index == eindex)
+                return element } } 
+    if (index == -1)    
+        return elements }"""
+DEFINE_CLICK_WITH_BOOL_FUNCTION = """
+function clickWithBool(object) {
+    try {
+        object.click()
+        return true }
+    catch {
+        return false } }"""
+
+colorama.init()
+
+class LoggerType:
+    def __init__(self, sborder, eborder, title, color, fill_text):
+        self.sborder = sborder
+        self.eborder = eborder
+        self.title = title
+        self.color = color
+        self.fill_text = fill_text
+
+    @property
+    def data(self):
+        return self.sborder + self.color + self.title + colorama.Style.RESET_ALL + self.eborder
+
+ERROR = LoggerType('[ ', ' ]', 'FAILED', colorama.Fore.RED, True)
+OK = LoggerType('[   ', '   ]', 'OK', colorama.Fore.GREEN, False)
+INFO = LoggerType('[  ', '  ]', 'INFO', colorama.Fore.LIGHTBLACK_EX, True)
+DEVINFO = LoggerType('[ ', ' ]', 'DEBUG', colorama.Fore.CYAN, True)
+WARN = LoggerType('[  ', '  ]', 'WARN', colorama.Fore.YELLOW, False)
+
+class Installer:
+    def __init__(self):
+        self.install_path = None
+        self.executable_path = None
+        if sys.platform.startswith('win'):
+            self.install_path = os.environ['SystemRoot']
+            self.executable_path = self.install_path + '\\esetkeygen.exe'
+        elif sys.platform == "darwin":
+            self.install_path = '/usr/local/bin'
+            self.executable_path = self.install_path + '/esetkeygen'
+
+    def check_install(self):
+        exit_code = None
+        try:
+            exit_code = subprocess.call([self.executable_path, '--return-exit-code', '999'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        except:
+            pass
+        return (exit_code == 999)
+    
+    def install(self):
+        if self.check_install():
+            logging.info('The program is already installed!!!')
+            logging.warning(f'Location: {self.executable_path}')
+            console_log('The program is already installed!!!', OK, silent_mode=SILENT_MODE)
+            console_log(f'Location: {self.executable_path}', WARN, silent_mode=SILENT_MODE)
+            return True
+        if sys.platform.startswith('win') or sys.platform == 'darwin':
+            if I_AM_EXECUTABLE:
+                try:
+                    shutil.copy2(PATH_TO_SELF, self.executable_path)
+                    logging.info(f'The program was successfully installed on the path: {self.executable_path}')
+                    console_log(f'The program was successfully installed on the path: {self.executable_path}', OK, silent_mode=SILENT_MODE)
+                    return True
+                except PermissionError:
+                    logging.error('No write access, try running the program with elevated permissions!!!')
+                    console_log('No write access, try running the program with elevated permissions!!!', ERROR, silent_mode=SILENT_MODE)
+                except Exception as e:
+                    raise RuntimeError(e)
+                except shutil.SameFileError:
+                    logging.error('Installation is pointless from under an installed executable file!!!')
+                    console_log('Installation is pointless from under an installed executable file!!!', ERROR, silent_mode=SILENT_MODE)
+            else:
+                logging.error('Installation from source is not possible!!!!')
+                console_log('Installation from source is not possible!!!!', ERROR, silent_mode=SILENT_MODE)
+            return False
+
+class ChromeProxyExtensionManager:
+    MANIFEST = """
+        {
+        "version": "1.0.0",
+        "manifest_version": 3,
+        "name": "Chrome Proxy Manager",
+        "permissions": [
+            "proxy",
+            "tabs",
+            "unlimitedStorage",
+            "storage",
+            "webRequest",
+            "webRequestAuthProvider"
+        ],
+        "background": {
+            "service_worker": "background.js"
+        },
+        "host_permissions": [
+            "<all_urls>"
+        ],
+        "minimum_chrome_version":"22.0.0"
+        }
+    """
+    
+    BACKGROUND_JS = """
+        const config = {
+            mode: "fixed_servers",
+            rules: {
+                singleProxy: {
+                    scheme: "%s",
+                    host: "%s",
+                    port: %s
+                }
+            }
+        }
+        chrome.proxy.settings.set({
+            value: config,
+            scope: 'regular'
+        }, () => {});
+    """
+
+    BACKGROUND_AUTO_AUTH = """
+        chrome.webRequest.onAuthRequired.addListener(
+        (details, callback) => {
+            const authCredentials = {
+            username: "%s",
+            password: "%s",
+            };
+            setTimeout(() => {
+            callback({ authCredentials });
+            }, 200);
+        },
+        { urls: ["<all_urls>"] },
+        ["asyncBlocking"]
+        );
+    """
+
+    def create_extension(scheme: string, host: string, port: int, username="", password=""):
+        if scheme == "" or host == "" or port == 0:
+            return ''
+        
+        tempdir = pathlib.Path(tempfile.mkdtemp())
+
+        with open(tempdir.joinpath("manifest.json"), "x") as f:
+            f.write(ChromeProxyExtensionManager.MANIFEST)
+        with open(tempdir.joinpath("background.js"), "x") as f:
+            f.write(ChromeProxyExtensionManager.BACKGROUND_JS % (scheme, host, port))
+        
+        if username != "" or password != "":
+            with open(tempdir.joinpath("background.js"), "a") as f:
+                f.write(ChromeProxyExtensionManager.BACKGROUND_AUTO_AUTH % (username, password))
+
+        return tempdir
+
+    def parse_proxies_from_file(path: str):
+        proxies = []
+        with open(path) as f:
+            try:
+                lines = f.readlines()
+                for line in lines:
+                    line = line.strip()
+                    if line != "":
+                        proxy = line.split(':') # scheme:host:port:username:password
+                        if len(proxy) == 5:
+                            proxies.append(proxy)
+            except:
+                pass
+        return proxies
+
+def console_log(text='', logger_type=None, fill_text=None, silent_mode=False):
+    if silent_mode:
+        return
+    if isinstance(logger_type, LoggerType):
+        ni = 0
+        for i in range(0, len(text)):
+            if text[i] != '\n':
+                ni = i
+                break
+            print()
+        if fill_text is None:
+            fill_text = logger_type.fill_text
+        if fill_text:
+            print(logger_type.data + ' ' + logger_type.color + text[ni:] + colorama.Style.RESET_ALL)
+        else:
+            print(logger_type.data + ' ' + text[ni:])
+    else:
+        print(text)
+
+from .WebDriverInstaller import GOOGLE_CHROME, MICROSOFT_EDGE, MOZILLA_FIREFOX, APPLE_SAFARI
+
+def clear_console():
+    if os.name == 'nt':
+        os.system('cls')
+    else:
+        os.system('clear')
+
+def untilConditionExecute(driver_obj, js: str, delay=DEFAULT_DELAY, max_iter=DEFAULT_MAX_ITER, positive_result=True, raise_exception_if_failed=True, return_js_result=False):
+    driver_obj.execute_script(f'window.{GET_EBAV} = {DEFINE_GET_EBAV_FUNCTION}')
+    driver_obj.execute_script(f'window.{CLICK_WITH_BOOL} = {DEFINE_CLICK_WITH_BOOL_FUNCTION}')
+    pre_js = [
+        DEFINE_GET_EBAV_FUNCTION,
+        DEFINE_CLICK_WITH_BOOL_FUNCTION
+    ]
+    js = '\n'.join(pre_js+[js])
+    for _ in range(max_iter):
+        try:
+            result = driver_obj.execute_script(js)
+            if return_js_result and result is not None:
+                return result
+            elif result == positive_result:
+                return True
+        except Exception as E:
+            pass
+        time.sleep(delay)
+    if raise_exception_if_failed:
+        raise RuntimeError('untilConditionExecute: the code did not return the desired value! TRY VPN!')
+
+def dataGenerator(length, only_numbers=False):
+    """generates a password by default. If only_numbers=True - phone number"""
+    data = []
+    if only_numbers: # phone number
+        data = [random.choice(string.digits) for _ in range(length)]
+    else: # password
+        length += random.randint(1, 10)
+        data = [ # 1 uppercase & lowercase letter, 1 number, 1 special character
+            random.choice(string.ascii_uppercase),
+            random.choice(string.ascii_lowercase),
+            random.choice(string.digits),
+            random.choice("""!"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~""")
+        ]
+        characters = string.ascii_letters + string.digits + string.punctuation
+        data += [random.choice(characters) for _ in range(length-3)]
+        random.shuffle(data)
+    return ''.join(data)
+
+def initSeleniumWebDriver(browser_name: str, webdriver_path = None, browser_path = '', chrome_proxy_extension_path = '', headless=True):
+    if browser_path is None:
+        browser_path = ''
+    logging.info('-- Browsers Initializer --')
+    console_log(f'{colorama.Fore.LIGHTMAGENTA_EX}-- Browsers Initializer --{colorama.Fore.RESET}\n', silent_mode=SILENT_MODE)
+    if os.name == 'posix': # For Linux
+        if sys.platform.startswith('linux'):
+            logging.info(f'Initializing {browser_name} for Linux')
+            console_log(f'Initializing {browser_name} for Linux', INFO, silent_mode=SILENT_MODE)
+        elif sys.platform == "darwin":
+            logging.info(f'Initializing {browser_name} for macOS')
+            console_log(f'Initializing {browser_name} for macOS', INFO, silent_mode=SILENT_MODE)
+    elif os.name == 'nt':
+        logging.info(f'Initializing {browser_name} for Windows')
+        console_log(f'Initializing {browser_name} for Windows', INFO, silent_mode=SILENT_MODE)
+    driver_options = None
+    driver = None
+    if browser_name == GOOGLE_CHROME:
+        driver_options = ChromeOptions()
+        driver_options.page_load_strategy = "eager"
+        driver_options.binary_location = browser_path
+        driver_options.debugger_address = ''
+        driver_options.add_experimental_option('excludeSwitches', ['enable-logging'])
+        driver_options.add_argument("--log-level=3")
+        driver_options.add_argument("--lang=en-US")
+        driver_options.add_argument(f"--load-extension={chrome_proxy_extension_path}")
+        if headless:
+            driver_options.add_argument('--headless')
+        if os.name == 'posix': # For Linux
+            driver_options.add_argument('--no-sandbox')
+            driver_options.add_argument('--disable-dev-shm-usage')
+        try:
+            service = ChromeService(executable_path=webdriver_path)
+            if os.name == 'nt' and headless:
+                service.creation_flags = 0x08000000 # CREATE_NO_WINDOW (Process Creation Flags, WinBase.h) -> 'DevTools listening on' is not visible!!!
+            driver = Chrome(options=driver_options, service=service)
+        except Exception as e:
+            logging.critical("EXC_INFO:", exc_info=True)
+            if traceback.format_exc().find('only supports') != -1: # Fix for downloaded chrome update
+                browser_path = traceback.format_exc().split('path')[-1].split('Stacktrace')[0].strip()
+                if 'new_chrome.exe' in os.listdir(browser_path[:-10]):
+                    logging.info('Downloaded Google Chrome update is detected! Using new chrome executable file!')
+                    console_log('Downloaded Google Chrome update is detected! Using new chrome executable file!', INFO, silent_mode=SILENT_MODE)
+                    browser_path = browser_path[:-10]+'new_chrome.exe'
+                    driver_options.binary_location = browser_path
+                    driver = Chrome(options=driver_options, service=ChromeService(executable_path=webdriver_path))
+            else:
+                raise e
+    elif browser_name == MICROSOFT_EDGE:
+        driver_options = EdgeOptions()
+        driver_options.page_load_strategy = "eager"
+        driver_options.use_chromium = True
+        driver_options.binary_location = browser_path
+        driver_options.add_experimental_option('excludeSwitches', ['enable-logging'])
+        driver_options.add_argument("--log-level=3")
+        driver_options.add_argument("--lang=en-US")
+        if headless:
+            driver_options.add_argument('--headless')
+        if os.name == 'posix': # For Linux
+            driver_options.add_argument('--no-sandbox')
+            driver_options.add_argument('--disable-dev-shm-usage')
+        service = EdgeService(executable_path=webdriver_path)
+        if os.name == 'nt' and headless:
+            service.creation_flags = 0x08000000 # CREATE_NO_WINDOW (Process Creation Flags, WinBase.h) -> 'DevTools listening on' is not visible!!!
+        try:
+            driver = Edge(options=driver_options, service=service)
+        except Exception as e:
+            logging.critical("EXC_INFO:", exc_info=True)
+            if traceback.format_exc().find('--user-data-dir') != -1: # Fix for probably user data directory is already in use
+                driver_options.add_argument("--user-data-dir=./edge_tmp")
+                try:
+                    shutil.rmtree("edge_tmp")
+                except:
+                    pass
+                os.makedirs('edge_tmp', exist_ok=True)
+                driver = Edge(options=driver_options, service=EdgeService(executable_path=webdriver_path))
+            else:
+                raise e
+    elif browser_name == MOZILLA_FIREFOX:
+        driver_options = FirefoxOptions()
+        driver_options.page_load_strategy = "eager"
+        if browser_path.strip() != '':
+            driver_options.binary_location = browser_path
+        driver_options.set_preference('intl.accept_languages', 'en-US')
+        if headless:
+            driver_options.add_argument('--headless')
+        if os.name == 'posix': # For Linux
+            driver_options.add_argument('--no-sandbox')
+            driver_options.add_argument("--disable-dev-shm-usage")
+        service = FirefoxService(executable_path=webdriver_path)
+        if os.name == 'nt' and headless:
+            service.creation_flags = 0x08000000 # CREATE_NO_WINDOW (Process Creation Flags, WinBase.h) -> 'DevTools listening on' is not visible!!!
+        # Fix for: Your firefox profile cannot be loaded. it may be missing or inaccessible
+        os.makedirs('firefox_tmp', exist_ok=True)
+        os.environ['TMPDIR'] = (os.getcwd()+'/firefox_tmp').replace('\\', '/')
+        driver = Firefox(options=driver_options, service=service)
+    elif browser_name == APPLE_SAFARI:
+        driver_options = SafariOptions()
+        try:
+            if os.name == 'nt':
+                console_log('Apple Safari is not supported on Windows!!!', ERROR)
+                return None
+            elif os.name == 'posix' and sys.platform.startswith('linux'):
+                console_log('Apple Safari is not supported on Linux!!!', ERROR)
+                return None
+            driver = Safari(options=driver_options, service=SafariService(executable_path=webdriver_path))
+        except Exception as e:
+            logging.critical("EXC_INFO:", exc_info=True)
+            if traceback.format_exc().find("Allow Remote Automation") != -1:
+                console_log(traceback.format_exc().split('Message: ')[-1].strip(), ERROR)
+            else:
+                raise e
+    return driver
+
+def parseToken(email_obj, driver=None, eset_business=False, delay=DEFAULT_DELAY, max_iter=DEFAULT_MAX_ITER):
+    activated_href = None
+    if email_obj.class_name == 'custom':
+        while True:
+            activated_href = input(f'\n[  {colorama.Fore.YELLOW}INPT{colorama.Fore.RESET}  ] {colorama.Fore.CYAN}Enter the link to activate your account, it will come to the email address you provide: {colorama.Fore.RESET}').strip()
+            logging.info(f'[  INPT  ] Enter the link to activate your account, it will come to the email address you provide: {activated_href}')
+            if activated_href != '':
+                if eset_business:
+                    match = re.search(r'activation\/[a-zA-Z0-9-]+', activated_href)
+                else:
+                    match = re.search(r'token=[a-zA-Z\d:/-]*', activated_href)
+                if match is not None:
+                    if eset_business:
+                        token = match.group()[11:]
+                    else:
+                        token = match.group()[6:]
+                    if len(token) == 36:
+                        return token
+            logging.error('Incorrect link syntax')
+            console_log('Incorrect link syntax', ERROR)
+    for _ in range(max_iter):
+        if email_obj.class_name == '1secmail':
+            json = email_obj.read_email()
+            if json != []:
+                for message in json:
+                    if eset_business and message['subject'].find('ESET PROTECT Hub') != -1:
+                        activated_href = email_obj.get_message(message['id'])['body']
+                    elif message['from'].find('product.eset.com') != -1:
+                        activated_href = email_obj.get_message(message['id'])['body']
+        elif email_obj.class_name in ['developermail', 'inboxes']:
+            messages = email_obj.get_messages()
+            if messages is not None:
+                for message in messages:
+                    if eset_business and message['subject'].find('ESET PROTECT Hub') != -1:
+                        activated_href = message['body']
+                    elif message['from'].find('product.eset.com') != -1:
+                        activated_href = message['body']
+        elif email_obj.class_name in ['guerrillamail', 'mailticking', 'fakemail', 'incognitomail']:
+            inbox = email_obj.parse_inbox()
+            for mail in inbox:
+                mail_id, mail_from, mail_subject = mail
+                if mail_from.find('product.eset.com') != -1 or mail_from.find('ESET HOME') != -1 or mail_subject.find('ESET PROTECT Hub') != -1:
+                    email_obj.open_mail(mail_id)
+                    if email_obj.class_name in ['mailticking', 'incognitomail']:
+                        time.sleep(2)
+                    try:
+                        if email_obj.class_name == 'mailticking':
+                            driver.switch_to.frame(driver.find_element('id', 'email-iframe'))
+                        if eset_business:
+                            activated_href = driver.find_element('xpath', "//a[starts-with(@href, 'https://protecthub.eset.com')]").get_attribute('href') 
+                        else:
+                            activated_href = driver.find_element('xpath', "//a[starts-with(@href, 'https://login.eset.com')]").get_attribute('href')
+                        driver.switch_to.default_content()
+                    except:
+                        pass
+        if activated_href is not None:
+            if eset_business:
+                match = re.search(r'activation\/[a-zA-Z0-9-]+', activated_href)
+            else:
+                match = re.search(r'token=[a-zA-Z\d:/-]*', activated_href)
+            if match is not None:
+                if eset_business:
+                    token = match.group()[11:]
+                else:
+                    token = match.group()[6:]
+                if len(token) == 36:
+                    return token
+        time.sleep(delay)
+    raise RuntimeError('Token retrieval error, try again later or change the Email API!!!')
+
+def parseEPHKey(email_obj, driver=None, delay=DEFAULT_DELAY, max_iter=DEFAULT_MAX_ITER):
+    for _ in range(max_iter):
+        license_data = None
+        if email_obj.class_name in ['developermail', 'inboxes']:
+            messages = email_obj.get_messages()
+            if messages is not None:
+                for message in messages:
+                    if message['subject'].find('Thank you for purchasing') != -1:
+                        license_data = message['body']
+                        break
+        elif email_obj.class_name in ['mailticking', 'fakemail', 'incognitomail']:
+            inbox = email_obj.parse_inbox()
+            for mail in inbox:
+                mail_id, mail_from, mail_subject = mail
+                if mail_subject.find('Thank you for purchasing') != -1:
+                    try:
+                        email_obj.open_mail(mail_id)
+                        time.sleep(3)
+                        if email_obj.class_name == 'mailticking':
+                            license_data = driver.find_element('id', 'email-iframe').srcdoc
+                        else:
+                            license_data = email_obj.driver.page_source
+                        break
+                    except:
+                        pass
+        if license_data is not None:
+            license_data = str(license_data)
+            license_key = re.search(r'([A-Z0-9]){4}-([A-Z0-9]){4}-([A-Z0-9]){4}-([A-Z0-9]){4}-([A-Z0-9]){4}', license_data).group()
+            license_id = re.search(r'[A-Z0-9]{3}-[A-Z0-9]{3}-[A-Z0-9]{3}', license_data).group()
+            license_out_date = re.findall(r'\d\d.\d\d.\d\d\d\d', license_data)[-1]
+            return license_key, license_out_date, license_id
+        time.sleep(delay)
+    raise RuntimeError('ESET ProtectHub data waiting time has been exceeded!!!')
+
+def parseVPNCodes(email_obj, driver=None, delay=DEFAULT_DELAY, max_iter=DEFAULT_MAX_ITER):
+    for _ in range(max_iter):
+        data = None
+        try:
+            if email_obj.class_name == '1secmail':
+                json = email_obj.read_email()
+                if json != []:
+                    for message in json:
+                        if message['subject'].find('VPN - Setup instructions') != -1:
+                            data = email_obj.get_message(message['id'])['body']
+            elif email_obj.class_name in ['developermail', 'inboxes']:
+                messages = email_obj.get_messages()
+                if messages is not None:
+                    for message in messages:
+                        if message['subject'].find('VPN - Setup instructions') != -1:
+                            data = message['body']
+            elif email_obj.class_name in ['guerrillamail', 'mailticking', 'fakemail', 'incognitomail']:
+                inbox = email_obj.parse_inbox()
+                for mail in inbox:
+                    mail_id, mail_from, mail_subject = mail
+                    if mail_subject.find('VPN - Setup instructions') != -1:
+                        email_obj.open_mail(mail_id)
+                        if email_obj.class_name == 'mailticking':
+                            time.sleep(1.5)
+                            try:
+                                data = str(driver.find_element('id', 'email-iframe').get_attribute('srcdoc'))
+                            except:
+                                pass
+                        elif email_obj.class_name == 'guerrillamail':
+                            try:
+                                data = str(driver.execute_script(f'return {GET_EBCN}("email_body")[0].innerHTML'))
+                            except:
+                                pass
+                        elif email_obj.class_name == 'incognitomail':
+                            time.sleep(1.5)
+                            try:
+                                data = str(driver.execute_script(f'return {GET_EBCN}("MuiBox-root joy-1v8x7dw")[0].innerHTML'))
+                            except:
+                                pass
+                        else:
+                            data = driver.page_source
+        except:
+            pass
+        if data is not None:
+            match = re.findall(r'[A-Z0-9]{10}', data)
+            if match is not None and len(match) == 10:
+                return match
+        time.sleep(delay)
+    raise RuntimeError('VPN Codes retrieval error, try again later or change the Email API!!!')

modules/Updater.py

@@ -0,0 +1,235 @@
+from .SharedTools import console_log, INFO, OK, ERROR, WARN
+from .ProgressBar import ProgressBar, DEFAULT_RICH_STYLE
+
+import subprocess
+import requests
+import zipfile
+import logging
+import pathlib
+import sys
+import os
+
+SILENT_MODE = '--silent' in sys.argv
+
+WINDOWS_EXTERNAL_UPDATER = """
+@echo off
+
+timeout 1 >nul 2>&1
+
+echo.
+echo --- ESET-KeyGen External-Updater ---
+echo.
+
+echo !!! Make sure you are running the program with elevated permissions, else update will fail !!!
+echo.
+echo !!! Do not interrupt the update, if you interrupt the update, the executable file will be corrupted !!!
+echo.
+
+where curl >nul 2>&1
+if %ERRORLEVEL%==0 (
+    curl -#L %1 -o %2
+) else (
+    powershell Invoke-WebRequest -Uri %1 -OutFile %2
+)
+
+echo.
+echo Press Enter to exit the updater ... 
+pause >nul
+"""
+
+WINDOWS_EXTERNAL_UPDATER_SILENT = """
+@echo off
+
+timeout 1 >nul 2>&1
+
+where curl >nul 2>&1
+if %ERRORLEVEL%==0 (
+    curl -#L %1 -o %2 -s
+) else (
+    powershell Invoke-WebRequest -Uri %1 -OutFile %2
+)
+"""
+
+MACOS_EXTERNAL_UPDATER = """
+#!/bin/bash
+
+sleep 1
+
+echo -e '\n--- ESET-KeyGen External-Updater ---\n'
+echo -e '!!! Make sure you are running the program with elevated permissions, else update will fail !!!\n'
+echo -e '!!! Do not interrupt the update, if you interrupt the update, the executable file will be corrupted !!!\n'
+
+curl -#L $1 -o $2
+chmod 755 $2
+echo -e "\nPress Enter to exit the updater ..."
+
+exit
+"""
+
+MACOS_EXTERNAL_UPDATER_SILENT = """
+#!/bin/bash
+
+sleep 1
+
+curl -#L $1 -o $2 -s
+chmod 755 $2
+exit
+"""
+
+class Updater:
+    def __init__(self, disable_logging=False):
+        self.disable_logging = disable_logging
+        if SILENT_MODE:
+            self.disable_logging = True
+        self.arch = None
+        if sys.platform.startswith('win'):
+            self.arch = 'win32'
+            if sys.maxsize > 2**32: # 64bit 
+                self.arch = 'win64'
+        elif sys.platform == 'darwin':
+            self.arch = 'macos' # prefix for universal macOS builds (arm64 + x86_64)
+            #arch = 'macos_arm64'
+            #if platform.machine() == "x86_64":
+            #    arch = 'macos_amd64'
+        self.releases = None
+    
+    def get_releases(self, version='latest'):
+        url = 'https://api.github.com/repos/shadowcopyrz/ESET-KGEN-COPY/releases'
+        if version == 'latest':
+            url = 'https://api.github.com/repos/shadowcopyrz/ESET-KGEN-COPY/releases/latest'
+        try:
+            response = requests.get(url, timeout=5)
+            update_json = response.json()
+            try:
+                if update_json.get('message') is not None:
+                    logging.error('Your IP address has been blocked. try again later or use a VPN!')
+                    console_log('Your IP address has been blocked. try again later or use a VPN!', ERROR, silent_mode=self.disable_logging)
+                    return None
+            except AttributeError:
+                pass
+            if version == 'latest': # when requesting the latest version, the site returns json without a list. 
+                update_json = [update_json]
+            f_update_json = {}
+            for release in update_json:
+                f_update_json[release['name']] = {
+                    'version': release['name'],
+                    'src': release['zipball_url'],
+                    'assets': {}
+                }
+                for asset in release['assets']:
+                    if asset['name'] == 'src.zip':
+                        f_update_json[release['name']]['src'] = asset['browser_download_url']
+                    else:
+                        f_update_json[release['name']]['assets'][asset['name']] = asset['browser_download_url']
+            self.releases = f_update_json
+            return f_update_json
+        except:
+            return None
+
+    def find_suitable_data(self, datatype='source_code', version='latest'): # datatype: source_code OR executable_file
+        if self.releases is None:
+            self.releases = self.get_releases(version)
+        if version == 'latest':
+            if datatype == 'source_code':
+                return self.releases[list(self.releases.keys())[0]]['src']
+            elif datatype == 'executable_file':
+                assets = self.releases[list(self.releases.keys())[0]]['assets']
+        else:
+            for release_name in self.releases:
+                if release_name == version:
+                    if datatype == 'source_code':
+                        return self.releases[release_name]['src']
+                    elif datatype == 'executable_file':
+                        assets = self.releases[release_name]['assets']
+                        break
+        if datatype == 'executable_file':
+            for asset_name, asset_url in assets.items():
+                if asset_name.find(self.arch) != -1:
+                    return asset_url
+        
+    def download_file(self, url):
+        try:
+            response = requests.get(url, stream=True)
+            try:
+                filename = response.headers.get('content-disposition').split('filename=')[1]
+                logging.info(f'Downloading {filename}...')
+                console_log(f'Downloading {filename}...', INFO, silent_mode=self.disable_logging)
+            except:
+                pass
+            total_length = response.headers.get('content-length')
+            if total_length is None or self.disable_logging: # No content length header
+                with open(filename, 'wb') as f:
+                    f.write(response.content)
+            else:
+                task = ProgressBar(int(total_length), '           ', DEFAULT_RICH_STYLE)
+                with open(filename, 'wb') as f:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        if chunk: # filter out keep-alive new chunks
+                            f.write(chunk)
+                            task.update(len(chunk))
+                            task.render()
+            return str(pathlib.Path(filename).resolve())
+        except Exception as e:
+            logging.critical("EXC_INFO:", exc_info=True)
+            console_log(f"Error downloading file: {e}", ERROR, silent_mode=self.disable_logging)
+            return False
+    
+    def extract_data(self, data_path: str, new_name=None):
+        extracted_data_path = None
+        if data_path.endswith('.zip'): # source code
+            try:
+                with zipfile.ZipFile(data_path, 'r') as zipf:
+                    extracted_folder_name = zipf.filelist[0].filename[0:-1] # rzc0d3r-ESET-KeyGen-56a2c5b/ -> rzc0d3r-ESET-KeyGen-56a2c5b
+                    zipf.extractall()
+                    logging.info("Extraction completed successfully!")
+                    console_log("Extraction completed successfully!", OK, silent_mode=self.disable_logging)
+                    extracted_data_path = str(pathlib.Path(extracted_folder_name).resolve())
+                if new_name is not None:
+                    os.rename(extracted_folder_name, new_name)
+                    extracted_data_path = str(pathlib.Path(new_name).resolve())
+                else:
+                    os.rename(extracted_folder_name, 'ESET-KeyGen-'+list(self.releases.keys())[0])
+                    extracted_data_path = str(pathlib.Path('ESET-KeyGen-'+list(self.releases.keys())[0]))
+            except Exception as e:
+                logging.critical("EXC_INFO:", exc_info=True)
+                console_log(str(e), ERROR, silent_mode=self.disable_logging)
+        if not data_path.endswith('.zip'): # executable file
+            extracted_data_path = str(pathlib.Path(data_path).resolve())
+            if new_name is not None:
+                os.rename(data_path, new_name)
+                extracted_data_path = str(pathlib.Path(new_name).resolve())
+        logging.warning(f"Location of update: {extracted_data_path}")
+        console_log(f"Location of update: {extracted_data_path}", WARN, silent_mode=self.disable_logging)
+        return extracted_data_path
+
+    def updater_menu(self, i_am_executable, path_to_main_file):
+        executable_file_url = self.find_suitable_data(datatype='executable_file')
+        if i_am_executable: # run from the build [supported platform]
+            logging.info('Transferring control to an external script...')
+            if sys.platform.startswith('win'):
+                updater_path = os.environ['TEMP']+'\\updater.bat'
+                with open(updater_path, 'w') as f:
+                    if SILENT_MODE:
+                        f.write(WINDOWS_EXTERNAL_UPDATER_SILENT)
+                    else:
+                        f.write(WINDOWS_EXTERNAL_UPDATER)
+                subprocess.Popen([updater_path, executable_file_url, path_to_main_file], shell=True)
+            elif sys.platform == 'darwin':
+                updater_path = r'/tmp/updater.sh'
+                with open(updater_path, 'w') as f:
+                    if SILENT_MODE:
+                        f.write(MACOS_EXTERNAL_UPDATER_SILENT)
+                    else:
+                        f.write(MACOS_EXTERNAL_UPDATER)
+                os.chmod(updater_path, 0o755)
+                subprocess.Popen(['bash', updater_path, executable_file_url, path_to_main_file])
+            sys.exit(0)
+        elif executable_file_url is not None: # run from source [supported platform]
+            executable_file_url = self.find_suitable_data(datatype='executable_file')
+            self.extract_data(self.download_file(executable_file_url))
+        else: # run from source [unsupported platform]
+            logging.error('No suitable executable file was found for your platform!!!')
+            logging.info('Downloading the latest release source code...')
+            console_log('No suitable executable file was found for your platform!!!', ERROR, silent_mode=SILENT_MODE)
+            console_log('Downloading the latest release source code...', INFO, silent_mode=SILENT_MODE)
+            self.extract_data(self.download_file(self.find_suitable_data()))

modules/WebDriverInstaller.py

@@ -0,0 +1,410 @@
+GOOGLE_CHROME = 'Google Chrome'
+MICROSOFT_EDGE = 'Microsoft Edge'
+MOZILLA_FIREFOX = 'Mozilla Firefox'
+APPLE_SAFARI = 'Apple Safari'
+
+GOOGLE_CHROME_RE = r'(\d+\.\d+\.\d+\.\d+)'
+MICROSOFT_EDGE_RE = r'(\d+\.\d+\.\d+\.\d+)'
+MOZILLA_FIREFOX_RE = r'(\d+\.\d+\.\d+)|(\d+\.\d+)'
+APPLE_SAFARI_RE = r'\d+.\d+.\d+'
+
+from .SharedTools import console_log, INFO, OK, ERROR, WARN
+from .ProgressBar import ProgressBar, DEFAULT_RICH_STYLE
+
+from pathlib import Path
+
+from colorama import Fore, init
+init()
+
+import subprocess
+import platform
+import requests
+import logging
+import zipfile
+import tarfile
+import shutil
+import sys
+import re
+import os
+
+SILENT_MODE = '--silent' in sys.argv
+
+class WebDriverInstaller(object):
+    def __init__(self, browser_name: str, custom_browser_location=None):
+        self.browsers_data = {
+            GOOGLE_CHROME: [self.get_chromedriver_url, 'chromedriver.exe' if sys.platform.startswith('win') else 'chromedriver', self.get_chrome_version, GOOGLE_CHROME_RE],
+            MICROSOFT_EDGE: [self.get_msedgedriver_url, 'msedgedriver.exe' if sys.platform.startswith('win') else 'msedgedriver', self.get_edge_version, MICROSOFT_EDGE_RE],
+            MOZILLA_FIREFOX: [self.get_geckodriver_url, 'geckodriver.exe' if  sys.platform.startswith('win') else 'geckodriver', self.get_firefox_version, MOZILLA_FIREFOX_RE],
+            APPLE_SAFARI: []
+        }
+        self.browser_name = browser_name
+        self.custom_browser_location = custom_browser_location
+        if self.browser_name not in self.browsers_data:
+            raise RuntimeError('WebDriverInstaller: invalid browser_name!')
+        self.browser_data = self.browsers_data[self.browser_name]
+        self.platform = ['', []] # [OC name, [webdriver architectures]]
+        if sys.platform.startswith('win'):
+            self.platform[0] = 'win'
+            if sys.maxsize > 2**32:
+                self.platform[1] = ['win64', 'win32']
+            else:
+                self.platform[1] = ['win32']
+        elif sys.platform.startswith('linux'):
+            self.platform[0] = 'linux'
+            if sys.maxsize > 2**32:
+                self.platform[1].append('linux64')
+            else:
+                self.platform[1].append('linux32')
+        elif sys.platform == "darwin":
+            self.platform[0] = 'mac'
+            if self.browser_name == MOZILLA_FIREFOX:
+                self.platform[1] = ['macos']
+            elif platform.processor() == "arm":
+                self.platform[1] = ['mac-arm64', 'mac_arm64', 'mac64_m1']
+                if self.browser_name == MOZILLA_FIREFOX:
+                    self.platform[1] = ['macos-aarch64']
+            elif platform.processor() == "i386":
+                self.platform[1] = ['mac64', 'mac-x64']
+    
+    def get_browser_version_from_cmd(self, path: str, re_pattern: str):
+        try:
+            with subprocess.Popen([path, "--version"], stdout=subprocess.PIPE) as proc:
+                return re.search(re_pattern, proc.communicate()[0].decode("utf-8")).group()
+        except:
+            pass
+
+    def get_chrome_version(self):
+        browser_version = None
+        browser_path = None
+        if self.platform[0] == "linux":
+            if self.custom_browser_location is not None:
+                browser_version = self.get_browser_version_from_cmd(self.custom_browser_location, GOOGLE_CHROME_RE)
+                browser_path = self.custom_browser_location
+            else:
+                for executable in ["google-chrome", "google-chrome-stable", "google-chrome-beta", "google-chrome-dev", "chromium-browser", "chromium"]:
+                    browser_version = self.get_browser_version_from_cmd(shutil.which(executable), GOOGLE_CHROME_RE)
+                    if browser_version is not None:
+                        browser_path = shutil.which(executable)
+                        break
+        elif self.platform[0] == "mac":
+            if self.custom_browser_location is not None:
+                browser_version = self.get_browser_version_from_cmd(self.custom_browser_location, GOOGLE_CHROME_RE)
+                browser_path = self.custom_browser_location
+            else:
+                browser_version = self.get_browser_version_from_cmd('/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', GOOGLE_CHROME_RE)
+                browser_path = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
+        elif self.platform[0] == "win":
+            paths = [
+                f'{os.environ.get("SYSTEMDRIVE")}\\Program Files\\Google\\Chrome\\Application',
+                f'{os.environ.get("SYSTEMDRIVE")}\\Program Files (x86)\\Google\\Chrome\\Application',
+                f'{os.environ.get("LOCALAPPDATA")}\\Google\\Chrome\\Application'
+            ]
+            if self.custom_browser_location is not None:
+                paths = [str(Path(self.custom_browser_location).parent)]
+            for path in paths:
+                try:
+                    with open(path+'\\chrome.VisualElementsManifest.xml', 'r') as f:
+                        browser_version = re.search(GOOGLE_CHROME_RE, f.read()).group()
+                        browser_path = path+'\\chrome.exe'
+                        break
+                except:
+                    pass
+        return [browser_version, browser_path]
+
+    def get_chromedriver_url(self, chrome_major_version=None):
+        if chrome_major_version is None:
+            chrome_major_version = self.get_chrome_version()[0]
+            if chrome_major_version is None:
+                return None
+            chrome_major_version = self.get_chrome_version()[0].split('.')[0]
+        if int(chrome_major_version) >= 115: # for new drivers ( [115.0.0000.0, ...] )
+            drivers_data = requests.get('https://googlechromelabs.github.io/chrome-for-testing/known-good-versions-with-downloads.json')
+            drivers_data = drivers_data.json()['versions'][::-1] # start with the latest version
+            for driver_data in drivers_data:
+                driver_major_version = driver_data['version'].split('.')[0] # major, _, minor, micro
+                if driver_major_version == chrome_major_version: # return latest driver version for current major chrome version
+                    for driver_url in driver_data['downloads'].get('chromedriver', []):
+                        if driver_url['platform'] in self.platform[1]:
+                            return driver_url['url']
+        else: # for old drivers ( [..., 115.0.0000.0) )
+            latest_old_driver_version = requests.get(f'https://chromedriver.storage.googleapis.com/LATEST_RELEASE_{chrome_major_version}')
+            if latest_old_driver_version.status_code == 200:
+                latest_old_driver_version = latest_old_driver_version.text
+                driver_url = f'https://chromedriver.storage.googleapis.com/{latest_old_driver_version}/chromedriver_'
+                for arch in self.platform[1]:
+                    current_driver_url = driver_url+arch+'.zip'
+                    driver_size = requests.head(current_driver_url).headers.get('x-goog-stored-content-length', None)
+                    if driver_size is not None and int(driver_size) > 1024**2:
+                        return current_driver_url
+   
+    def get_edge_version(self):
+        browser_version = None
+        browser_path = None
+        if self.platform[0] == 'linux':
+            if self.custom_browser_location is not None:
+                browser_version = self.get_browser_version_from_cmd(self.custom_browser_location, MICROSOFT_EDGE_RE)
+                browser_path = self.custom_browser_location
+            else:
+                for executable in ['microsoft-edge']:
+                    browser_version = self.get_browser_version_from_cmd(shutil.which(executable), MICROSOFT_EDGE_RE)
+                    if browser_version is not None:
+                        browser_path = shutil.which(executable)
+                        break
+        elif self.platform[0] == "mac":
+            if self.custom_browser_location is not None:
+                browser_version = self.get_browser_version_from_cmd(self.custom_browser_location, MICROSOFT_EDGE_RE)
+                browser_path = self.custom_browser_location
+            else:
+                browser_version = self.get_browser_version_from_cmd('/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge', MICROSOFT_EDGE_RE)
+                browser_path = '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge'
+        elif self.platform[0] == 'win':
+            paths = [
+                f'{os.environ.get("SYSTEMDRIVE")}\\Program Files\\Microsoft\\Edge\\Application',
+                f'{os.environ.get("SYSTEMDRIVE")}\\Program Files (x86)\\Microsoft\\Edge\\Application'
+            ]
+            if self.custom_browser_location is not None:
+                paths = [str(Path(self.custom_browser_location).parent)]
+            for path in paths:
+                try:
+                    with open(path+'\\msedge.VisualElementsManifest.xml', 'r') as f:
+                        browser_version = re.search(MICROSOFT_EDGE_RE, f.read()).group()
+                        browser_path = path+'\\msedge.exe'
+                        break
+                except:
+                    pass
+        return [browser_version, browser_path]
+
+    def get_msedgedriver_url(self, edge_version=None):
+        archs = self.platform[1]
+        if edge_version is None:
+            edge_version, _ = self.get_edge_version()
+        major_version = edge_version.split('.')[0]
+        if self.platform[0] == 'win':
+            r = requests.get(f'https://msedgedriver.azureedge.net/LATEST_RELEASE_{major_version}_WINDOWS')
+        elif self.platform[0] == 'linux':
+            r = requests.get(f'https://msedgedriver.azureedge.net/LATEST_RELEASE_{major_version}_LINUX')
+        elif self.platform[0] == 'mac':
+            r = requests.get(f'https://msedgedriver.azureedge.net/LATEST_RELEASE_{major_version}_MACOS')
+        if r.status_code == 200:
+            webdriver_version = r.text.strip()
+            for arch in archs:
+                driver_url = f'https://msedgedriver.azureedge.net/{webdriver_version}/edgedriver_{arch}.zip'
+                driver_size = requests.head(driver_url).headers.get('Content-Length', None)
+                if driver_size is not None and int(driver_size) > 1024**2:
+                    return driver_url
+    
+    def get_firefox_version(self):
+        browser_version = None
+        browser_path = None
+        if self.platform[0] == 'linux':
+            if self.custom_browser_location is not None:
+                browser_version = self.get_browser_version_from_cmd(self.custom_browser_location, MOZILLA_FIREFOX_RE)
+                browser_path = self.custom_browser_location
+            else:
+                for executable in ['firefox']:
+                    browser_version = self.get_browser_version_from_cmd(shutil.which(executable), MOZILLA_FIREFOX_RE)
+                    if browser_version is not None:
+                        browser_path = shutil.which(executable)
+                        break
+        elif self.platform[0] == "mac":
+            if self.custom_browser_location is not None:
+                browser_version = self.get_browser_version_from_cmd(self.custom_browser_location, MOZILLA_FIREFOX_RE)
+                browser_path = self.custom_browser_location
+            else:
+                for path in ['/Applications/Firefox.app/Contents/MacOS/firefox', '/application/firefox.app']:
+                    if browser_version is not None:
+                        browser_version = self.get_browser_version_from_cmd(path, MOZILLA_FIREFOX_RE)
+                        browser_path = path
+                        break
+        elif self.platform[0] == 'win':
+            paths = [
+                f'{os.environ.get("SYSTEMDRIVE")}\\Program Files\\Mozilla Firefox',
+                f'{os.environ.get("SYSTEMDRIVE")}\\Program Files (x86)\\Mozilla Firefox',
+            ]
+            if self.custom_browser_location is not None:
+                paths = [str(Path(self.custom_browser_location).parent)]
+            for path in paths:
+                try:
+                    with open(path+'\\application.ini', 'r') as f:
+                        browser_version = re.search(MOZILLA_FIREFOX_RE, f.read()).group()
+                        browser_path = path+'\\firefox.exe'
+                        break
+                except:
+                    pass
+        return [browser_version, browser_path]
+
+    def get_geckodriver_url(self, only_version=False):
+        r = requests.get("https://api.github.com/repos/mozilla/geckodriver/releases/latest")
+        r_json = r.json()
+        api_rate_limit = (True if r_json.get('name', None) is None else False)
+        if api_rate_limit: # bypass for API rate limit exceeded for your IP
+            r = requests.head("https://github.com/mozilla/geckodriver/releases/latest", allow_redirects=True)
+            geckodriver_version = r.url.split('/')[-1][1:]
+        else:
+            geckodriver_version = r_json['name']
+        if only_version:
+            return geckodriver_version
+        if not api_rate_limit:
+            #https://github.com/mozilla/geckodriver/releases/download/v0.34.0/geckodriver-v0.34.0-macos.tar.gz
+            # note for: r_json['assets'][::-1]
+            # in the initialization of WebDriverInstaller for 64bit is also suitable for 32bit, but
+            # in the list of assets first go 32bit and it comes out that for 64bit gives a 32bit release, turning the list fixes it
+            for asset in r_json['assets'][::-1]:
+                if asset['name'].find('asc') == -1: # ignoring GPG Keys
+                    asset_arch = asset['name'].split('-', 2)[-1].split('.')[0] # package architecture parsing; geckodriver-v0.34.0-win32.zip -> ['geckodriver', 'v0.34.0', 'win32.zip'] -> ['win32', 'zip'] -> win32
+                    if asset_arch in self.platform[1]:
+                        return asset['browser_download_url']
+        else:
+            # bypass for API rate limit exceeded for your IP
+            extension = '.zip' if self.platform[0] == 'win' else '.tar.gz'
+            for arch in self.platform[1]:
+                url = f'https://github.com/mozilla/geckodriver/releases/download/v{geckodriver_version}/geckodriver-v{geckodriver_version}-{arch}{extension}'
+                r = requests.get(url, stream=True)
+                if int(r.headers.get('Content-Length', 0)) > 1024**2:
+                    return url
+    
+    def get_safari_version(self):
+        if self.platform[0] == "mac":
+            cmd = ['/usr/libexec/PlistBuddy', '-c', "print :CFBundleShortVersionString", '/Applications/Safari.app/Contents/Info.plist']
+            try:
+                with subprocess.Popen(cmd, stdout=subprocess.PIPE) as proc:
+                    return re.search(APPLE_SAFARI_RE, proc.communicate()[0].decode("utf-8")).group()
+            except:
+                pass
+
+    def detect_installed_browser(self):
+        for browser_name in self.browsers_data:
+            if browser_name == APPLE_SAFARI:
+                browser_version = self.get_safari_version()
+                if browser_version is not None:
+                    return [APPLE_SAFARI, browser_version]
+            else:
+                browser_version, browser_path = self.browsers_data[browser_name][2]()
+                if browser_version is not None:
+                    return [browser_name, browser_version, browser_path]
+    
+    def download_webdriver(self, url=None, path='.', disable_progress_bar=False):
+        # init
+        webdriver_name = self.browser_data[1]
+        file_extension = '.zip'
+        if url is None:
+            url = self.browser_data[0]()
+            if url is None:
+                return None
+        if url.split('.')[-1] == 'gz':
+            file_extension = '.tar.gz'
+        # downloading
+        archive_path = str(Path(f'{path}/data{file_extension}').resolve())
+        response = requests.get(url, stream=True)
+        if not disable_progress_bar:
+            total_length = int(response.headers.get('Content-Length', 0))
+            total_length = int(response.headers.get('content-length', total_length))
+        else:
+            total_length = 0
+        if total_length == 0 or SILENT_MODE: # No content length header
+            with open(archive_path, 'wb') as f:
+                f.write(response.content)
+        else:
+            task = ProgressBar(int(total_length), '           ', DEFAULT_RICH_STYLE)
+            with open(archive_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk: # filter out keep-alive new chunks    
+                        f.write(chunk)
+                        task.update(len(chunk))
+                        task.render()
+        # extracting
+        archive, info = None, []
+        if file_extension == '.zip':
+            archive = zipfile.ZipFile(archive_path)
+            archive_info = archive.infolist()
+        elif file_extension == '.tar.gz':
+            archive = tarfile.open(archive_path)
+            archive_info = archive.getnames()
+        if archive is not None:
+            for info in archive_info:
+                archive_filename, archive_filepath = None, None
+                if file_extension == '.zip':
+                    archive_filename, archive_filepath = info.filename.split('/')[-1], info.filename
+                else:
+                    archive_filename, archive_filepath = info.split('/')[-1], info
+                if archive_filename is not None and archive_filename == webdriver_name:
+                    try:
+                        archive.extract(info)
+                        archive.close()
+                        webdriver_path = str(Path(archive_filepath).resolve())
+                        if Path(archive_filepath).resolve().parent != Path(os.getcwd()):
+                            webdriver_path = shutil.copy2(str(Path(archive_filepath).resolve()), os.getcwd())
+                        try:
+                            shutil.rmtree(archive_filepath.split('/')[0], ignore_errors=True)
+                            os.remove(archive_path)
+                        except:
+                            pass
+                        os.chmod(webdriver_path, 0o777)
+                        return webdriver_path
+                    except:
+                        return None
+            
+    def menu(self, disable_progress_bar=False): # auto updating or installing webdrivers
+        def download():
+            driver_url = self.browser_data[0]()
+            if driver_url is not None:
+                logging.info('Found a suitable version for your system!')
+                logging.info('Downloading...')
+                console_log('\nFound a suitable version for your system!', OK, silent_mode=SILENT_MODE)
+                console_log('Downloading...', INFO, silent_mode=SILENT_MODE)
+                if self.download_webdriver(driver_url, disable_progress_bar=disable_progress_bar):
+                    logging.info(f'{self.browser_name} webdriver was successfully downloaded and unzipped!')
+                    console_log(f'{self.browser_name} webdriver was successfully downloaded and unzipped!\n', OK, silent_mode=SILENT_MODE)
+                    return os.path.join(os.getcwd(), webdriver_name)
+                else:
+                    logging.info('Error downloading or unpacking!')
+                    console_log('Error downloading or unpacking!\n', ERROR, silent_mode=SILENT_MODE)
+            else:
+                logging.info('A suitable version for your system was not found!')
+                console_log('\nA suitable version for your system was not found!\n', ERROR, silent_mode=SILENT_MODE)
+        logging.info('-- WebDriver Auto-Installer --')
+        console_log(f'{Fore.LIGHTMAGENTA_EX}-- WebDriver Auto-Installer --{Fore.RESET}\n', silent_mode=SILENT_MODE)
+        browser_version, browser_path = self.browser_data[2]()
+        if browser_version is None:
+            if self.custom_browser_location is None or self.custom_browser_location == '':
+                raise RuntimeError(f'{self.browser_name} was not found in the standard catalogs!')
+            raise RuntimeError(f'{self.custom_browser_location} is not a valid executable file of {self.browser_name}!')
+        webdriver_name = self.browser_data[1]
+        current_webdriver_version = None
+        webdriver_path = None
+        if os.path.exists(webdriver_name):
+            try:
+                out = subprocess.check_output([os.path.join(os.getcwd(), webdriver_name), "--version"], stderr=subprocess.PIPE)
+                out = re.search(self.browser_data[3], out.decode('utf-8'))
+                if out is not None:
+                    current_webdriver_version = out.group()
+                    webdriver_path = os.path.join(os.getcwd(), webdriver_name)
+            except:
+                pass
+        logging.info(f'{self.browser_name} version: {browser_version}')
+        logging.info(f'{self.browser_name} webdriver version: {current_webdriver_version}')
+        console_log(f'{self.browser_name} version: {browser_version}', INFO, False, SILENT_MODE)
+        console_log(f'{self.browser_name} webdriver version: {current_webdriver_version}', INFO, False, SILENT_MODE)
+        if self.browser_name == MOZILLA_FIREFOX:
+            latest_geckodriver_version = self.browser_data[0](True)
+            if current_webdriver_version == latest_geckodriver_version:
+                logging.info('The webdriver has already been updated to the latest version!')
+                console_log('The webdriver has already been updated to the latest version!\n', OK, silent_mode=SILENT_MODE)
+                webdriver_path = os.path.join(os.getcwd(), webdriver_name)
+            else:
+                logging.info(f'Updating the webdriver from {current_webdriver_version} to {latest_geckodriver_version} version...')
+                console_log(f'Updating the webdriver from {current_webdriver_version} to {latest_geckodriver_version} version...', INFO, silent_mode=SILENT_MODE)
+                webdriver_path = download()
+        else:
+            if current_webdriver_version is None or (current_webdriver_version.split('.')[0] != browser_version.split('.')[0]): # major version match
+                logging.warning(f'{self.browser_name} webdriver version doesn\'t match version of the installed {self.browser_name}, trying to download...')
+                console_log(f'{self.browser_name} webdriver version doesn\'t match version of the installed {self.browser_name}, trying to download...', WARN, True, SILENT_MODE)
+                webdriver_path = download()
+            else:
+                logging.info('The webdriver has already been updated to the browser version!')
+                console_log('The webdriver has already been updated to the browser version!\n', OK, silent_mode=SILENT_MODE)
+        try:
+            os.chmod(webdriver_path, 0o755)
+        except:
+            pass
+        return [str(Path(webdriver_path).resolve()), str(Path(browser_path).resolve())]