def run(self):
self.console.root.interfaces
data = [[
"ESSID", "BSSID", "Channel", "Power", "Enc", "Cipher", "Auth",
"Password", "Stations"
]]
# parse targets from the state variable
for essid, target in sorted(self.console.state['TARGETS'].items(),
key=lambda x: x[0]):
i = self.console.state['INTERFACES']
c = any(x[1] == essid for x in i.values())
rows = []
# for each target, get the value from its associated dictionary
for i, h in enumerate(data[0]):
rows.append([""] * len(data[0]))
v = target[h.lower()]
if isinstance(v, (tuple, list)):
for j in range(len(v) - 1):
rows.append([""] * len(data[0]))
else:
v = [v]
for j, sv in enumerate(v):
sv = sv or ""
if c:
sv = colored(sv, attrs=['bold'])
rows[j][i] = sv
for r in rows:
if all(v == "" for v in r):
continue
data.append(r)
if len(data) > 1:
t = BorderlessTable(data, "Available Targets")
print_formatted_text(ANSI(t.table))
else:
self.logger.warning("No target available yet")
def run(self, key, value=None):
if value is not None:
obj = list(filter(lambda o: str(o) == value, get_objects()))[0]
if key == "graph":
from objgraph import show_refs
if value is None:
p = self.console.parent
show_refs(self.console if p is None else p,
refcounts=True,
max_depth=3)
else:
show_refs(obj, refcounts=True, max_depth=3)
elif key == "growth":
from objgraph import get_leaking_objects, show_most_common_types
show_most_common_types(objects=get_leaking_objects())
elif key == "info":
from psutil import Process
p = Process(os.getpid())
print_formatted_text(p.memory_info())
elif key == "leaking":
from objgraph import get_leaking_objects
print_formatted_text(get_leaking_objects())
elif key == "objects":
data = [["Object", "#References"]]
for o in get_objects():
if isinstance(o, (Console, Module)):
data.append([str(o), str(getrefcount(o))])
t = BorderlessTable(data, "Consoles/Modules")
print_formatted_text(t.table)
elif key == "refs":
if value is not None:
print_formatted_text(getrefcount(obj), ":")
pprint(get_referrers(obj))
def get_help(cls, *levels, **kwargs):
""" Display commands' help(s), using its metaclass' properties. """
if len(levels) == 0:
levels = Command._levels
if len(levels) == 2 and "general" in levels:
# process a new dictionary of commands, handling levels in order
_ = {}
for l in levels:
for n, c in cls.commands.get(l, {}).items():
if c.level != "general" or all(l not in levels
for l in c.except_levels):
_[n] = c
# then rebuild the dictionary by levels from this dictionary
levels = {"general": {}, "specific": {}}
for n, c in _.items():
levels[["specific", "general"][c.level == "general"]][n] = c
else:
_, levels = levels, {}
for l in _:
levels[l] = cls.commands[l]
# now make the help with tables of command name-descriptions by level
s, i = "", 0
for l, cmds in sorted(levels.items(), key=lambda x: x[0]):
if len(cmds) == 0 or l in kwargs.get('except_levels', []):
continue
d = [["Command", "Description"]]
for n, c in sorted(cmds.items(), key=lambda x: x[0]):
if not hasattr(c, "console") or not c.check():
continue
d.append([n, getattr(c, "description", "")])
if len(d) > 1:
t = BorderlessTable(d, "{} commands".format(l.capitalize()))
s += t.table + "\n"
i += 1
return "\n" + s.strip() + "\n" if i > 0 else ""
def run(self):
d = [["Item", "Path", "Size"]]
p = self.console.app_folder
d.append(["APP_FOLDER", str(p), human_readable_size(p.size)])
p = self.workspace
d.append(["WORKSPACE", str(p), human_readable_size(p.size)])
t = BorderlessTable(d, "Statistics")
print_formatted_text(t.table)
def __str__(self):
""" Custom string method. """
data = [["Name", "Value", "Required", "Description"]]
l = len(list(self.items(False)))
for n, d, v, r in sorted(self.items(False), key=lambda x: x[0]):
if v is None and l > 1:
continue
r = ["N", "Y"][r]
if v == "":
n, v, r = map(lambda s: colored(s, "red", attrs=['bold']),
[n, v, r])
data.append([n, v, r, d])
if len(data) == 2:
return BorderlessTable(data).table
elif len(data) > 3:
return BorderlessTable(data,
"{} options".format(self.prefix)).table
return ""
def get_info(cls, *fields, show_all=False):
""" Display entity's metadata and other information.
:param fields: metadata fields to be output
:param show_all: also include unselected fields, to be output behind the list of selected fields
"""
t = ""
if len(fields) == 0:
fields = [("name", "description"),
("author", "email", "version", "comments"),
("options", )]
# make a data table with the given fields and corresponding values
data, __used = [], []
_ = lambda s: s.capitalize() + ":"
for field in fields:
if not isinstance(field, (list, tuple)):
field = (field, )
add_blankline = False
for f in field:
try:
f, alias = f.split("|", 1)
except:
alias = f
__used.append(f)
v = getattr(cls, f, "")
if v is None or len(v) == 0:
continue
elif isinstance(v, (list, tuple)):
data.append([_(alias), v[0]])
for i in v[1:]:
data.append(["", i])
else:
data.append([_(alias), v])
add_blankline = True
if add_blankline:
data.append(["", ""])
t = BorderlessTable(data,
header=False).table + "\n" if len(data) > 0 else ""
# add other metadata if relevant
if show_all:
unused = set(cls._metadata.keys()) - set(__used)
if len(unused) > 0:
t += cls.get_info(*sorted(list(unused)))
return t.rstrip() + "\n"
def run(self, key, value=None):
if key == "files":
if value is None:
data = [["Path", "Size"]]
p = Path(self.config.option("WORKSPACE").value)
for f in self.console._files.list:
data.append([f, human_readable_size(p.joinpath(f).size)])
print_formatted_text(
BorderlessTable(data, "Files from the workspace"))
elif self.config.option("TEXT_VIEWER").value:
self.console._files.view(value)
elif key == "issues":
t = Entity.get_issues()
if len(t) > 0:
print_formatted_text(t)
elif key == "modules":
h = Module.get_help(value)
if h.strip() != "":
print_formatted_text(h)
else:
self.logger.warning("No module loaded")
elif key == "options":
if value is None:
print_formatted_text(ANSI(str(self.config)))
else:
c = Config()
c[self.config.option(value)] = self.config[value]
print_formatted_text(ANSI(str(c)))
elif key == "projects":
if value is None:
data = [["Name"]]
for p in projects(self):
data.append([p])
print_formatted_text(BorderlessTable(data,
"Existing projects"))
else:
print_formatted_text(value)
elif key == "sessions":
data = [["ID", "Description"]]
for i, s in self.console._sessions:
data.append([str(i), getattr(s, "description", "<undefined>")])
print_formatted_text(BorderlessTable(data, "Open sessions"))
def run(self, text):
keywords = shlex.split(text)
data = [["Name", "Path", "Description"]]
for m in Module.subclasses:
for k in keywords:
if m.search(k):
data.append([m.name, m.path, m.description])
if len(data) == 1:
self.logger.error("No match found")
else:
t = BorderlessTable(data, "Matching modules")
print_formatted_text(t.table)
n = len(data) - 2
self.logger.info("{} match{} found".format(n, ["", "es"][n > 0]))
def get_help(cls, category=None):
""" Display command's help, using its metaclass' properties. """
uncat = {}
for c, v in cls.modules.items():
if not isinstance(v, dict):
uncat[c] = v
if category is None:
categories = list(set(cls.modules.keys()) - set(uncat.keys()))
if len(uncat) > 0:
categories += ["uncategorized"]
else:
categories = [category]
s, i = "", 0
for c in categories:
d = [["Name", "Path", "Enabled", "Description"]]
for n, m in sorted((flatten_dict(cls.modules.get(c, {})) if c != "uncategorized" else uncat).items(),
key=lambda x: x[1].name):
e = ["N", "Y"][m.enabled]
d.append([m.name, m.subpath, e, m.description])
t = BorderlessTable(d, "{} modules".format(c.capitalize()))
s += t.table + "\n\n"
i += 1
return "\n" + s.strip() + "\n" if i > 0 else ""