powershell-pro-obfuscator 1.0.0__py3-none-any.whl

powershellproobfuscator/powershellproobfuscator.py

@@ -0,0 +1,414 @@
+#!/usr/bin/env python
+
+###############################################################################
+#
+# PowerShell Pro Obfuscator is a source code obfuscator for PowerShell scripts.
+# Obfuscate, virtualize and protect your PowerShell .ps1 scripts against
+# analysis, reverse engineering and technology theft.
+#
+# PowerShell Pro Obfuscator provides advanced PowerShell source code parsing
+# based on AST trees, multiple advanced obfuscation, virtualization and
+# protection strategies are available.
+#
+# Version      : Python SDK v1.0.0
+# Python       : Python v3
+# Dependencies : requests (https://pypi.python.org/pypi/requests/)
+# Author       : Bartosz Wójcik (support@pelock.com)
+# Project      : https://www.pelock.com/products/powershell-pro-obfuscator
+# Homepage     : https://www.pelock.com
+#
+###############################################################################
+
+import zlib
+import base64
+
+# required external package - install with "pip install requests"
+import requests
+
+
+class PowerShellProObfuscator(object):
+    """PowerShell Pro Obfuscator module"""
+
+    #
+    # @var string default PowerShell Pro Obfuscator WebApi endpoint
+    #
+    API_URL = "https://www.pelock.com/api/powershell-pro-obfuscator/v1"
+
+    #
+    # @var string WebApi key for the service
+    #
+    _apiKey = ""
+
+    #
+    # @var bool should the source code be compressed
+    #
+    enableCompression = False
+
+    #
+    # @var bool protection against tampering with protected code (integrity verification)
+    #
+    selfDefending = True
+
+    #
+    # @var bool protection linker (decoy call graph)
+    #
+    protectionLinker = True
+
+    #
+    # @var bool rename variable names to random string values
+    #
+    renameVariables = True
+
+    #
+    # @var bool rename parameter names to random string values
+    #
+    renameParameters = True
+
+    #
+    # @var bool rename function names to random string values
+    #
+    renameFunctions = True
+
+    #
+    # @var bool shuffle function order in the output source
+    #
+    shuffleFunctions = True
+
+    #
+    # @var bool change linear code execution flow via control-flow flattening
+    #
+    controlFlowFlatten = True
+
+    #
+    # @var bool rewrite statement blocks into finite-state automata (state-machine obfuscation)
+    #
+    stateMachine = True
+
+    #
+    # @var bool lift selected statements into a VM engine (virtualized statements)
+    #
+    vmStrategy = True
+
+    #
+    # @var bool encrypt integers
+    #
+    encryptIntegers = True
+
+    #
+    # @var bool split strings into concatenated chunks
+    #
+    splitStrings = True
+
+    #
+    # @var bool encrypt strings using randomly generated polymorphic encryption algorithms
+    #
+    encryptStrings = True
+
+    #
+    # @var bool move integers to arrays
+    #
+    integersToArrays = True
+
+    #
+    # @var bool move floats to arrays
+    #
+    floatsToArrays = True
+
+    #
+    # @var bool insert dead code
+    #
+    insertDeadCode = True
+
+    #
+    # @var bool replace boolean conditions with equivalent complex expressions
+    #
+    complexifyBooleans = True
+
+    #
+    # @var bool represent integers via floating-point math
+    #
+    integersToFloating = True
+
+    #
+    # @var bool encrypt floating point numbers
+    #
+    encryptFloating = True
+
+    #
+    # @var bool insert decoy functions
+    #
+    decoyFunctions = True
+
+    #
+    # @var bool insert anti-debugging detections
+    #
+    detectDebugger = True
+
+    #
+    # @var bool insert fake dot-source comment markers
+    #
+    fakeDotSourceMarkers = True
+
+    #
+    # @var bool insert opaque predicate branches
+    #
+    opaqueBranches = True
+
+    #
+    # @var bool insert scriptblock decoys
+    #
+    scriptblockDecoys = True
+
+    #
+    # @var bool insert here-string padding
+    #
+    literalPadding = True
+
+    #
+    # @var bool use indirect command invocation
+    #
+    reflectInvokeCommands = True
+
+    #
+    # @var bool store string fragments in char-code array vaults
+    #
+    stringCharArrayVault = True
+
+    #
+    # @var bool wrap code in try/finally blocks with dead noise
+    #
+    tryFinallyNoise = True
+
+    #
+    # @var bool apply redundant xor / affine integer masks
+    #
+    affineIntegerMask = True
+
+    #
+    # @var bool insert dead event/timer stubs
+    #
+    eventStub = True
+
+    #
+    # @var bool strip comments from the output source
+    #
+    removeComments = True
+
+    #
+    # @var integer success
+    #
+    ERROR_SUCCESS = 0
+
+    #
+    # @var integer invalid size for source code (it's 1000 bytes max. for demo version)
+    #
+    ERROR_INPUT_SIZE = 1
+
+    #
+    # @var integer input source is empty
+    #
+    ERROR_INPUT = 2
+
+    #
+    # @var integer PowerShell source code parsing error
+    #
+    ERROR_PARSING = 3
+
+    #
+    # @var integer PowerShell parsed code obfuscation error
+    #
+    ERROR_OBFUSCATION = 4
+
+    #
+    # @var integer error while generating output code
+    #
+    ERROR_OUTPUT = 5
+
+    def __init__(self, api_key=None, enable_all_obfuscation_options=True):
+        """Initialize PowerShell Pro Obfuscator class
+
+        :param api_key: Activation key for the service (it can be empty for demo mode)
+        :param enable_all_obfuscation_options: Enable or disable all of the obfuscation options
+        """
+
+        self._apiKey = api_key
+
+        # compression stays disabled by default (API does not decompress today)
+        self.enableCompression = False
+
+        self.selfDefending = enable_all_obfuscation_options
+        self.protectionLinker = enable_all_obfuscation_options
+        self.renameVariables = enable_all_obfuscation_options
+        self.renameParameters = enable_all_obfuscation_options
+        self.renameFunctions = enable_all_obfuscation_options
+        self.shuffleFunctions = enable_all_obfuscation_options
+        self.controlFlowFlatten = enable_all_obfuscation_options
+        self.stateMachine = enable_all_obfuscation_options
+        self.vmStrategy = enable_all_obfuscation_options
+        self.encryptIntegers = enable_all_obfuscation_options
+        self.splitStrings = enable_all_obfuscation_options
+        self.encryptStrings = enable_all_obfuscation_options
+        self.integersToArrays = enable_all_obfuscation_options
+        self.floatsToArrays = enable_all_obfuscation_options
+        self.insertDeadCode = enable_all_obfuscation_options
+        self.complexifyBooleans = enable_all_obfuscation_options
+        self.integersToFloating = enable_all_obfuscation_options
+        self.encryptFloating = enable_all_obfuscation_options
+        self.decoyFunctions = enable_all_obfuscation_options
+        self.detectDebugger = enable_all_obfuscation_options
+        self.fakeDotSourceMarkers = enable_all_obfuscation_options
+        self.opaqueBranches = enable_all_obfuscation_options
+        self.scriptblockDecoys = enable_all_obfuscation_options
+        self.literalPadding = enable_all_obfuscation_options
+        self.reflectInvokeCommands = enable_all_obfuscation_options
+        self.stringCharArrayVault = enable_all_obfuscation_options
+        self.tryFinallyNoise = enable_all_obfuscation_options
+        self.affineIntegerMask = enable_all_obfuscation_options
+        self.eventStub = enable_all_obfuscation_options
+        self.removeComments = enable_all_obfuscation_options
+
+    def login(self):
+        """Login to the service and get the information about the current license limits
+
+        :return: An array with the results or False on error
+        :rtype: bool,dict
+        """
+
+        # parameters
+        params = {"command": "login"}
+
+        return self.post_request(params)
+
+    def obfuscate_script_file(self, script_file_path):
+        """Obfuscate PowerShell script source code file using provided parameters
+
+        :param script_file_path: PowerShell compatible script *.ps1 file path
+        :return: An array with the results or False on error
+        :rtype: bool,dict
+        """
+
+        source_file = open(script_file_path, 'r')
+        source = source_file.read()
+        source_file.close()
+
+        if not source:
+            return False
+
+        return self.obfuscate_script_source(source)
+
+    def obfuscate_script_source(self, script_source):
+        """Obfuscate PowerShell script source code using provided parameters
+
+        :param script_source: PowerShell compatible script *.ps1 source code
+        :return: An array with the results or False on error
+        :rtype: bool,dict
+        """
+
+        # additional parameters
+        params_array = {"command": "obfuscate", "source": script_source}
+
+        return self.post_request(params_array)
+
+    def post_request(self, params_array):
+        """Send a POST request to the server
+
+        :param params_array: An array with the parameters
+        :return: An array with the results or false on error
+        :rtype: bool,dict
+        """
+
+        # add activation key to the parameters array
+        if self._apiKey:
+            params_array["key"] = self._apiKey
+
+        #
+        # obfuscation strategies
+        #
+        if self.selfDefending:
+            params_array["self_defending"] = "1"
+        if self.protectionLinker:
+            params_array["protection_linker"] = "1"
+        if self.renameVariables:
+            params_array["rename_variables"] = "1"
+        if self.renameParameters:
+            params_array["rename_parameters"] = "1"
+        if self.renameFunctions:
+            params_array["rename_functions"] = "1"
+        if self.shuffleFunctions:
+            params_array["shuffle_functions"] = "1"
+        if self.controlFlowFlatten:
+            params_array["control_flow_flatten"] = "1"
+        if self.stateMachine:
+            params_array["state_machine"] = "1"
+        if self.vmStrategy:
+            params_array["vm_strategy"] = "1"
+        if self.encryptIntegers:
+            params_array["encrypt_integers"] = "1"
+        if self.splitStrings:
+            params_array["split_strings"] = "1"
+        if self.encryptStrings:
+            params_array["encrypt_strings"] = "1"
+        if self.integersToArrays:
+            params_array["integers_to_arrays"] = "1"
+        if self.floatsToArrays:
+            params_array["floats_to_arrays"] = "1"
+        if self.insertDeadCode:
+            params_array["insert_dead_code"] = "1"
+        if self.complexifyBooleans:
+            params_array["complexify_booleans"] = "1"
+        if self.integersToFloating:
+            params_array["integers_to_floating"] = "1"
+        if self.encryptFloating:
+            params_array["encrypt_floating"] = "1"
+        if self.decoyFunctions:
+            params_array["decoy_functions"] = "1"
+        if self.detectDebugger:
+            params_array["detect_debugger"] = "1"
+        if self.fakeDotSourceMarkers:
+            params_array["fake_dot_source_markers"] = "1"
+        if self.opaqueBranches:
+            params_array["opaque_branches"] = "1"
+        if self.scriptblockDecoys:
+            params_array["scriptblock_decoys"] = "1"
+        if self.literalPadding:
+            params_array["literal_padding"] = "1"
+        if self.reflectInvokeCommands:
+            params_array["reflect_invoke_commands"] = "1"
+        if self.stringCharArrayVault:
+            params_array["string_char_array_vault"] = "1"
+        if self.tryFinallyNoise:
+            params_array["try_finally_noise"] = "1"
+        if self.affineIntegerMask:
+            params_array["affine_integer_mask"] = "1"
+        if self.eventStub:
+            params_array["event_stub"] = "1"
+        if self.removeComments:
+            params_array["remove_comments"] = "1"
+
+        #
+        # check if compression is enabled
+        #
+        if "source" in params_array and self.enableCompression and params_array["source"]:
+
+            compressed_data = zlib.compress(bytes(params_array["source"], 'utf-8'), 9)
+            base64_encoded_data = base64.b64encode(compressed_data).decode()
+
+            params_array["source"] = base64_encoded_data
+            params_array["compression"] = "1"
+
+        response = requests.post(self.API_URL, data=params_array)
+
+        # no response at all or an invalid response code
+        if not response or not response.ok:
+            return False
+
+        # decode to json array
+        result = response.json()
+
+        # depack output code back into the string
+        if "output" in result and self.enableCompression and result["error"] == self.ERROR_SUCCESS:
+
+            result["output"] = str(zlib.decompress(base64.b64decode(result["output"])), "utf-8")
+
+        # return original JSON response code
+        return result