Merge pull request #57 from bytebutcher/develop

Custom Code Script

Author: bytebutcher

README.md

@@ -6,27 +6,27 @@
 
 # Decoder++
 
-An extensible application for penetration testers and software developers to decode/encode data into various formats.
+Decoder++ is an extensible application designed for penetration testers, software developers, 
+and anyone in between looking to effortlessly decode and encode data across various formats. 
+It includes a wide range of preinstalled scripts and codecs, smart decoding and format identification, 
+and supports both graphical user interface (GUI) and command-line interface (CLI) operations.
 
-## Setup
+## Quick Start
 
-To install ```Decoder++``` simply use ```pip```:
+Get up and running with Decoder++ in just a few steps:
 
 ```bash
 # Install using pip (latest:qt6)
 pip3 install decoder-plus-plus[qt6]
 
-# Install using pip (backport:qt5)
+# Or, for a qt5 backport:
 pip3 install decoder-plus-plus[qt5]
-```
 
-Note, that this will install ```Decoder++``` and the most common plugins.
-In order to install and use all available plugins the package ```decoder-plus-plus[extras]``` needs to be installed:
-```
+# To leverage all features and plugins:
 pip3 install decoder-plus-plus[extras]
 ```
 
-Please refer to the [Installation Guide](docs/INSTALL.md) for more information regarding individual setups. 
+For a detailed installation guide, including platform-specific instructions, see the [Installation Guide](docs/INSTALL.md).
 
 ## Overview
 
@@ -55,26 +55,32 @@ $ dpp -e base64 -h sha1 "Hello, world!"
 e52d74c6d046c390345ae4343406b99587f2af0d
 ```
 
-### Features
-
-* User Interfaces:
-    * Graphical User Interface
-    * Command Line Interface
-* Preinstalled Scripts and Codecs:
-    * **Encode/Decode:** Base16, Base32, Base45, Base64, Base64 (URL-safe), Binary, Gzip, Hex, Html, JWT, HTTP64, Octal, Url, Url+, Zlib
-    * **Hashing:** Adler-32, Apache-Md5, CRC32, FreeBSD-NT, Keccak224, Keccak256, Keccak384, Keccak512, LM, Md2, Md4,
-        Md5, NT, PHPass, RipeMd160, Sha1, Sha3 224, Sha3 256, Sha3 384, Sha3 512, Sha224, Sha256, Sha348, Sha512,
-        Sun Md5
-    * **Scripts:** CSS-Minify, Caesar, Extract URLs, Filter-Lines, Identify File Format, Identify Hash Format, JS-Beautifier, JS-to-XML, JQ, JSONify, JSONPath, HTML-Beautifier, Little/Big-Endian Transform, Reformat Text, Remove Newlines, Remove Whitespaces, Search and Replace, Split and Rejoin, Unescape/Escape String, XPath
-* Format-Identification
-* Smart-Decode
-* Plugin System
-* Load & Save Current Session
-* Supported Platforms:
-    * Windows
-    * Linux
-    * MAC
+### Codecs and Scripts
+
+```Decoder++``` allows you to choose from a variety of codecs and scripts:
+
+* **Encode/Decode:**
+  - Base16, Base32, Base45, Base64, Base64 (URL-safe)
+  - Binary, Gzip, Hex, Html, JWT, HTTP64
+  - Octal, Url, Url+, Zlib
+* **Hashing:** 
+  - Adler-32, Apache-Md5, CRC32, FreeBSD-NT
+  - Keccak224, Keccak256, Keccak384, Keccak512
+  - LM, Md2, Md4, Md5, NT, PHPass
+  - RipeMd160, Sha1, Sha3 224, Sha3 256, Sha3 384, Sha3 512
+  - Sha224, Sha256, Sha348, Sha512, Sun Md5
+* **Scripts:**
+  - Caesar, CSS-Minify, Custom Code, Extract URLs, Filter-Lines
+  - Identify File Format, Identify Hash Format, JS-Beautifier, JS-to-XML, JQ
+  - JSONify, JSONPath, HTML-Beautifier
+  - Little/Big-Endian Transform, Reformat Text, Remove Newlines, Remove Whitespaces
+  - Search and Replace, Split and Rejoin, Unescape/Escape String, XPath
+
+
+In cases where you require a bit more flexibility ```Decoder++``` allows you to process your data with 
+custom scripts by using the ```Custom Code``` script:
 
+![Decoder++ Screenshot](https://raw.githubusercontent.com/bytebutcher/decoder-plus-plus/master/images/dpp-custom-code-script.png)
 
 ## Advanced Usage
 

data/dpp.png

@@ -2,43 +2,46 @@
 
 The following sections provide information about how Decoder++ can be installed on various Systems.
 
-## Ubuntu
+## via pip (Ubuntu)
 
 ### Qt6
 ```bash
 apt-get update
-apt-get install -y python3 python3-pip git \
+apt-get install -y python3 python3-pip \
   libqt6core6 libqt6network6 libqt6openglwidgets6 libqt6widgets6 qt6-qpa-plugins \
   libgl1 libxcb-xinerama0
-git clone https://github.com/bytebutcher/decoder-plus-plus/
-cd decoder-plus-plus
-pip3 install --upgrade pip && pip3 install decoder-plus-plus[qt6] decoder-plus-plus[extras]
+pip3 install decoder-plus-plus[qt6]
 ```
 
 ### Qt5
+
 ```bash
 apt-get update
-apt-get install -y python3 python3-pip git qt5-default libgl1 libxcb-xinerama0
-git clone https://github.com/bytebutcher/decoder-plus-plus/
-cd decoder-plus-plus
-pip3 install --upgrade pip && pip3 install decoder-plus-plus[qt5]  decoder-plus-plus[extras]
+apt-get install -y python3 python3-pip qt5-default libgl1 libxcb-xinerama0
+pip3 install decoder-plus-plus[qt5]
 ```
 
-## Git
+## via git (Ubuntu)
 
 ### Qt6
 ```bash
-git clone https://github.com/bytebutcher/decoder-plus-plus
-pip3 install decoder-plus-plus/.[qt6] decoder-plus-plus/.[extras]
+apt-get update
+apt-get install -y python3 python3-pip git \
+  libqt6core6 libqt6network6 libqt6openglwidgets6 libqt6widgets6 qt6-qpa-plugins \
+  libgl1 libxcb-xinerama0
+git clone https://github.com/bytebutcher/decoder-plus-plus/
+pip3 install --upgrade pip && pip3 install ./decoder-plus-plus[qt6] ./decoder-plus-plus[extras]
 ```
 
 ### Qt5
 ```bash
-git clone https://github.com/bytebutcher/decoder-plus-plus
-pip3 install decoder-plus-plus/.[qt5] decoder-plus-plus/.[extras]
+apt-get update
+apt-get install -y python3 python3-pip git qt5-default libgl1 libxcb-xinerama0
+git clone https://github.com/bytebutcher/decoder-plus-plus/
+pip3 install --upgrade pip && pip3 install ./decoder-plus-plus[qt5] ./decoder-plus-plus[extras]
 ```
 
-## Docker container
+## via Docker
 
 ### Qt6
 ```bash

docs/INSTALL.md

@@ -16,7 +16,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 __name__ = 'decoder-plus-plus'
-__version__ = '1.5.0'
+__version__ = '1.6.0'
 __author__ = 'bytebutcher'
 
 import os

docs/plugin-config-class-overview.drawio

@@ -67,7 +67,7 @@ class Shortcut:
         TAB_CLOSE = "tab_close"
         TAB_SELECT_ = "tab_select_{}"
         TAB_SELECT_1 = "tab_select_1"
-        TAB_SELECT_2= "tab_select_2"
+        TAB_SELECT_2 = "tab_select_2"
         TAB_SELECT_3 = "tab_select_3"
         TAB_SELECT_4 = "tab_select_4"
         TAB_SELECT_5 = "tab_select_5"
@@ -92,14 +92,13 @@ class Shortcut:
         SHOW_KEYBOARD_SHORTCUTS = "show_keyboard_shortcuts"
         SHOW_ABOUT = "show_about"
 
-    def __init__(self, app_id, app_path, namespace):
+    def __init__(self, app_id, app_path):
         super(__class__, self).__init__()
         self._app_id = app_id
         self._app_path = app_path
-        self._namespace = namespace
         self._trace_mode = False
         self._debug_mode = self.config.isDebugModeEnabled()
-        self._logger = logger.init_logger(self.getLogLevel())
+        self._logger = logger.getLogger(name='dpp', level=self.getLogLevel())
         self._listener = Listener(self)
         self._plugins = None
         self._shortcuts = {}
@@ -117,7 +116,7 @@ def config(self):
     @property
     def logger(self) -> logging.Logger:
         """ Returns the standard logger for this application. """
-        return logging.getLogger()
+        return self._logger
 
     def getAppName(self) -> str:
         """ Returns the name of the application. """
@@ -157,15 +156,15 @@ def setDebugMode(self, status: bool, temporary=False):
             self.config.setDebugMode(status)
         self._debug_mode = status
         self._trace_mode = False
-        logger.set_level(logging.DEBUG if status else logging.INFO)
+        self._logger.setLevel(logging.DEBUG if status else logging.INFO)
         status_string = "enabled" if status else "disabled"
         self._logger.info("Debug Mode: {} {}".format(status_string, " (temporary) " if temporary else ""))
 
     def setTraceMode(self, status: bool):
         """ Enables/Disables debug mode. """
         self._trace_mode = status
         self._debug_mode = False
-        logger.set_level(logging.TRACE if status else logging.INFO)
+        self._logger.setLevel(logging.TRACE if status else logging.INFO)
         status_string = 'enabled' if status else 'disabled'
         self._logger.info(f'Trace Mode: {status_string}')
 
@@ -261,10 +260,6 @@ def getShortcutById(self, id: str):
     def getPluginByName(self, name: str, type: str) -> AbstractPlugin:
         return self.plugins().plugin(name, type)
 
-    def saveAsFile(self, filename: str, content: str):
-        with open(filename, "w") as f:
-            f.write(content)
-
     def __deepcopy__(self, memo):
         """ There shall be only one. """
         return self

docs/plugin-config-class-overview.png

@@ -22,7 +22,7 @@
 
 from dpp import app_path
 
-logger = logging.getLogger()
+logger = logging.getLogger(__name__)
 
 
 class Icon:

dpp/__init__.py

@@ -67,7 +67,7 @@ class Listener:
     selectedFrameChanged = Signal(str, str, str)  # tab_id, frame_id, input_text
 
     # Signals that the text inside the codec frame changed (e.g. to update the hex view)
-    textChanged = Signal(str, str, str, bool)  # tab_id, frame_id, input_text, interactive
+    textChanged = Signal(str, str, str)  # tab_id, frame_id, input_text
 
     # Signals that the text selection inside the codec frame changed (e.g. to update the hex view)
     textSelectionChanged = Signal(str, str, str)  # tab_id, frame_id, input_text
@@ -83,8 +83,8 @@ def __init__(self, context: 'core.context.Context'):
         self.selectedFrameChanged.connect(lambda tab_id, frame_id, input_text:
                                           context.logger.trace(
                                               "selectedFrameChanged({}, {}, {})".format(tab_id, frame_id, input_text)))
-        self.textChanged.connect(lambda tab_id, frame_id, input_text, interactive:
-            context.logger.trace("textChanged({}, {}, {}, {})".format(tab_id, frame_id, input_text, interactive)))
+        self.textChanged.connect(lambda tab_id, frame_id, input_text:
+            context.logger.trace("textChanged({}, {}, {})".format(tab_id, frame_id, input_text)))
         self.textSelectionChanged.connect(lambda tab_id, frame_id, input_text:
             context.logger.trace("textSelectionChanged({}, {}, {})".format(tab_id, frame_id, input_text)))
         self.textSubmitted.connect(lambda tab_id, frame_id, input_text:

dpp/core/context.py

@@ -16,45 +16,105 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import logging
 import sys
-from functools import partial
-from typing import Callable
 
-logging.TRACE = logging.DEBUG - 5
 
-console_logger = None
+level_trace = logging.DEBUG - 5
+
+
+def logmethod(name=None, level=level_trace, prefix_callback=None):
+    """ Decorator for logging method calls. """
+    if not name:
+        name = __name__
+    def decorator(method):
+        def wrapper(self, *args, **kwargs):
+            prefix = ''
+            if prefix_callback:
+                prefix = prefix_callback(self)
+            logging.getLogger(name=name).log(
+                level=level,
+                msg=f'{prefix}{method.__name__}({args, kwargs})'
+            )
+            #print(f'{level}: {logger_message}')
+            result = method(self, *args, **kwargs)
+            if result is not None:
+                logging.getLogger(name=name).log(
+                    level=level,
+                    msg=f'{prefix}{method.__name__}({args, kwargs}) returns {result}'
+                )
+            return result
+
+        return wrapper
+
+    return decorator
 
 
 def _get_log_format(level: int) -> str:
     """ Returns the log format for the specified log level. """
-    if level == logging.DEBUG or level == logging.TRACE:
+    if level == logging.DEBUG or level == level_trace:
         return f'%(asctime)s: %(levelname)7s: %(filename)s:%(lineno)s:%(funcName)s: %(msg)s'
     else:
         return f'%(asctime)s: %(levelname)7s: %(msg)s'
 
 
-def _init_log_trace(logger: logging.Logger) -> Callable:
-    """ Add custom log level TRACE. Do not define if it already exists. """
-    if logging.getLevelName(logging.TRACE) == f'Level {logging.TRACE}':
-        logging.addLevelName(logging.TRACE, 'TRACE')
-    return lambda msg, *args, **kwargs: logger.log(logging.TRACE, msg, *args, **kwargs)
+def addLoggingLevel(levelName, levelNum, methodName=None):
+    """
+    Comprehensively adds a new logging level to the `logging` module and the
+    currently configured logging class.
+
+    `levelName` becomes an attribute of the `logging` module with the value
+    `levelNum`. `methodName` becomes a convenience method for both `logging`
+    itself and the class returned by `logging.getLoggerClass()` (usually just
+    `logging.Logger`). If `methodName` is not specified, `levelName.lower()` is
+    used.
+
+    To avoid accidental clobberings of existing attributes, this method will
+    raise an `AttributeError` if the level name is already an attribute of the
+    `logging` module or if the method name is already present
+
+    Example
+    -------
+    >>> addLoggingLevel('TRACE', logging.DEBUG - 5)
+    >>> logging.getLogger(__name__).setLevel("TRACE")
+    >>> logging.getLogger(__name__).trace('that worked')
+    >>> logging.trace('so did this')
+    >>> logging.TRACE
+    5
+
+    """
+    if not methodName:
+        methodName = levelName.lower()
 
+    if hasattr(logging, levelName):
+        raise AttributeError('{} already defined in logging module'.format(levelName))
+    if hasattr(logging, methodName):
+        raise AttributeError('{} already defined in logging module'.format(methodName))
+    if hasattr(logging.getLoggerClass(), methodName):
+        raise AttributeError('{} already defined in logger class'.format(methodName))
 
-def init_logger(level: int) -> logging.Logger:
+    # This method was inspired by the answers to Stack Overflow post
+    # http://stackoverflow.com/q/2183233/2988730, especially
+    # http://stackoverflow.com/a/13638084/2988730
+    def logForLevel(self, msg, *args, **kwargs):
+        if self.isEnabledFor(levelNum):
+            self._log(levelNum, msg, args, **kwargs)
+    def logToRoot(msg, *args, **kwargs):
+        logging.log(levelNum, msg, *args, **kwargs)
+
+    logging.addLevelName(levelNum, levelName)
+    setattr(logging, levelName, levelNum)
+    setattr(logging.getLoggerClass(), methodName, logForLevel)
+    setattr(logging, methodName, logToRoot)
+
+
+def getLogger(name: str, level: int) -> logging.Logger:
     """ Initializes a logging.Logger with the specified level. """
-    logger = logging.getLogger()
+    logger = logging.getLogger(name)
     logger.setLevel(level)
-    logger.trace = _init_log_trace(logger)
-
-    global console_logger
+    try:
+        addLoggingLevel('TRACE', level_trace)
+    except AttributeError as err:
+        logger.debug(f'Failed to add TRACE logging level: {err}')
     console_logger = logging.StreamHandler(sys.stderr)
     console_logger.setFormatter(logging.Formatter(_get_log_format(level)))
     logger.addHandler(console_logger)
     return logger
-
-
-def set_level(level: int):
-    """ Sets the specified level for the standard logger. """
-    logger = logging.getLogger()
-    logger.setLevel(level)
-    global console_logger
-    console_logger.setFormatter(logging.Formatter(_get_log_format(level)))