def read_register( ctx: click.Context, address: int, item_length: int, count: int, file: click.File, use_hexdump: bool, ) -> None: """Reads the contents of a memory location or register value. The address of the register or memory location should be passed in as the first argument. Optional arguments include the data format of the register value in the number of bits and number of bytes to read. \b ADDRESS - starting address where to read FORMAT - bits per item: valid values: 8, 16, 32; default 32 COUNT - bytes to read; default size of FORMAT FILE - write data into a file; write to stdout if not specified """ with SDP(ctx.obj["interface"]) as sdp: response = sdp.read_safe(address, count, item_length) if not response: click.echo( f"Error: invalid sub-command or arguments 'read-register {address:#8X} {item_length} {count}'" ) sys.exit(1) if file: file.write(response) # type: ignore else: click.echo(format_raw_data(response, use_hexdump=use_hexdump)) display_output([], sdp.hab_status, ctx.obj["use_json"])
def main(source: click.File, destination: click.File) -> int: requirements = source.read().split() new_requirements = sort_requirements(requirements=requirements) destination.write("\n".join(new_requirements)) click.echo(f"Successfully wrote to {destination.name}") return 0
def read_key_store(ctx: click.Context, key_store_file: click.File) -> None: """Read the key store from bootloader to host(PC). \b FILE - Binary file to save the key store. """ with McuBoot(ctx.obj['interface']) as mboot: response = mboot.kp_read_key_store() if not response: raise SPSDKError('Error reading key store') key_store_file.write(response) # type: ignore display_output([len(response)], mboot.status_code, ctx.obj['use_json'])
def generate_key_blob(ctx: click.Context, dek_file: click.File, blob_file: click.File) -> None: """Generate the Key Blob for a given DEK. \b DEK_FILE - the file with the binary DEK key BLOB_FILE - the generated file with binary key blob """ with McuBoot(ctx.obj['interface']) as mboot: data = dek_file.read() # type: ignore write_response = mboot.generate_key_blob(data) if not write_response: raise ValueError(f"Error generating key blob") blob_file.write(write_response) # type: ignore display_output([mboot.status_code, len(write_response)], mboot.status_code, ctx.obj['use_json'])
def process_input_file(input: click.File, output: click.File): "Process file and create a download link for output file" if DEBUG: click.echo("global debug set, printing some debug output") while True: click.echo(f"Reading from {input.name}...") chunk = input.read(2048) if not chunk: break click.echo(f"Writing to {output.name}...") chunk = chunk.upper() output.write(chunk) click.echo({output.name})
def cli_download( from_file: click.File, url_list: Tuple[str, ...], verbose: bool = False ) -> None: urls = [(x, None) for x in url_list] if from_file: urls += [(x.strip("\n"), None) for x in from_file.readlines()] download(urls, verbose)
def main(file: click.File, debug: bool, input: int) -> int: """ A Python implementation of the chicken esoteric programming language. Pass a source file using -f/--file or pipe the source to the program. """ # Debug mode if debug: log.setLevel(logging.DEBUG) # Accept source code from both the --file option and stdin # https://stackoverflow.com/a/13443424/11457597 stdin_mode = os.fstat(sys.stdin.fileno()).st_mode if file: log.debug(f"Reading source from file: {file.name!r}") source_code = file.read() elif stat.S_ISFIFO(stdin_mode) or stat.S_ISREG(stdin_mode): log.debug("Reading source from pipe/redirect...") source_code = click.open_file("-").read() else: log.debug("Couldn't find source!") message = ( "ERROR: Source code required. Pipe text into the program or pass the --file option." ) click.echo(message=message, err=True) return EXIT_FAILURE exit_status = interpret(source_code, input) return exit_status
def standard_interface(f): @argument('defs', type=_path) @option('--captions', type=_path) @option('--collect-dir', type=_path, help="Directory in which figure files can be found by ID") # This is kinda a legacy option -- this type of thing can be controlled by # pointing to a new set of templates now. @option('--starred-floats/--no-starred-floats', default=True) @option('--natbib', 'citation_backend', flag_value='natbib', default=True) @option('--biblatex', 'citation_backend', flag_value='biblatex') @option("--order-by", default=None, type=File()) @pass_context def cli_wrapper(ctx, defs, **kwargs): # Get captions file if defined spec = load_spec(defs, caption_file=kwargs.pop('captions', None)) # Create a global pandoc processor ctx.pandoc_processor = partial( pandoc_processor, citation_backend=kwargs.pop('citation_backend')) template_dir = kwargs.pop('template_dir') ctx.tex_renderer = TexRenderer(*template_dir) includes = process_includes(spec, **kwargs) return ctx.invoke(f, ctx, spec, includes) return update_wrapper(cli_wrapper, f)
def _show_filename(file: click.File): if file.isatty(): text = _user_input_help() else: text = file.name click.echo(text)
def write_file(ctx: click.Context, bin_file: click.File) -> None: """Write boot image data. \b FILE - binary file to write """ click.echo(WARNING_MSG) data = bin_file.read() # type: ignore with SDPS(ctx.obj['interface'], device_name=ctx.obj['name']) as sdps: sdps.write_file(data)
def process_optional_file(input: click.File): "Process a file given as option" if input is None: click.echo("no input file given") while True: click.echo(f"Reading from {input.name}...") chunk = input.read(2048) if not chunk: break click.echo(chunk.upper())
def receive_sb_file(ctx: click.Context, sb_file: click.File) -> None: """Receive SB file. \b FILE - SB file to send to target """ with McuBoot(ctx.obj['interface']) as mboot: data = sb_file.read() # type: ignore mboot.receive_sb_file(data) display_output([], mboot.status_code, ctx.obj['use_json'])
def load_image(ctx: click.Context, boot_file: click.File) -> None: """Load a boot image to the device. \b FILE - boot file to load """ data = boot_file.read() # type: ignore with McuBoot(ctx.obj['interface']) as mboot: mboot.load_image(data) display_output([], mboot.status_code, ctx.obj['use_json'])
def parse(device: str, revision: str, area: str, output: click.Path, binary: click.File, show_calc: bool, show_diff: bool) -> None: """Parse binary a extract configuration.""" pfr_obj = _get_pfr_class(area)(device=device, revision=revision) data = binary.read() # type: ignore parsed = pfr_obj.parse(data, exclude_computed=False) if show_diff: parsed = dict_diff( pfr_obj.generate_config(exclude_computed=not show_calc), parsed) json_data = json.dumps(parsed, indent=2) _store_output(json_data, output)
def read_register(ctx: click.Context, address: int, item_length: int, count: int, file: click.File, use_hexdump: bool) -> None: """Read one or more registers. \b ADDRESS - starting address where to read FORMAT - bits per item: valid values: 8, 16, 32; default 32 COUNT - items to read; default 1 FILE - write data into a file; write to stdout if not specified """ with SDP(ctx.obj['interface']) as sdp: response = sdp.read_safe(address, count, item_length) if not response: click.echo(f"Error: invalid command or arguments 'read-register {address:#8X} {item_length} {count}'") sys.exit(1) if file: file.write(response) # type: ignore else: click.echo(format_raw_data(response, use_hexdump=use_hexdump)) display_output([], sdp.response_value, ctx.obj['use_json'])
def read_memory(ctx: click.Context, address: int, byte_count: int, out_file: click.File, memory_id: int, use_hexdump: bool) -> None: """Read memory. \b ADDRESS - starting address BYTE_COUNT - number of bytes to read FILE - store result into this file, if not specified use stdout MEMORY_ID - id of memory to read from (default: 0) """ with McuBoot(ctx.obj['interface']) as mboot: response = mboot.read_memory(address, byte_count, memory_id) assert response, "Error reading memory" if out_file: out_file.write(response) # type: ignore else: click.echo(format_raw_data(response, use_hexdump=use_hexdump)) display_output([len(response)], mboot.status_code, ctx.obj['use_json'], f"Read {len(response)} of {byte_count} bytes.")
def write_file(ctx: click.Context, address: int, bin_file: click.File, count: int) -> None: """Write file at address. \b ADDRESS - starting address of the image FILE - binary file to write COUNT - Count is size of data to write in bytes (default: whole file) """ data = bin_file.read(count) # type: ignore with SDP(ctx.obj['interface']) as sdp: sdp.write_file(address, data) display_output([], sdp.response_value)
def receive_sb_file(ctx: click.Context, sb_file: click.File) -> None: """Receive SB file. \b FILE - SB file to send to target """ with McuBoot(ctx.obj['interface']) as mboot: data = sb_file.read() # type: ignore write_response = mboot.receive_sb_file(data) assert write_response, f"Error sending SB file." display_output([write_response], mboot.status_code, ctx.obj['use_json'])
def write_memory(ctx: click.Context, address: int, in_file: click.File, memory_id: int) -> None: """Write memory. \b ADDRESS - starting address FILE - write content of this file MEMORY_ID - id of memory to read from (default: 0) """ with McuBoot(ctx.obj['interface']) as mboot: data = in_file.read() # type: ignore write_response = mboot.write_memory(address, data, memory_id) assert write_response, f"Error writing memory addr={address:#0x} memory_id={memory_id}" display_output([write_response], mboot.status_code, ctx.obj['use_json'])
def generate_stats(output:click.File, limit=None): try: from google.cloud import bigquery client = bigquery.Client() except Exception: logger.error("Error creating BigQuery client, Aura is probably not correctly configured. Please consult docs.") sys.exit(1) if limit: q = PYPI_STATS_QUERY + f" LIMIT {int(limit)}" else: q = PYPI_STATS_QUERY logger.info("Running Query on PyPI download dataset") query_job = client.query( q, location = 'US', ) for row in query_job: output.write(json.dumps(dict(row)) + '\n') logger.info("PyPI download stats generation finished")
def load_file(verbose, file: click.File): """Load and execute a script file into database.""" sql = file.read() click.secho(f'Loading file {file.name}...', bold = True, fg = 'yellow') if verbose: click.echo(sql) with _db.session.begin_nested(): _db.session.execute(sql) _db.session.commit() click.secho(f'File {file.name} loaded!', bold = True, fg = 'green')
def generate_key_blob(ctx: click.Context, dek_file: click.File, blob_file: click.File, key_sel: str) -> None: """Generate the Key Blob for a given DEK. \b DEK_FILE - the file with the binary DEK key BLOB_FILE - the generated file with binary key blob KEY_SEL - select the BKEK used to wrap the BK and generate the blob. For devices with SNVS, valid options of [key_sel] are 0, 1 or OTPMK: OTPMK from FUSE or OTP(default), 2 or ZMK: ZMK from SNVS, 3 or CMK: CMK from SNVS, For devices without SNVS, this option will be ignored. """ with McuBoot(ctx.obj['interface']) as mboot: data = dek_file.read() # type: ignore key_sel_int = int(key_sel) if key_sel.isnumeric() else GenerateKeyBlobSelect.get(key_sel) assert isinstance(key_sel_int, int) write_response = mboot.generate_key_blob(data, key_sel=key_sel_int) display_output( [mboot.status_code, len(write_response)] if write_response else None, mboot.status_code, ctx.obj['use_json'] ) if write_response: blob_file.write(write_response) # type: ignore
def write_file(ctx: click.Context, address: int, bin_file: click.File, count: int) -> None: """Writes file to the device’s memory address. \b ADDRESS - starting address of the image FILE - binary file to write COUNT - Count is the size of data to write in bytes (default: whole file) """ data = bin_file.read(count) # type: ignore with SDP(ctx.obj["interface"]) as sdp: sdp.write_file(address, data) display_output( [], sdp.hab_status, extra_output=f"Response status = {decode_status_code(sdp.cmd_status)}.", )
def main(program: click.File, raw: bool = False) -> None: space = FungeSpace(program.read()) # type: ignore # TODO: logging, commenting # If no state activated, continue processing of char # else, move to next cell while space.running: cmd = space.val() char = chr(cmd) if space.toggle_states(char): run_instruction(char, space) space.move() # output newline to terminal unless --raw if (not raw) and stdout.isatty(): click.echo("")
def cli_simple( from_file: click.File, author: str, title: str, url_list: Tuple[str, ...], verbose: bool = False, ): urls = [x for x in url_list] if from_file: urls += [x.strip("\n") for x in from_file.readlines()] if not urls: click.echo("You must provide at least one URL to download.") return story = HTMLStory( chapters=urls, author=author, title=title, url=furl("http://httpbin.org/status/200"), verbose=verbose, ) story.run()
def parse_binary( device: str, revision: str, area: str, output: click.Path, binary: click.File, show_calc: bool, show_diff: bool, ) -> None: """Parse binary and extract configuration.""" pfr_obj = _get_pfr_class(area)(device=device, revision=revision) data = binary.read() # type: ignore pfr_obj.parse(data) parsed = pfr_obj.get_yaml_config(exclude_computed=not show_calc, diff=show_diff) yaml = YAML() yaml.indent(sequence=4, offset=2) stream = io.StringIO() yaml.dump(parsed, stream) yaml_data = stream.getvalue() _store_output(yaml_data, output)
def migra( owner: str, file: click.File, urls: List[str], submodule_from: str, ): if not check_if_installed("git") or not check_if_installed("hub"): return # Filter out invalid URLs and join file and args URLs urls = list(filter(validate_git_url, urls)) if file: urls += list(filter(validate_git_url, file.read().splitlines())) # Removes duplicates urls = list(set(urls)) names: Dict[str, List[str]] = {} # Assumes a match is always found for url in urls: match = REPO_NAME_REGEX.search(url) name = match.group(1) if name in names: names[name].append(url) else: names[name] = [url] # Removes repositories with same name duplicates: Dict[str, List[str]] = {k: v for k, v in names.items() if len(v) > 1} repos: Dict[str, str] = {k: v[0] for k, v in names.items() if len(v) == 1} # Warn users that duplicates won't be processed if len(duplicates) > 0: print("Skipping repositories with same name:") for name, repo_urls in duplicates.items(): print(f"{name}") for url in repo_urls: print(f" {url}") # Starts processing repositories asyncio.run(process(owner, repos, submodule_from))
def get_docker_compose(input_file: click.File) -> dict: """Gets the contents of the docker-compose file after it's been parsed by PyYaml. If the file cannot be opened or parsed i.e. incorrect yaml. Then it will throw an error and exit. Args: input_file (click.File): An file object (docker-compose). Returns: dict: Contents of the docker-compose file. """ logger.info("Opening docker-compose file.") try: data = "".join(sys.stdin.readlines( )) if input_file.name == "<stdin>" else input_file.read() docker_compose = yaml.load(data, Loader=yaml.SafeLoader) except yaml.YAMLError as e: error_message = f"Invalid yaml file, {input_file.name}." logger.error(f"error_message, {e}") click.echo(error_message, err=True) sys.exit(1) logger.info("Retrieved docker compose data.") return docker_compose
def explore(startup_command: str, quiet: bool, file_commands, startup_script: click.File, enable_api: bool, plugin_folder: str) -> None: """ Start the objection exploration REPL. """ agent = Agent() pause_early = not (file_commands is None and startup_script is None and startup_command is None) try: agent.inject(pause_early) except (frida.ServerNotRunningError, frida.NotSupportedError) as e: click.secho('Unable to connect to the frida server: {error}'.format( error=str(e)), fg='red') return # set the frida agent state_connection.set_agent(agent=agent) # load plugins if plugin_folder: folder = os.path.abspath(plugin_folder) debug_print('[plugin] Plugins path is: {0}'.format(folder)) for p in os.scandir(folder): # skip files and hidden directories if p.is_file() or p.name.startswith('.'): debug_print('[plugin] Skipping {0}'.format(p.name)) continue debug_print('[plugin] Attempting to load plugin at {0}'.format( p.path)) load_plugin([p.path]) # start the main REPL r = Repl() # if we have a command to run, do that first before # the call to get_device_info(). if startup_command: for command in startup_command: click.secho('Running a startup command... {0}'.format(command), dim=True) r.run_command(command) # If we have a script, import and run that asap if startup_script: click.secho( 'Importing and running startup script at: {location}'.format( location=startup_script), dim=True) response = agent.single(startup_script.read(), pause_early) print(response) # process commands from a resource file if file_commands: click.secho('Running commands from file...', bold=True) for command in file_commands.readlines(): # clean up newlines command = command.strip() # do nothing for empty lines if command == '': continue # run the command using the instantiated repl click.secho('Running: \'{0}\':\n'.format(command), dim=True) r.run_command(command) agent.resume() try: # poll the device for information. this method also sets # the device type internally in state.device device_info = get_device_info() except (frida.TimedOutError, frida.ServerNotRunningError, frida.ProcessNotFoundError, frida.NotSupportedError) as e: click.secho('Could not connect with error: {0}'.format(str(e)), fg='red') print_frida_connection_help() return warn_about_older_operating_systems() # start the api server if enable_api: def api_thread(): """ Small method to run Flash non-blocking :return: """ a = create_api_app() a.run(host=app_state.api_host, port=app_state.api_port) click.secho('Starting API server on {host}:{port}'.format( host=app_state.api_host, port=app_state.api_port), fg='yellow', bold=True) thread = threading.Thread(target=api_thread) thread.daemon = True thread.start() time.sleep(2) # run the REPL and wait for more commands r.set_prompt_tokens(device_info) r.start_repl(quiet=quiet)
def process_optional_output_file(output: click.File): "Process an output file given as option" if output is None: click.echo("No input file given") else: output.write('Some text written to optional output file')
z_delay = utils.as_list_with_len(network['Z']['delay'], length) setups = [] for delays in zip(x_delay, y_delay, z_delay): s = deepcopy(setup) s['network']['X']['delay'] = delays[0] s['network']['Y']['delay'] = delays[1] s['network']['Z']['delay'] = delays[2] setups.append(s) return setups @command() @argument("file", type=File('rb')) def main(file: File): utils.configure_loguru() dc = DockerClient.from_env() # Load benchmark matrix matrix = load(file, Loader=Loader) client = matrix['client'] output = matrix['output'] runs_per_setup = matrix['runs-per-setup'] defaults = matrix['defaults'] # Setup the Docker network. tc = containers.create_tc_container(dc) net = containers.create_network(dc)
from click import argument, command, File, option, Path from ..utils import samples_from_dir @command() @argument('in_directory', type=Path(exists=True, file_okay=False)) @option('--base-dir', '-b', type=Path(exists=True, file_okay=False), help='The directory to create relative paths from.') @option( '--out-file', '-o', type=File(mode='w'), default=None, help='A file for saving the printed filenames for easy future reference.') @option('--show-urls', '-u', default=False, is_flag=True, help='Also show the original URL of each sample.') def main(in_directory, base_dir, out_file, show_urls): """ Recursively list paths of HTML files in IN_DIRECTORY relative to BASE_DIR, one path per line. If BASE_DIR is not specified, paths are relative to IN_DIRECTORY. Optionally saves output to OUT_FILE. This is useful for vectorizing samples using FathomFox. FathomFox expects input filenames copied into a text box with one filename per line and