def event_history(self, columns, *, indent=4, sieve=None, repres=None): self._events_to_show = _filter_events(self._all_events, sieve) if not self._events_to_show: print_info('No USB events found!') return if not cfg.QUIET and cfg.ISATTY: choice, abs_filename = _output_choice('event history', 'history.json', 'history/') if choice == '2': try: _dump_events(self._events_to_show, 'event history', abs_filename, indent) except USBRipError as e: print_critical(str(e), initial_error=e.errors['initial_error']) return # elif choice == '1' or choice == '': if columns: table_data = [[COLUMN_NAMES[name] for name in columns]] else: columns = [key for key in COLUMN_NAMES.keys()] table_data = [[val for val in COLUMN_NAMES.values()]] _represent_events(self._events_to_show, columns, table_data, 'USB-History-Events', repres)
def __new__(cls, files=None): try: # child_env = os.environ.copy() # child_env['LANG'] = 'en_US.utf-8' # journalctl_out = check_output(['journalctl'], env=child_env).decode('utf-8') journalctl_out = check_output( ['journalctl', '-o', 'short-iso-precise']).decode('utf-8') if '-- Logs begin at' in journalctl_out: filtered_history = _read_log_file(None, log=StringIO(journalctl_out)) elif files: filtered_history = [] for file in files: filtered_history.extend(_read_log_file(file)) else: filtered_history = _get_filtered_history() except USBRipError as e: print_critical(str(e), initial_error=e.errors['initial_error']) return None all_events = _parse_history(filtered_history) instance = super().__new__(cls) instance._all_events = all_events # self._all_events instance._violations = [] # self._violations instance._events_to_show = None # self._events_to_show return instance
def open_dump(input_dump, columns, *, sieve=None, repres=None): abs_input_dump = os.path.abspath(input_dump) print_info(f'Opening USB event dump: "{abs_input_dump}"') try: with open(abs_input_dump, 'r', encoding='utf-8') as dump: events_dumped = json.load(dump) except json.decoder.JSONDecodeError as e: print_critical('Failed to decode event dump (JSON)', initial_error=str(e)) return if not events_dumped: print_critical('This dump is empty!') return events_to_show = _filter_events(events_dumped, sieve) if not events_to_show: print_info('No USB events found!') return if columns: table_data = [[COLUMN_NAMES[name] for name in columns]] else: columns = [key for key in COLUMN_NAMES.keys()] table_data = [[val for val in COLUMN_NAMES.values()]] _represent_events(events_to_show, columns, table_data, 'USB-Event-Dump', repres)
def generate_auth_json(self, output_auth, attributes, *, indent=4, sieve=None): self._events_to_show = _filter_events(self._all_events, sieve) if not self._events_to_show: print_info('No USB devices found!') rand_id = f'usbrip-{randint(1000, 9999)}' self._events_to_show += [{ 'conn': rand_id, 'host': rand_id, 'vid': rand_id, 'pid': rand_id, 'prod': rand_id, 'manufact': rand_id, 'serial': rand_id, 'port': rand_id, 'disconn': rand_id }] abs_output_auth = os.path.abspath(output_auth) try: dirname = os.path.dirname(abs_output_auth) os_makedirs(dirname) except USBRipError as e: print_critical(str(e), initial_error=e.errors['initial_error']) return 1 else: print_info(f'Created directory "{dirname}/"') try: auth_json = open(abs_output_auth, 'w', encoding='utf-8') except PermissionError as e: print_critical(f'Permission denied: "{abs_output_auth}". Retry with sudo', initial_error=str(e)) return 1 print_info('Generating authorized device list (JSON)') if not attributes: attributes = ('vid', 'pid', 'prod', 'manufact', 'serial') auth = defaultdict(set) for event in tqdm(self._events_to_show, ncols=80, unit='dev'): for key, val in event.items(): if key in attributes and val is not None: auth[key].add(val) auth = {key: list(vals) for key, vals in auth.items()} for key in auth.keys(): auth[key].sort() json.dump(auth, auth_json, sort_keys=True, indent=indent) auth_json.close() os.chmod(abs_output_auth, stat.S_IRUSR | stat.S_IWUSR) # 600 print_info(f'New authorized device list: "{abs_output_auth}"')
def change_password(storage_type, *, compression_level='5'): storage_full_path = f'{USBStorage._STORAGE_BASE}/{storage_type}.7z' if not os.path.isfile(storage_full_path): print_critical(f'Storage not found: "{storage_full_path}"') return old_password = getpass('Old password: '******'New password: '******'Confirm new password: '******'Passwords does not match, try again') return try: out = _7zip_unpack(storage_full_path, old_password) if 'Everything is Ok' in out: base_filename = re.search( r'([^\n ]*\.json)', _7zip_list(storage_full_path, old_password), re.MULTILINE).group(1) json_file = f'{USBStorage._STORAGE_BASE}/{base_filename}' os.remove(storage_full_path) out = _7zip_pack(storage_full_path, json_file, new_password, compression_level) if 'Everything is Ok' in out: print_info('Password was successfully changed') conf_parser = ConfigParser(allow_no_value=True) conf_parser.optionxform = str conf_parser.read(CONFIG_FILE, encoding='utf-8') conf_parser.set(storage_type, 'password', new_password) with open(CONFIG_FILE, 'w', encoding='utf-8') as f: conf_parser.write(f) print_info('Configuration file updated') else: print_critical( 'Undefined behaviour while creating storage', initial_error=out) os.remove(json_file) else: print_critical('Undefined behaviour while unpacking storage', initial_error=out) except USBRipError as e: print_critical(str(e), errcode=e.errors['errcode'], initial_error=e.errors['initial_error']) return
def search_ids(vid, pid, *, offline=True): if offline: print_warning('Offline mode') try: usb_ids = USBIDs.prepare_database(offline=offline) except USBRipError as e: print_critical(str(e), errcode=e.errors['errcode'], initial_error=e.errors['initial_error']) else: _search_ids_helper(usb_ids, vid, pid) usb_ids.close()
def _output_choice(list_name, default_filename, dirname): while True: print( f'[?] How would you like your {list_name} list to be generated?\n') print(' 1. JSON-file') print(' 2. Terminal stdout') number = input('\n[>] Please enter the number of your choice: ') if number == '1': while True: filename = input( f'[>] Please enter the base name for the output file ' f'(default is "{default_filename}"): ') if all(c in printable for c in filename) and len(filename) < 256: if not filename: filename = default_filename elif filename[-5:] != '.json': filename = filename + '.json' filename = root_dir_join(dirname + filename) try: dirname = os.path.dirname(filename) os_makedirs(dirname) except USBRipError as e: print_critical(str(e), initial_error=e.errors['initial_error']) return (None, '') else: print_info(f'Created "{dirname}"') overwrite = True if os.path.isfile(filename): while True: overwrite = input( '[?] File exists. Would you like to overwrite it? [Y/n]: ' ) if len(overwrite) == 1 and overwrite in 'Yy': overwrite = True break elif len(overwrite) == 1 and overwrite in 'Nn': overwrite = False break if overwrite: return (int(number), filename) elif number == '2': return (int(number), '')
def __new__(cls, files=None): try: if files: filtered_history = [] for file in files: filtered_history.extend(_read_log_file(file)) else: print_info('Trying to run journalctl...') # child_env = os.environ.copy() # child_env['LANG'] = 'en_US.utf-8' # journalctl_out = check_output(['journalctl'], env=child_env).decode('utf-8') try: journalctl_out = check_output([ 'journalctl', '-o', 'short-iso-precise' ]).decode('utf-8') except Exception as e: print_warning(f'Failed to run journalctl: {str(e)}') filtered_history = _get_filtered_history() else: if '-- Logs begin at' in journalctl_out: print_info('Successfully ran journalctl') filtered_history = _read_log_file( None, log=StringIO(journalctl_out), total=journalctl_out.count('\n') ) else: print_warning(f'An error occurred when running journalctl: {journalctl_out}') filtered_history = _get_filtered_history() except USBRipError as e: print_critical(str(e), initial_error=e.errors['initial_error']) return None all_events = _parse_history(filtered_history) instance = super().__new__(cls) instance._all_events = all_events # self._all_events instance._violations = [] # self._violations instance._events_to_show = None # self._events_to_show return instance
def generate_auth_json(self, output_auth, attributes, *, indent=4, sieve=None): self._events_to_show = _filter_events(self._all_events, sieve) if not self._events_to_show: print_info('No USB devices found!') return 1 abs_output_auth = os.path.abspath(output_auth) try: dirname = os.path.dirname(abs_output_auth) os_makedirs(dirname) except USBRipError as e: print_critical(str(e), initial_error=e.errors['initial_error']) return 1 else: print_info(f'Created "{dirname}"') try: auth_json = open(abs_output_auth, 'w', encoding='utf-8') except PermissionError as e: print_critical( f'Permission denied: "{abs_output_auth}". Retry with sudo', initial_error=str(e)) return 1 print_info('Generating authorized device list (JSON)') if not attributes: attributes = ('vid', 'pid', 'prod', 'manufact', 'serial') auth = defaultdict(list) for event in tqdm(self._events_to_show, ncols=80, unit='dev'): for key, val in event.items(): if (key in attributes and val is not None and val not in auth[key]): auth[key].append(val) for key in auth.keys(): auth[key].sort() json.dump(auth, auth_json, sort_keys=True, indent=indent) auth_json.close() print_info(f'New authorized device list: "{abs_output_auth}"')
def create_storage(storage_type, password, *, input_auth=None, attributes=None, compression_level='5', indent=4, sieve=None): if storage_type == 'history': events_to_show = _get_history_events(sieve) elif storage_type == 'violations': try: events_to_show = _get_violation_events(sieve, input_auth, attributes, indent) except USBRipError as e: print_critical(str(e), initial_error=e.errors['initial_error']) return 1 if events_to_show is None: return 1 if events_to_show: min_date, max_date = _get_dates(events_to_show) json_file = f'{USBStorage._STORAGE_BASE}/{min_date}-{max_date}.json' else: json_file = f'{USBStorage._STORAGE_BASE}/{datetime.now().strftime("%Y%m%dT%H%M%S")}.json' try: _dump_events(events_to_show, storage_type, json_file, indent) except USBRipError as e: print_critical(str(e), initial_error=e.errors['initial_error']) return 1 storage_full_path = f'{USBStorage._STORAGE_BASE}/{storage_type}.7z' if os.path.exists(storage_full_path): os.remove(storage_full_path) try: out = _7zip_pack(storage_full_path, json_file, password, compression_level) except USBRipError as e: os.remove(json_file) print_critical(str(e), errcode=e.errors['errcode'], initial_error=e.errors['initial_error']) return 1 if 'Everything is Ok' in out: print_info(f'New {storage_type} storage: "{storage_full_path}"') print_secret('Your password is', secret=password) os.remove(json_file) else: print_critical('Undefined behaviour while creating storage', initial_error=out)
def __new__(cls, files=None): if files: filtered_history = [] for file in files: filtered_history.extend(_read_log_file(file)) else: try: filtered_history = _get_filtered_history() except USBRipError as e: print_critical(str(e)) return None all_events = _parse_history(filtered_history) instance = super().__new__(cls) instance._all_events = all_events # self._all_events instance._violations = [] # self._violations instance._events_to_show = None # self._events_to_show return instance
def __new__(cls, files=None): if files: raw_history = DefaultOrderedDict(default_factory=list) for file in files: raw_history.update(_read_log_file(file)) else: try: raw_history = _get_raw_history() except USBRipError as e: print_critical(str(e)) return None divided_history = _divide_history(raw_history) all_events = _parse_history(divided_history) instance = super().__new__(cls) instance._all_events = all_events # self._all_events instance._violations = [] # self._violations instance._events_to_show = None # self._events_to_show return instance
def open_storage(storage_type, password, columns, *, sieve=None, repres=None): storage_full_path = f'{USBStorage._STORAGE_BASE}/{storage_type}.7z' if not os.path.isfile(storage_full_path): print_critical(f'Storage not found: "{storage_full_path}"') return try: out = _7zip_unpack(storage_full_path, password) except USBRipError as e: print_critical(str(e), errcode=e.errors['errcode'], initial_error=e.errors['initial_error']) return if 'Everything is Ok' in out: base_filename = re.search(r'([^\n ]*\.json)', _7zip_list(storage_full_path, password), re.MULTILINE).group(1) json_file = f'{USBStorage._STORAGE_BASE}/{base_filename}' USBEvents.open_dump(json_file, columns, sieve=sieve, repres=repres) os.remove(json_file) else: print_critical('Undefined behaviour while unpacking storage', initial_error=out)
def open_storage(storage_type, password, columns, *, sieve=None, repres=None): storage_full_path = '{}/{}.7z'.format(USBStorage._STORAGE_BASE, storage_type) if not os.path.isfile(storage_full_path): print_critical( 'Storage not found: \'{}\''.format(storage_full_path)) return try: out = _7zip_unpack(storage_full_path, password) except USBRipError as e: print_critical(str(e), errcode=e.errors['errcode'], initial_error=e.errors['initial_error']) return if 'Everything is Ok' in out: base_filename = re.search(r'Extracting\s*(.*?$)', out, re.MULTILINE).group(1) json_file = '{}/{}'.format(USBStorage._STORAGE_BASE, base_filename) USBEvents.open_dump(json_file, columns, sieve=sieve, repres=repres) os.remove(json_file) else: print_critical('Undefined behaviour while unpacking storage', initial_error=out)
def search_violations(self, input_auth, attributes, columns, *, indent=4, sieve=None, repres=None): print_info( f'Opening authorized device list: "{os.path.abspath(input_auth)}"') try: auth = _process_auth_list(input_auth, indent) except json.decoder.JSONDecodeError as e: print_critical('Failed to decode authorized device list (JSON)', initial_error=str(e)) return print_info('Searching for violations') if not attributes: attributes = auth.keys() for event in self._all_events: try: if any(event[key] not in vals and event[key] is not None for key, vals in zip(attributes, auth.values())): self._violations.append(event) except KeyError as e: print_critical('No such attribute in authorized device list', initial_error=str(e)) return self._events_to_show = _filter_events(self._violations, sieve) if not self._events_to_show: print_info('No USB violation events found!') return if not cfg.QUIET and cfg.ISATTY: number, filename = _output_choice('violation', 'viol.json', 'violations/') if number is None: return elif number == 1: try: _dump_events(self._events_to_show, 'violations', filename, indent) except USBRipError as e: print_critical(str(e), initial_error=e.errors['initial_error']) return if columns: table_data = [[COLUMN_NAMES[name] for name in columns]] else: columns = [key for key in COLUMN_NAMES.keys()] table_data = [[val for val in COLUMN_NAMES.values()]] _represent_events(self._events_to_show, columns, table_data, 'USB-Violation-Events', repres)
def change_password(storage_type, old_password, new_password, *, compression_level='5'): storage_full_path = '{}/{}.7z'.format(USBStorage._STORAGE_BASE, storage_type) if not os.path.isfile(storage_full_path): print_critical( 'Storage not found: \'{}\''.format(storage_full_path)) return try: out = _7zip_unpack(storage_full_path, old_password) if 'Everything is Ok' in out: os.remove(storage_full_path) base_filename = re.search(r'Extracting\s*(.*?$)', out, re.MULTILINE).group(1) json_file = '{}/{}'.format(USBStorage._STORAGE_BASE, base_filename) out = _7zip_pack(storage_full_path, json_file, new_password, compression_level) if 'Everything is Ok' in out: print_info('Password was successfully changed') else: print_critical( 'Undefined behaviour while creating storage', initial_error=out) os.remove(json_file) else: print_critical('Undefined behaviour while unpacking storage', initial_error=out) except USBRipError as e: print_critical(str(e), errcode=e.errors['errcode'], initial_error=e.errors['initial_error']) return
def list_storage(storage_type, password): storage_full_path = f'{USBStorage._STORAGE_BASE}/{storage_type}.7z' if not os.path.isfile(storage_full_path): print_critical(f'Storage not found: "{storage_full_path}"') return try: out = _7zip_list(storage_full_path, password) except USBRipError as e: print_critical(str(e), errcode=e.errors['errcode'], initial_error=e.errors['initial_error']) return if '--' in out: print(out[out.index('--'):] + '--') else: print_critical('Undefined behaviour while listing storage contents', initial_error=out)
def main(): if not len(sys.argv) > 1: print(BANNER + '\n') usbrip_arg_error() parser = cmd_line_options() args = parser.parse_args() if 'quiet' in args and not args.quiet: if cfg.ISATTY: print(BANNER + '\n') else: print(f'# Done as: usbrip {" ".join(sys.argv[1:])}') else: cfg.QUIET = True # ---------------------------------------------------------- # ------------------------- Banner ------------------------- # ---------------------------------------------------------- if args.subparser == 'banner': print(BANNER) # ---------------------------------------------------------- # ----------------------- USB Events ----------------------- # ---------------------------------------------------------- elif args.subparser == 'events' and args.ue_subparser: sieve, repres = validate_ue_args(args) # ------------------- USB Events History ------------------- if args.ue_subparser == 'history': timing.begin() ueh = USBEvents(args.file) if ueh: ueh.event_history( args.column, sieve=sieve, repres=repres ) # -------------------- USB Events Open --------------------- elif args.ue_subparser == 'open': timing.begin() USBEvents.open_dump( args.input, args.column, sieve=sieve, repres=repres ) # ------------------ USB Events Gen Auth ------------------- elif args.ue_subparser == 'gen_auth': timing.begin() ueg = USBEvents(args.file) if ueg: if ueg.generate_auth_json( args.output, args.attribute, sieve=sieve ): usbrip_internal_error() else: usbrip_internal_error() # ----------------- USB Events Violations ------------------ elif args.ue_subparser == 'violations': timing.begin() uev = USBEvents(args.file) if uev: uev.search_violations( args.input, args.attribute, args.column, sieve=sieve, repres=repres ) # ---------------------------------------------------------- # ---------------------- USB Storage ----------------------- # ---------------------------------------------------------- elif args.subparser == 'storage' and args.us_subparser: if os.geteuid() != 0: sys.exit('Permission denied. Retry with sudo') sieve, repres = validate_us_args(args) timing.begin() us = USBStorage() # -------------------- USB Storage List -------------------- if args.us_subparser == 'list': us.list_storage( args.storage_type, args.password ) # -------------------- USB Storage Open -------------------- elif args.us_subparser == 'open': us.open_storage( args.storage_type, args.password, args.column, sieve=sieve, repres=repres ) # ------------------- USB Storage Update ------------------- elif args.us_subparser == 'update': if us.update_storage( args.storage_type, args.password, input_auth=args.input, attributes=args.attribute, compression_level=args.lvl, sieve=sieve ): usbrip_internal_error() # ------------------- USB Storage Create ------------------- elif args.us_subparser == 'create': if us.create_storage( args.storage_type, password=args.password, input_auth=args.input, attributes=args.attribute, compression_level=args.lvl, sieve=sieve ): usbrip_internal_error() # ------------------- USB Storage Passwd ------------------- elif args.us_subparser == 'passwd': us.change_password( args.storage_type, args.old, args.new, compression_level=args.lvl ) # ---------------------------------------------------------- # ------------------------ USB IDs ------------------------- # ---------------------------------------------------------- elif args.subparser == 'ids' and args.ui_subparser: validate_ui_args(args) timing.begin() ui = USBIDs() # --------------------- USB IDs Search --------------------- if args.ui_subparser == 'search': ui.search_ids( args.vid, args.pid, offline=args.offline ) # -------------------- USB IDs Download -------------------- elif args.ui_subparser == 'download': try: usb_ids = ui.prepare_database(offline=False) except USBRipError as e: print_critical(str(e), errcode=e.errors['errcode'], initial_error=e.errors['initial_error']) else: usb_ids.close() else: subparser = ' ' + args.subparser + ' ' usbrip_arg_error(f'Choose one of the usbrip {args.subparser} actions', subparser=subparser)
def create_storage(storage_type, *, password=None, input_auth=None, attributes=None, compression_level='5', indent=4, sieve=None): if storage_type == 'history': events_to_show = _get_history_events(sieve) elif storage_type == 'violations': try: events_to_show = _get_violation_events(sieve, input_auth, attributes, indent) except USBRipError as e: print_critical(str(e), initial_error=e.errors['initial_error']) return 1 if events_to_show is None: return 1 if events_to_show: min_date, max_date = _get_dates(events_to_show) json_file = '{}/{}-{}.json'.format(USBStorage._STORAGE_BASE, min_date, max_date) else: json_file = '{}/{}.json'.format(USBStorage._STORAGE_BASE, datetime.now().strftime('%m%d')) try: _dump_events(events_to_show, storage_type, json_file, indent) except USBRipError as e: print_critical(str(e), initial_error=e.errors['initial_error']) return 1 if password is None: print_warning('No password provided, generating random one') password = _gen_random_password(12) storage_full_path = '{}/{}.7z'.format(USBStorage._STORAGE_BASE, storage_type) if os.path.exists(storage_full_path): os.remove(storage_full_path) try: out = _7zip_pack(storage_full_path, json_file, password, compression_level) except USBRipError as e: os.remove(json_file) print_critical(str(e), errcode=e.errors['errcode'], initial_error=e.errors['initial_error']) return 1 if 'Everything is Ok' in out: print_info('New {} storage: \'{}\''.format(storage_type, storage_full_path)) print_secret('Your password is', secret=password) os.remove(json_file) else: print_critical('Undefined behaviour while creating storage', initial_error=out)
def main(): if not len(sys.argv) > 1: print(BANNER + '\n') usbrip_arg_error() arg_parser = get_arg_parser() args = arg_parser.parse_args() if 'quiet' in args and not args.quiet: if cfg.ISATTY: print(BANNER + '\n') else: print(f'# Done as: usbrip {" ".join(sys.argv[1:])}') else: cfg.QUIET = True # ---------------------------------------------------------- # ------------------------- Banner ------------------------- # ---------------------------------------------------------- if args.subparser == 'banner': print(BANNER) # ---------------------------------------------------------- # ----------------------- USB Events ----------------------- # ---------------------------------------------------------- elif args.subparser == 'events' and args.ue_subparser: if os.geteuid() != 0: sys.exit('Permission denied. Retry with sudo') sieve, repres = validate_ue_args(args) # ------------------- USB Events History ------------------- if args.ue_subparser == 'history': timing.begin() ue = USBEvents(args.file) if ue: ue.event_history(args.column, sieve=sieve, repres=repres) # -------------------- USB Events Open --------------------- elif args.ue_subparser == 'open': timing.begin() USBEvents.open_dump(args.input, args.column, sieve=sieve, repres=repres) # ------------------ USB Events GenAuth ------------------- elif args.ue_subparser == 'genauth': timing.begin() ue = USBEvents(args.file) if ue: if ue.generate_auth_json(args.output, args.attribute, sieve=sieve): usbrip_internal_error() else: usbrip_internal_error() # ----------------- USB Events Violations ------------------ elif args.ue_subparser == 'violations': timing.begin() ue = USBEvents(args.file) if ue: ue.search_violations(args.input, args.attribute, args.column, sieve=sieve, repres=repres) # ---------------------------------------------------------- # ---------------------- USB Storage ----------------------- # ---------------------------------------------------------- elif args.subparser == 'storage' and args.us_subparser: if os.geteuid() != 0: sys.exit('Permission denied. Retry with sudo') if any(not os.path.exists(p) for p in ('/opt/usbrip/', '/var/opt/usbrip', '/usr/local/bin/usbrip')): sys.exit( 'The "storage" module can only be used when usbrip is installed via "installer.sh" - https://git.io/fjDPT' ) sieve, repres = validate_us_args(args) timing.begin() config_parser = get_config_parser() us = USBStorage() # -------------------- USB Storage List -------------------- if args.us_subparser == 'list': us.list_storage(args.storage_type, config_parser[args.storage_type]['password']) # -------------------- USB Storage Open -------------------- elif args.us_subparser == 'open': us.open_storage(args.storage_type, config_parser[args.storage_type]['password'], args.column, sieve=sieve, repres=repres) # ------------------- USB Storage Update ------------------- elif args.us_subparser == 'update': if us.update_storage(args.storage_type, config_parser[args.storage_type]['password'], input_auth=args.input, attributes=args.attribute, compression_level=args.lvl, sieve=sieve): usbrip_internal_error() # ------------------- USB Storage Create ------------------- elif args.us_subparser == 'create': if us.create_storage(args.storage_type, config_parser[args.storage_type]['password'], input_auth=args.input, attributes=args.attribute, compression_level=args.lvl, sieve=sieve): usbrip_internal_error() # ------------------- USB Storage Passwd ------------------- elif args.us_subparser == 'passwd': us.change_password(args.storage_type, compression_level=args.lvl) # ---------------------------------------------------------- # ------------------------ USB IDs ------------------------- # ---------------------------------------------------------- elif args.subparser == 'ids' and args.ui_subparser: validate_ui_args(args) timing.begin() ui = USBIDs() # --------------------- USB IDs Search --------------------- if args.ui_subparser == 'search': ui.search_ids(args.vid, args.pid, offline=args.offline) # -------------------- USB IDs Download -------------------- elif args.ui_subparser == 'download': try: usb_ids = ui.prepare_database(offline=False) except USBRipError as e: print_critical(str(e), errcode=e.errors['errcode'], initial_error=e.errors['initial_error']) else: usb_ids.close() else: subparser = ' ' + args.subparser + ' ' usbrip_arg_error(f'Choose one of the usbrip {args.subparser} actions', subparser=subparser)
def update_storage( storage_type, password, *, input_auth=None, attributes=None, compression_level='5', indent=4, sieve=None ): if storage_type == 'history': events_to_show = _get_history_events(sieve) elif storage_type == 'violations': try: events_to_show = _get_violation_events(sieve, input_auth, attributes, indent) except USBRipError as e: print_critical(str(e), initial_error=e.errors['initial_error']) return 1 if events_to_show is None: return 1 if events_to_show: min_date, max_date = _get_dates(events_to_show) else: print_info('No events to append') return 1 storage_full_path = f'{USBStorage._STORAGE_BASE}/{storage_type}.7z' if not os.path.isfile(storage_full_path): print_critical(f'Storage not found: "{storage_full_path}"') return 1 print_info(f'Updating storage: "{storage_full_path}"') try: out = _7zip_unpack(storage_full_path, password) except USBRipError as e: print_critical(str(e), errcode=e.errors['errcode'], initial_error=e.errors['initial_error']) return 1 if 'Everything is Ok' in out: base_filename = re.search(r'([^\n ]*\.json)', _7zip_list(storage_full_path, password), re.MULTILINE).group(1) json_file = f'{USBStorage._STORAGE_BASE}/{base_filename}' os.remove(storage_full_path) with open(json_file, 'r', encoding='utf-8') as dump: events_dumped = json.load(dump) os.remove(json_file) merged_events = _merge_json_events(events_dumped, events_to_show) if len(base_filename) > 9: # len('mmdd.json') == 9 min_date = base_filename[:4] new_json_file = f'{USBStorage._STORAGE_BASE}/{min_date}-{max_date}.json' _dump_events(merged_events, storage_type, new_json_file, indent) try: out = _7zip_pack(storage_full_path, new_json_file, password, compression_level) except USBRipError as e: os.remove(new_json_file) print_critical(str(e), errcode=e.errors['errcode'], initial_error=e.errors['initial_error']) return 1 if 'Everything is Ok' in out: print_info('Storage was successfully updated') else: print_critical('Undefined behaviour while creating storage', initial_error=out) os.remove(new_json_file) else: print_critical('Undefined behaviour while unpacking storage', initial_error=out)