def main(unused_args): # Allow per platform configuration. config.CONFIG.AddContext( contexts.CLIENT_CONTEXT, "Context applied when we run the client process.") client_startup.ClientInit() if flags.FLAGS.install: installer.RunInstaller() errors = config.CONFIG.Validate(["Client", "CA", "Logging"]) if errors and list(iterkeys(errors.keys)) != ["Client.private_key"]: raise config_lib.ConfigFormatError(errors) if config.CONFIG["Client.fleetspeak_enabled"]: raise ValueError( "This is not a Fleetspeak client, yet 'Client.fleetspeak_enabled' is " "set to 'True'.") enrollment_necessary = not config.CONFIG.Get("Client.private_key") # Instantiating the client will create a private_key so we need to use a flag. client = comms.GRRHTTPClient(ca_cert=config.CONFIG["CA.certificate"], private_key=config.CONFIG.Get( "Client.private_key", default=None)) if enrollment_necessary: logging.info("No private key found, starting enrollment.") client.InitiateEnrolment() if flags.FLAGS.break_on_start: pdb.set_trace() else: client.Run()
def main(unused_args): client_plugins.RegisterPlugins() if flags.FLAGS.remote_debugging_port: _start_remote_debugging(flags.FLAGS.remote_debugging_port) elif flags.FLAGS.break_on_start: pdb.set_trace() if (flags.FLAGS.unprivileged_server_pipe_input != -1 and flags.FLAGS.unprivileged_server_pipe_output != -1 and flags.FLAGS.unprivileged_server_interface): communication.Main( communication.Channel.FromSerialized( pipe_input=flags.FLAGS.unprivileged_server_pipe_input, pipe_output=flags.FLAGS.unprivileged_server_pipe_output), interface_registry.GetConnectionHandlerForInterfaceString( flags.FLAGS.unprivileged_server_interface), flags.FLAGS.unprivileged_user, flags.FLAGS.unprivileged_group) return # Allow per platform configuration. config.CONFIG.AddContext( contexts.CLIENT_CONTEXT, "Context applied when we run the client process.") client_startup.ClientInit() if flags.FLAGS.install: installer.RunInstaller() sys.exit(0) if config.CONFIG["Client.fleetspeak_enabled"]: fleetspeak_client.GRRFleetspeakClient().Run() return errors = config.CONFIG.Validate(["Client", "CA", "Logging"]) if errors and list(errors.keys()) != ["Client.private_key"]: raise config_lib.ConfigFormatError(errors) if config.CONFIG["Client.fleetspeak_enabled"]: raise ValueError( "This is not a Fleetspeak client, yet 'Client.fleetspeak_enabled' is " "set to 'True'.") enrollment_necessary = not config.CONFIG.Get("Client.private_key") # Instantiating the client will create a private_key so we need to use a flag. client = comms.GRRHTTPClient(ca_cert=config.CONFIG["CA.certificate"], private_key=config.CONFIG.Get( "Client.private_key", default=None)) if enrollment_necessary: logging.info("No private key found, starting enrollment.") client.InitiateEnrolment() client.Run()
def main(unused_args): client_plugins.RegisterPlugins() if flags.FLAGS.remote_debugging_port: _start_remote_debugging(flags.FLAGS.remote_debugging_port) elif flags.FLAGS.break_on_start: pdb.set_trace() # Allow per platform configuration. config.CONFIG.AddContext( contexts.CLIENT_CONTEXT, "Context applied when we run the client process.") client_startup.ClientInit() if flags.FLAGS.install: installer.RunInstaller() sys.exit(0) is_pyinstaller_binary = getattr(sys, "frozen", False) if is_pyinstaller_binary and platform.system() == "Windows": # Since `Client.install_path` is shared with the Sandbox, Sandbox # initialization makes only sense if we run from a proper installation. # This is the case if this is a PyInstaller binary. sandbox.InitSandbox( "{}_{}".format(config.CONFIG["Client.name"], config.CONFIG["Source.version_string"]), [config.CONFIG["Client.install_path"]]) if config.CONFIG["Client.fleetspeak_enabled"]: fleetspeak_client.GRRFleetspeakClient().Run() return errors = config.CONFIG.Validate(["Client", "CA", "Logging"]) if errors and list(errors.keys()) != ["Client.private_key"]: raise config_lib.ConfigFormatError(errors) if config.CONFIG["Client.fleetspeak_enabled"]: raise ValueError( "This is not a Fleetspeak client, yet 'Client.fleetspeak_enabled' is " "set to 'True'.") enrollment_necessary = not config.CONFIG.Get("Client.private_key") # Instantiating the client will create a private_key so we need to use a flag. client = comms.GRRHTTPClient(ca_cert=config.CONFIG["CA.certificate"], private_key=config.CONFIG.Get( "Client.private_key", default=None)) if enrollment_necessary: logging.info("No private key found, starting enrollment.") client.InitiateEnrolment() client.Run()
def main(unused_args): config.CONFIG.AddContext( contexts.CLIENT_CONTEXT, "Context applied when we run the client process.") client_startup.ClientInit() if flags.FLAGS.install: installer.RunInstaller() if flags.FLAGS.break_on_start: pdb.set_trace() else: fleetspeak_client.GRRFleetspeakClient().Run()
def main(argv): del argv # Unused. config.CONFIG.AddContext(contexts.POOL_CLIENT_CONTEXT, "Context applied when we run the pool client.") client_startup.ClientInit() config.CONFIG.SetWriteBack("/dev/null") CheckLocation() # Let the OS handler also handle sleuthkit requests since sleuthkit is not # thread safe. vfs.VFS_HANDLERS[_UseOSForTSKFile.supported_pathtype] = _UseOSForTSKFile CreateClientPool(flags.FLAGS.nrclients)
def main(unused_args): if flags.FLAGS.remote_debugging_port: _start_remote_debugging(flags.FLAGS.remote_debugging_port) elif flags.FLAGS.break_on_start: pdb.set_trace() if flags.FLAGS.filesystem_server_socket != -1: communication.Main(flags.FLAGS.filesystem_server_socket, server_lib.Dispatch) return # Allow per platform configuration. config.CONFIG.AddContext(contexts.CLIENT_CONTEXT, "Context applied when we run the client process.") client_startup.ClientInit() if flags.FLAGS.install: installer.RunInstaller() sys.exit(0) if config.CONFIG["Client.fleetspeak_enabled"]: fleetspeak_client.GRRFleetspeakClient().Run() return errors = config.CONFIG.Validate(["Client", "CA", "Logging"]) if errors and list(errors.keys()) != ["Client.private_key"]: raise config_lib.ConfigFormatError(errors) if config.CONFIG["Client.fleetspeak_enabled"]: raise ValueError( "This is not a Fleetspeak client, yet 'Client.fleetspeak_enabled' is " "set to 'True'.") enrollment_necessary = not config.CONFIG.Get("Client.private_key") # Instantiating the client will create a private_key so we need to use a flag. client = comms.GRRHTTPClient( ca_cert=config.CONFIG["CA.certificate"], private_key=config.CONFIG.Get("Client.private_key", default=None)) if enrollment_necessary: logging.info("No private key found, starting enrollment.") client.InitiateEnrolment() client.Run()
def main(argv): del argv # Unused. config.CONFIG.AddContext(contexts.POOL_CLIENT_CONTEXT, "Context applied when we run the pool client.") client_startup.ClientInit() config.CONFIG.SetWriteBack("/dev/null") CheckLocation() # Let the OS handler also handle sleuthkit requests since sleuthkit is not # thread safe. tsk = rdf_paths.PathSpec.PathType.TSK os = rdf_paths.PathSpec.PathType.OS vfs.VFS_HANDLERS[tsk] = vfs.VFS_HANDLERS[os] CreateClientPool(flags.FLAGS.nrclients)
def main(unused_args): config.CONFIG.AddContext(contexts.CLIENT_CONTEXT, "Context applied when we run the client process.") client_startup.ClientInit() if flags.FLAGS.install: installer.RunInstaller() if not config.CONFIG["Client.fleetspeak_enabled"]: raise ValueError( "This is a Fleetspeak client, yet 'Client.fleetspeak_enabled' is " "'False'.") if flags.FLAGS.break_on_start: pdb.set_trace() else: fleetspeak_client.GRRFleetspeakClient().Run()
def main(args): """Launch the appropriate builder.""" grr_config.CONFIG.AddContext(contexts.CLIENT_BUILD_CONTEXT) if args.subparser_name == "generate_client_config": # We don't need a full init to just build a config. GetClientConfig(args.client_config_output) return # We deliberately use args.context because client_startup.py pollutes # grr_config.CONFIG.context with the running system context. context = FLAGS.context context.append(contexts.CLIENT_BUILD_CONTEXT) client_startup.ClientInit() # Use basic console output logging so we can see what is happening. logger = logging.getLogger() handler = logging.StreamHandler() handler.setLevel(logging.INFO) logger.handlers = [handler] if args.subparser_name == "build": if grr_config.CONFIG.Get("ClientBuilder.fleetspeak_enabled"): if "Target:Darwin" in context: if not args.fleetspeak_service_config: raise RuntimeError( "--fleetspeak_service_config must be provided.") if not grr_config.CONFIG.Get("ClientBuilder.install_dir"): raise RuntimeError( "ClientBuilder.install_dir must be set.") if not grr_config.CONFIG.Get( "ClientBuilder.fleetspeak_plist_path"): raise RuntimeError( "ClientBuilder.fleetspeak_plist_path must be set.") grr_config.CONFIG.Set("ClientBuilder.client_path", "grr_response_client.grr_fs_client") TemplateBuilder().BuildTemplate( context=context, output=args.output, fleetspeak_service_config=args.fleetspeak_service_config) elif args.subparser_name == "repack": if args.debug_build: context.append("DebugClientBuild Context") result_path = repacking.TemplateRepacker().RepackTemplate( args.template, args.output_dir, context=context, sign=args.sign, signed_template=args.signed_template) if not result_path: raise ErrorDuringRepacking(" ".join(sys.argv[:])) elif args.subparser_name == "repack_multiple": # Resolve globs manually on Windows. templates = [] for template in args.templates: if "*" in template: templates.extend(glob.glob(template)) else: # This could go through glob but then we'd swallow errors for # non existing files. templates.append(template) repack_configs = [] for repack_config in args.repack_configs: if "*" in repack_config: repack_configs.extend(glob.glob(repack_config)) else: # This could go through glob but then we'd swallow errors for # non existing files. repack_configs.append(repack_config) MultiTemplateRepacker().RepackTemplates( repack_configs, templates, args.output_dir, config=FLAGS.config, sign=args.sign, signed_template=args.signed_template) elif args.subparser_name == "sign_template": repacking.TemplateRepacker().SignTemplate(args.template, args.output_file, context=context) if not os.path.exists(args.output_file): raise RuntimeError("Signing failed: output not written")