def main(unused_argv):
"""Main."""
token = GetToken()
grr_config.CONFIG.AddContext(contexts.COMMAND_LINE_CONTEXT)
grr_config.CONFIG.AddContext(contexts.CONFIG_UPDATER_CONTEXT)
if flags.FLAGS.subparser_name == "initialize":
config_lib.ParseConfigCommandLine()
if flags.FLAGS.noprompt:
InitializeNoPrompt(grr_config.CONFIG, token=token)
else:
Initialize(grr_config.CONFIG, token=token)
return
server_startup.Init()
try:
print "Using configuration %s" % grr_config.CONFIG
except AttributeError:
raise RuntimeError("No valid config specified.")
if flags.FLAGS.subparser_name == "generate_keys":
try:
GenerateKeys(grr_config.CONFIG,
overwrite_keys=flags.FLAGS.overwrite_keys)
except RuntimeError, e:
# GenerateKeys will raise if keys exist and overwrite_keys is not set.
print "ERROR: %s" % e
sys.exit(1)
grr_config.CONFIG.Write()
def main(unused_argv):
"""Main."""
config_lib.CONFIG.AddContext("Worker Context",
"Context applied when running a worker.")
# Initialise flows
server_startup.Init()
token = access_control.ACLToken(username="******").SetUID()
worker_obj = worker.GRRWorker(token=token)
worker_obj.Run()
def main(unused_argv):
"""Main."""
config_lib.CONFIG.AddContext("HTTPServer Context")
server_startup.Init()
httpd = CreateServer()
server_startup.DropPrivileges()
try:
httpd.serve_forever()
except KeyboardInterrupt:
print "Caught keyboard interrupt, stopping"
def main(unused_argv):
"""Main."""
config_lib.CONFIG.AddContext("Commandline Context",
"Context applied for all command line tools")
config_lib.CONFIG.AddContext("ExportTool Context",
"Context applied to the export tool.")
server_startup.Init()
data_store.default_token = access_control.ACLToken(
username=flags.FLAGS.username or getpass.getuser(),
reason=flags.FLAGS.reason)
# If subcommand was specified by the user in the command line,
# corresponding subparser should have initialized "func" argument
# with a corresponding export plugin's Run() function.
flags.FLAGS.func(flags.FLAGS)
def main(unused_argv):
"""Main."""
config.CONFIG.AddContext(contexts.DATA_SERVER_CONTEXT)
server_startup.Init()
manager = Manager()
if not manager.Start():
print "Failed to start manager"
return
atexit.register(manager.SaveHistory)
try:
manager.Run()
except (EOFError, KeyboardInterrupt):
print
def main(unused_argv):
"""Main."""
server_startup.Init()
filename = flags.FLAGS.filename
if not os.path.exists(filename):
print "File %s does not exist" % filename
return
with aff4.FACTORY.Create(filestore.NSRLFileStore.PATH,
filestore.NSRLFileStore,
mode="rw",
token=aff4.FACTORY.root_token) as store:
imported = ImportFile(store, filename, flags.FLAGS.start)
data_store.DB.Flush()
print "Imported %d hashes" % imported
def main(unused_argv):
"""Main."""
banner = ("\nWelcome to the GRR console\n")
config_lib.CONFIG.AddContext(contexts.COMMAND_LINE_CONTEXT)
config_lib.CONFIG.AddContext(
contexts.CONSOLE_CONTEXT,
"Context applied when running the console binary.")
server_startup.Init()
# To make the console easier to use, we make a default token which will be
# used in StartFlow operations.
data_store.default_token = access_control.ACLToken(
username=getpass.getuser(), reason=flags.FLAGS.reason)
locals_vars = {
"__name__": "GRR Console",
"l": Lister,
"lc": GetChildrenList,
"o": aff4.FACTORY.Open,
# Bring some symbols from other modules into the console's
# namespace.
"StartFlowAndWait": flow_utils.StartFlowAndWait,
"StartFlowAndWorker": debugging.StartFlowAndWorker,
"RunEndToEndTests": end_to_end_tests.RunEndToEndTests,
}
locals_vars.update(globals()) # add global variables to console
if flags.FLAGS.client is not None:
locals_vars["client"], locals_vars["token"] = console_utils.OpenClient(
client_id=flags.FLAGS.client)
if flags.FLAGS.code_to_execute:
logging.info("Running code from flag: %s", flags.FLAGS.code_to_execute)
exec(flags.FLAGS.code_to_execute) # pylint: disable=exec-used
elif flags.FLAGS.command_file:
logging.info("Running code from file: %s", flags.FLAGS.command_file)
execfile(flags.FLAGS.command_file)
if (flags.FLAGS.exit_on_complete
and (flags.FLAGS.code_to_execute or flags.FLAGS.command_file)):
return
else: # We want the normal shell.
locals_vars.update(globals()) # add global variables to console
ipshell.IPShell(argv=[], user_ns=locals_vars, banner=banner)
def AddUsers(token=None):
# Now initialize with our modified config.
server_startup.Init()
print "\nStep 3: Adding Admin User"
try:
maintenance_utils.AddUser("admin",
labels=["admin"],
token=token,
password=flags.FLAGS.admin_password)
except maintenance_utils.UserError:
if flags.FLAGS.noprompt:
maintenance_utils.UpdateUser("admin",
password=flags.FLAGS.admin_password,
add_labels=["admin"],
token=token)
else:
if ((raw_input("User 'admin' already exists, do you want to "
"reset the password? [yN]: ").upper()
or "N") == "Y"):
maintenance_utils.UpdateUser("admin",
password=True,
add_labels=["admin"],
token=token)
def main(unused_argv):
config_lib.CONFIG.AddContext(contexts.COMMAND_LINE_CONTEXT,
"Context applied for all command line tools")
server_startup.Init()
if fuse is None:
logging.critical("""Could not start!
fusepy must be installed to run fuse_mount.py!
Try to run:
pip install fusepy
inside your virtualenv.
""")
sys.exit(1)
if not flags.FLAGS.mountpoint:
Usage()
sys.exit(1)
# We multiple inherit from GRRFuse and fuse.Operations. In the
# case that fuse is present, we run the actual FUSE layer, since we have
# fuse.Operations. In the case that fuse is not present, we have already
# exited by now if we were run from the command line, and if we were not run
# from the command line, we've been imported, and we run the tests using a
# mock fuse.
class FuseOperation(GRRFuse, fuse.Operations):
pass
root = flags.FLAGS.aff4path
username = flags.FLAGS.username or getpass.getuser()
data_store.default_token = access_control.ACLToken(
username=username, reason=flags.FLAGS.reason or "fusemount")
logging.info("fuse_mount.py is mounting %s at %s....", root,
flags.FLAGS.mountpoint)
refresh_policy = flags.FLAGS.refresh_policy
if refresh_policy == "always":
max_age_before_refresh = datetime.timedelta(0)
elif refresh_policy == "never":
# Set the max age to be the maximum possible time difference.
max_age_before_refresh = datetime.timedelta.max
elif refresh_policy == "if_older_than_max_age":
max_age_before_refresh = datetime.timedelta(
seconds=flags.FLAGS.max_age_before_refresh)
else:
# Otherwise, a flag outside the enum was given and the flag validator threw
# an execption.
pass
fuse_operation = FuseOperation(
root=root,
token=data_store.default_token,
max_age_before_refresh=max_age_before_refresh,
ignore_cache=flags.FLAGS.ignore_cache,
force_sparse_image=flags.FLAGS.force_sparse_image,
sparse_image_threshold=flags.FLAGS.sparse_image_threshold,
timeout=flags.FLAGS.timeout)
fuse.FUSE(fuse_operation,
flags.FLAGS.mountpoint,
foreground=not flags.FLAGS.background)
def RunEndToEndTests():
runner = unittest.TextTestRunner()
# We are running a test so let the config system know that.
config_lib.CONFIG.AddContext(contexts.TEST_CONTEXT,
"Context applied when we run tests.")
server_startup.Init()
token = access_control.ACLToken(username="******",
reason="Running end to end client tests.")
# We need this for the launchbinary test
with aff4.FACTORY.Create("aff4:/users/GRREndToEndTest",
aff4_users.GRRUser,
mode="rw",
token=token) as test_user:
test_user.AddLabels("admin")
client_id_set = base.GetClientTestTargets(
client_ids=flags.FLAGS.client_ids,
hostnames=flags.FLAGS.hostnames,
checkin_duration_threshold="1h",
token=token)
for cls in base.ClientTestBase.classes.values():
for p in cls.platforms:
if p not in set(["Linux", "Darwin", "Windows"]):
raise ValueError("Unsupported platform: %s in class %s" %
(p, cls.__name__))
if not client_id_set:
print(
"No clients to test on. Define Test.end_to_end_client* config "
"options, or pass them as parameters.")
results_by_client = {}
for client in aff4.FACTORY.MultiOpen(client_id_set, token=token):
client_summary = client.GetSummary()
if hasattr(client_summary, "system_info"):
sysinfo = client_summary.system_info
else:
raise RuntimeError(
"Unknown system type, likely waiting on interrogate"
" to complete.")
results = {}
results_by_client[client.urn] = results
for cls in base.ClientTestBase.classes.values():
if flags.FLAGS.testnames and (cls.__name__
not in flags.FLAGS.testnames):
continue
if not aff4.issubclass(cls, base.ClientTestBase):
continue
if cls.__name__.startswith("Abstract"):
continue
# Fix the call method so we can use the test runner. See doco in
# base.ClientTestBase
def _RealCall(testcase, *args, **kwds):
return testcase.run(*args, **kwds)
cls.__call__ = _RealCall
if sysinfo.system in cls.platforms:
print "Running %s on %s (%s: %s, %s, %s)" % (
cls.__name__, client_summary.client_id, sysinfo.fqdn,
sysinfo.system, sysinfo.version, sysinfo.machine)
try:
# Mixin the unittest framework so we can use the test runner to run
# the test and get nice output. We don't want to depend on unitttest
# code in the tests themselves.
testcase = cls(client_id=client_summary.client_id,
platform=sysinfo.system,
token=token,
local_client=flags.FLAGS.local_client,
local_worker=flags.FLAGS.local_worker)
results[cls.__name__] = runner.run(testcase)
except Exception: # pylint: disable=broad-except
logging.exception("Failed to run test %s", cls)
# Print a little summary.
for client, results in results_by_client.iteritems():
print "Results for %s:" % client
for testcase, result in sorted(results.items()):
res = "[ OK ]"
if result.errors or result.failures:
res = "[ FAIL ]"
print "%45s: %s" % (testcase, res)
def main(_):
"""Run the main test harness."""
config_lib.CONFIG.AddContext(
contexts.ADMIN_UI_CONTEXT,
"Context applied when running the admin user interface GUI.")
server_startup.Init()
if (not os.path.exists(
os.path.join(config_lib.CONFIG["AdminUI.document_root"],
"dist/grr-ui.bundle.js"))
or not os.path.exists(
os.path.join(config_lib.CONFIG["AdminUI.document_root"],
"dist/grr-ui.bundle.css"))):
raise RuntimeError("Can't find compiled JS/CSS bundles. "
"Please reinstall the PIP package using "
"\"pip install -e .\" to rebuild the bundles.")
# Start up a server in another thread
bind_address = config_lib.CONFIG["AdminUI.bind"]
ip = ipaddr.IPAddress(bind_address)
if ip.version == 4:
# Address looks like an IPv4 address.
ThreadedServer.address_family = socket.AF_INET
max_port = config_lib.CONFIG.Get("AdminUI.port_max",
config_lib.CONFIG["AdminUI.port"])
for port in range(config_lib.CONFIG["AdminUI.port"], max_port + 1):
# Make a simple reference implementation WSGI server
try:
server = simple_server.make_server(
bind_address,
port,
wsgiapp.AdminUIApp().WSGIHandler(),
server_class=ThreadedServer)
break
except socket.error as e:
if e.errno == socket.errno.EADDRINUSE and port < max_port:
logging.info("Port %s in use, trying %s", port, port + 1)
else:
raise
proto = "HTTP"
if config_lib.CONFIG["AdminUI.enable_ssl"]:
cert_file = config_lib.CONFIG["AdminUI.ssl_cert_file"]
if not cert_file:
raise ValueError("Need a valid cert file to enable SSL.")
key_file = config_lib.CONFIG["AdminUI.ssl_key_file"]
server.socket = ssl.wrap_socket(server.socket,
certfile=cert_file,
keyfile=key_file,
server_side=True)
proto = "HTTPS"
# SSL errors are swallowed by the WSGIServer so if your configuration does
# not work, uncomment the line below, point your browser at the gui and look
# at the log file to see why SSL complains:
# server.socket.accept()
sa = server.socket.getsockname()
logging.info("Serving %s on %s port %d ...", proto, sa[0], sa[1])
server_startup.DropPrivileges()
server.serve_forever()
