Beispiel #1
0
    def __init__(self, name, console, w3af, parent=None, **other):
        self._name = name
        self._history = history()

        self._help = HelpContainer()
        self._keysHelp = HelpContainer()
        self._w3af = w3af
        self._handlers = {}
        self._parent = parent
        self._console = console
        self._children = {}
        self._child_call = False

        self._load_help('common')
        helpMainRepository.load_help('keys', self._keysHelp)

        self._initHandlers()
Beispiel #2
0
    def __init__(self, name, console, w3af, parent=None, **other):
        self._name = name
        self._history = history()

        self._help = HelpContainer()
        self._keysHelp = HelpContainer()
        self._w3af = w3af
        self._handlers = {}
        self._parent = parent
        self._console = console
        self._children = {}
        self._child_call = False
        
        self._load_help('common')
        helpMainRepository.load_help('keys', self._keysHelp)
#        self._keysHelp = {}

        self._initHandlers()
Beispiel #3
0
class menu(object):
    """
    Menu objects handle the commands and completion requests.
    Menus form an hierarchy and are able to delegate requests to their children.
    
    :author: Alexander Berezhnoy (alexander.berezhnoy |at| gmail.com)
    """
    def __init__(self, name, console, w3af, parent=None, **other):
        self._name = name
        self._history = history()

        self._help = HelpContainer()
        self._keysHelp = HelpContainer()
        self._w3af = w3af
        self._handlers = {}
        self._parent = parent
        self._console = console
        self._children = {}
        self._child_call = False
        
        self._load_help('common')
        helpMainRepository.load_help('keys', self._keysHelp)
#        self._keysHelp = {}

        self._initHandlers()

#            if cmd not in helpTab:
                # highlight undocumented items
#                self._help.add_help_entry(cmd, 'UNDOCUMENTED', 'menu')

    def suggest(self, tokens, part, onlyLocalCommands=False):
        """
        Suggest the possible completions
        :param tokens: list of string
        :param part: base for completion
        """
        if len(tokens) == 0:
            return self.suggest_commands(part, onlyLocalCommands)
        return self.suggest_params(tokens[0], tokens[1:], part)

    def is_raw(self=None):
        return False

    def get_path(self):
        if self._parent is None:
            return self._name
        else:
            return self._parent.get_path() + '/' + self._name

    def get_history(self):
        return self._history

    def _initHandlers(self):
        self._universalCommands = ['back', 'exit', 'keys', 'print']

        self._paramHandlers = {}
        for cmd in [c for c in dir(self) if c.startswith('_cmd_')]:
            self._handlers[cmd[5:]] = getattr(self, cmd)

        for cmd in self._handlers.keys():
            try:
                pHandler = getattr(self, '_para_' + cmd)
                self._paramHandlers[cmd] = pHandler
            except:
                pass

    def _load_help(self, name, vars=None):
        helpMainRepository.load_help(name, self._help, vars)
#        self._help = load_help(name, self._help, vars)

    def addChild(self, name, constructor):
        if type(constructor) in (tuple, list):
            constructor, params = constructor[0], constructor[1:]
        else:
            params = []

        self._children[name] = constructor(
            name, self._console, self._w3af, self, *params)

    def suggest_commands(self, part='', onlyLocal=False):

        first, rest = splitPath(part)

        if rest is None:
            # the command must be in the current menu
            result = suggest(self.get_commands(onlyLocal), part)
            if self.get_children() is not None:
                result += suggest(self.get_children(), part)
            return result
        else:
            try:
                # delegate to the children
                subMenu = self.get_children()[first]
                return subMenu.suggest_commands(rest, True)
            except:
                return []

    def suggest_params(self, command, params, part):
        if command in self._paramHandlers:
            return self._paramHandlers[command](params, part)

        children = self.get_children()
        if command in children:
            child = children[command]
            return child.suggest(params, part, True)

    def get_commands(self, onlyLocal=False):
        """
        By default, commands are defined by methods _cmd_<command>.
        """
        cmds = self._handlers.keys()

        if onlyLocal:
            cmds = [c for c in cmds if c not in self._universalCommands]

        return cmds

    def get_children(self):
        return self._children

    def get_handler(self, command):
        try:
            return self._handlers[command]
        except:
            return None

    def set_child_call(self, true_false):
        """
        This will set _child_call to True for handling the "set" command:
            w3af>>> target set target http://w3af.org/
        
        While this won't ever set it to true:
            w3af>>> target
            w3af/config:target>>> set target http://w3af.org/
        """
        self._child_call = true_false

    def execute(self, tokens):

        if len(tokens) == 0:
            return self

        command, params = tokens[0], tokens[1:]
        handler = self.get_handler(command)
        if handler:
            return handler(params)

        children = self.get_children()
        if command in children:
            child = children[command]
            child.set_child_call(True)
            try:
                return child.execute(params)
            finally:
                child.set_child_call(False)

        raise BaseFrameworkException("Unknown command '%s'" % command)

    def _cmd_back(self, tokens):
        return self._console.back

    def _cmd_exit(self, tokens):
        return self._console.exit

    def _cmd_help(self, params, brief=False):
        if len(params) == 0:
            table = self._help.get_plain_help_table(True)
            self._console.draw_table(table)
        else:
            subj = params[0]
            short, full = self._help.get_help(subj)
            if short is None:
                raise BaseFrameworkException("No help for '%s'" % subj)

            om.out.console(short)
            if full:
                om.out.console(full)

    def _cmd_keys(self, params=None):
        table = self._keysHelp.get_plain_help_table(True)
        self._console.draw_table(table)

    def _cmd_print(self, params):
        if not len(params):
            raise BaseFrameworkException('Variable is expected')

        small_locals = {'kb': kb, 'w3af_core': self._w3af}
        small_globals = {}

        evalVariable = ' '.join(params)
        try:
            res = eval(evalVariable, small_globals, small_locals)
        except:
            om.out.console('Unknown variable.')
        else:
            pp = pprint.PrettyPrinter(indent=4)
            output = pp.pformat(res)
            om.out.console(output)

    def _para_help(self, params, part):
        if len(params) == 0:
            return suggest(self._help.get_items(), part)
        else:
            return []

    def join(self):
        """
        This is a abstract method to emulate the join
        method on a thread, by default DO NOTHING
        """
        pass