engine: add support for Kalidroid (--kalidroid) miniterminal's

Author: kimocoder

wifite/args.py

@@ -14,6 +14,11 @@ def __init__(self, configuration):
         # Hack: Check for -v before parsing args;
         # so we know which commands to display.
         self.verbose = '-v' in sys.argv or '-hv' in sys.argv or '-vh' in sys.argv
+        # Activate Kalidroid MiniTerminal output mode as early as possible (before
+        # any option-echo prints) so the whole run streams scrollback-friendly
+        # output to the Kalidroid app's MiniTerminal.
+        if '--kalidroid' in sys.argv:
+            Color.kalidroid = True
         self.config = configuration
         self.args = self.get_arguments()
 
@@ -270,6 +275,15 @@ def _add_global_args(self, glob):
                           help=self._verbose(
                               'Write debug log to {C}[path]{W} (implies {C}-vv{W} minimum verbosity)'))
 
+        glob.add_argument('--kalidroid',
+                          action='store_true',
+                          default=False,
+                          dest='kalidroid',
+                          help=self._verbose(
+                              'Emit {C}MiniTerminal{W}-friendly output for the {C}Kalidroid{W} app: '
+                              'flatten carriage-return progress redraws into discrete lines and '
+                              'skip clear-line escapes (default: {G}off{W})'))
+
         glob.add_argument('-i',
                           action='store',
                           dest='interface',

wifite/config/__init__.py

@@ -21,6 +21,7 @@ class Configuration:
 
     initialized = False  # Flag indicating config has been initialized
     verbose = 0
+    kalidroid = False  # --kalidroid: MiniTerminal-friendly output for the Kalidroid app
     version = _get_version()
 
     all_bands = None

wifite/config/parsers/settings.py

@@ -11,6 +11,11 @@
 def parse_settings_args(cls, args):
     """Parses basic settings/configurations from arguments."""
 
+    if getattr(args, 'kalidroid', False):
+        cls.kalidroid = True
+        Color.kalidroid = True  # already set early in Arguments.__init__; keep in sync
+        Color.pl('{+} {C}option:{W} {G}Kalidroid MiniTerminal{W} output mode enabled')
+
     if args.random_mac or args.random_mac_vendor:
         if args.random_mac and args.random_mac_vendor:
             Color.pl('{!} {O}Warning: Cannot use both --random-mac and --random-mac-vendor')

wifite/util/color.py

@@ -29,13 +29,29 @@ class Color:
 
     last_sameline_length = 0
 
+    # ── Kalidroid MiniTerminal mode ───────────────────────────────────────────
+    # The Kalidroid Android app streams wifite's stdout into a MiniTerminal: an
+    # append-only scrollback view, NOT a terminal emulator. Carriage-return
+    # redraws (the live attack progress lines) and clear-line escapes therefore
+    # render as overwritten/garbled text. When --kalidroid is set these are
+    # flattened into discrete, newline-terminated lines (throttled so a
+    # per-second timer doesn't flood the view) and the clear-line ops become
+    # no-ops. ANSI colours are kept — the MiniTerminal parses SGR codes.
+    kalidroid = False
+    _kalidroid_last_emit = 0.0
+    _kalidroid_last_line = ''
+    _KALIDROID_MIN_INTERVAL = 0.4  # seconds between same-line progress emits
+
     @staticmethod
     def p(text):
         """
         Prints text using colored format on same line.
         Example:
             Color.p('{R}This text is red. {W} This text is white')
         """
+        if Color.kalidroid:
+            Color._p_kalidroid(text)
+            return
         sys.stdout.write(Color.s(text))
         sys.stdout.flush()
         if '\r' in text:
@@ -44,6 +60,34 @@ def p(text):
         else:
             Color.last_sameline_length += len(text)
 
+    @staticmethod
+    def _p_kalidroid(text):
+        """
+        Same as [p] but for the Kalidroid MiniTerminal: a carriage-return
+        same-line update (e.g. the per-second attack progress line) is emitted
+        as its own newline-terminated line so the append-only scrollback stays
+        readable. Identical consecutive redraws and bursts faster than
+        [_KALIDROID_MIN_INTERVAL] are dropped so timers don't flood the view.
+        Plain text (no '\\r') — including the newline-terminated Color.pl prints
+        — passes through unchanged, so final/result lines are never throttled.
+        """
+        if '\r' not in text:
+            sys.stdout.write(Color.s(text))
+            sys.stdout.flush()
+            return
+        content = text[text.rfind('\r') + 1:].rstrip('\n')
+        if content.strip() == '':
+            return  # bare '\r' / whitespace-only clear carries no information
+        import time
+        now = time.time()
+        if (content == Color._kalidroid_last_line
+                or now - Color._kalidroid_last_emit < Color._KALIDROID_MIN_INTERVAL):
+            return
+        Color._kalidroid_last_emit = now
+        Color._kalidroid_last_line = content
+        sys.stdout.write(Color.s(content) + '\n')
+        sys.stdout.flush()
+
     @staticmethod
     def pl(text):
         """Prints text using colored format with trailing new line."""
@@ -71,13 +115,21 @@ def s(text):
 
     @staticmethod
     def clear_line():
+        # MiniTerminal has no cursor to rewind — the '\r<spaces>\r' erase would
+        # just append blanks. The flattened progress lines stand on their own.
+        if Color.kalidroid:
+            Color.last_sameline_length = 0
+            return
         spaces = ' ' * Color.last_sameline_length
         sys.stdout.write('\r%s\r' % spaces)
         sys.stdout.flush()
         Color.last_sameline_length = 0
 
     @staticmethod
     def clear_entire_line():
+        if Color.kalidroid:
+            Color.last_sameline_length = 0
+            return
         import shutil
         columns = shutil.get_terminal_size(fallback=(80, 24)).columns
         Color.p('\r' + (' ' * columns) + '\r')