Skip to content

Home

Jump to bottom
Pavel Izosimov edited this page Jan 1, 2025 · 4 revisions

Python App Bundle Shield

Welcome to the Python App Bundle Shield wiki! This page provides comprehensive documentation and guidance on how to use the Python App Bundle Shield Script to create standalone protected applications and executable files based on your Python scripts.

Version: 1.3 GUI
© 2024 αβ.net (alphabetanet.com) - Alpha Beta Network. All Rights Reserved.

Introduction

The Python App Bundle Shield Script is a powerful, user-friendly tool designed to help developers create standalone protected applications and executable files from Python scripts of varying complexity. This cross-platform solution supports Python versions 3.6 and above, allowing you to package your Python code into self-contained executables for secure distribution.

Key benefits of using this script include:

  • Secure Code Sharing: Utilize advanced Python code encryption and code obfuscation in Python techniques to share your Python code securely during distribution.
  • Source Code Protection: Prevent unauthorized access to your code with multi-level protection mechanisms.
  • Seamless Application Updates: Update your applications without requiring end-users to reinstall them when using Alpha Beta Network cloud platform protection tools.
  • Usage Restrictions: Implement restrictions on each instance of your application, such as expiration dates, hardware-bound licensing, usage frequency limits, and more.
  • Cross-Platform Compatibility: Create applications that work on Windows, macOS, Linux/Unix, and other operating systems where Python 3.6+ is installed.
  • Ease of Use: Package applications with just a few clicks using a simple graphical interface or automate the process with command-line arguments, without the need for complex configurations.

By combining the Python App Bundle Shield Script with other tools from the Alpha Beta Network, developers can achieve the widest and most flexible possibilities for secure code sharing, source code protection, and secure distribution of their applications.

This tool is part of the Alpha Beta Network's suite of Python code protection tools, designed to help developers protect Python code, implement Python code encryption, and share Python code securely. By utilizing the Python App Bundle Shield, you adhere to Python code security best practices, ensuring your applications are distributed safely and securely.

Key Features

  • Unique Code Analysis Technology: Automatically analyzes and collects data about imported modules and dependencies, allowing the use of obfuscated .py code and compiled .pyc files from Python version 3.6 onwards.
  • Automatic Embedding of Python Environment: Embeds your complete configured Python environment with all imported modules and packages installed via pip into the application build.
  • Additional Protection Layers: Implements code obfuscation and encryption of created executable files for enhanced security.
  • Seamless Updating of Applications: Allows updating of created applications (fixing bugs, adding functionality) without the need to reinstall them when using Alpha Beta Network cloud protection tools like the Secure Python Code Manager Script.
  • Usage Restrictions: Enables implementation of restrictions on the use of each instance of your program (by expiration date, allowed user hardware, usage frequency, and more) when using scripts protected by Alpha Beta Network tools such as the Python Obfuscator Online and Secure Python Code Manager Script, as well as local protection tools that do not require internet access like the Local Python Code Protector Script and Python Binary Optimization Compiler.
  • Support for Cloud-Protected Scripts: Provides extensive capabilities to use Python scripts protected by the Alpha Beta Network cloud platform, facilitating secure code sharing and source code protection.
  • Ease of Use: Features a simple, user-friendly graphical interface and command-line support that requires no complex configurations, allowing you to create secure standalone applications with minimal effort.

Main Functions of the Script

  • Packaging Python Scripts into Executables: Converts Python source files (.py) and compiled files (.pyc) into standalone executables, making them runnable on systems without requiring Python installation. This can be done via a user-friendly graphical interface or through command-line arguments for automation and scripting capabilities.

  • Command-Line Interface Support: Provides flexible command-line arguments for advanced users who prefer automation or need to integrate the packaging process into scripts and build processes.

  • Embedding Full Python Runtime: Optionally embeds the entire Python runtime environment and all necessary dependencies into the executable, ensuring functionality even on systems without Python installed.

  • Code Obfuscation and Encryption: Applies multi-level protection with dynamic encryption and obfuscation techniques to enhance Python code security.

  • Integration with Cloud Protection Tools: Facilitates the use of scripts protected by Alpha Beta Network cloud platform tools, enabling seamless updates and implementation of usage restrictions. This integration allows developers to enforce Python code security best practices, utilizing advanced techniques in source code protection, and ensuring secure code sharing.

Getting Started

Prerequisites

  • Python 3.6+ installed on your system.

Installation

Clone the repository and navigate to the project directory:

git clone https://github.com/alphabetanetcom/python-app-bundle-shield.git

cd python-app-bundle-shield

Installing Required Packages

The script requires the following Python packages:

  • requests
  • psutil
  • cryptography
  • decompyle3
  • xdis
  • astor
  • pyinstaller
  • tkinter (usually included with Python)

Install them using pip:

pip install requests psutil cryptography decompyle3 xdis astor pyinstaller

Note: For Windows users, tkinter may not be included by default. You may need to run the Python installer again and select the option to install tkinter.

Ensure that you are using the correct version of pip associated with your Python 3 installation. If you are using a virtual environment, activate it before installing the packages.

User Interface Overview

The Python App Bundle Shield features both a graphical user interface (GUI) and a command-line interface (CLI) to accommodate different user preferences.

Graphical User Interface (GUI)

The GUI includes the following components:

  • File Selection: Browse and select the Python file (.py or .pyc) you wish to package.
  • Options:
    • Auto embed full python runtime: Includes the full Python environment and all installed pip packages in the build.
    • Disable Console Window: Hides the console window when running the application (useful for GUI applications).
    • Create a One-File Bundled Executable: Packages everything into a single executable file.
  • Additional Modules: Specify any additional modules (comma-separated) that need to be included.
  • Progress Display: Shows the progress of the packaging process.
  • Messages: Displays logs and messages during the process.

Command-Line Interface (CLI)

The CLI offers the same functionality as the GUI but allows for automation and integration into scripts.

  • Basic Usage:

    python python_app_bundle_shield.py -f <path_to_file> [options]

  • Options:

    • -f, --file: (Required) Path to the Python source file (.py) or compiled file (.pyc).
    • -a, --autoembed: Auto embed the full Python runtime and all installed pip packages.
    • -w, --windowed: Disable the console window for the packaged application.
    • -o, --onefile: Create a one-file bundled executable.
    • -m, --module: Specify additional modules to include (comma-separated).

Usage

The Python App Bundle Shield provides the following main functionalities:

  • Packaging Python Scripts into Executables
  • Embedding Full Python Runtime
  • Code Obfuscation and Encryption
  • Integration with Cloud Protection Tools

Basic Usage

Packaging a Python Source File using the GUI

  1. Launch the Script:

    python python_app_bundle_shield.py

  2. Select Your File: Click "Browse" and select your .py file.

  3. Click "Start": The script will package your file into an executable in the dist directory.

Packaging with Full Python Runtime using the GUI

  1. Select Your File: As above.

  2. Enable "Auto embed full python runtime": Check the option.

  3. Optional: Specify any additional modules in the "Additional Modules" field.

  4. Click "Start": The script will package your file into an executable, including the full Python runtime.

Packaging with Cloud-Protected Scripts using the GUI

  1. Obtain Cloud-Protected Script: Use our Python Obfuscator Online or Secure Python Code Manager Script to obtain your protected script.

  2. Select Your File: Choose the cloud-protected .py file.

  3. Enable "Auto embed full python runtime": Check the option.

  4. Click "Start": The script will create an executable optimized for cloud-protected scripts.

Note: If your application requires additional modules that are not automatically detected, you can specify them (comma-separated) in the Additional Modules field.

Command-Line Usage Examples

The Python App Bundle Shield supports operation via command-line arguments, enabling automation and scripting capabilities.

Basic Packaging of a Source File

To package a Python source file into an executable using the command line:

python python_app_bundle_shield.py -f /path/to/your_script.py

This command will package your_script.py into an executable in the dist directory.

Packaging with Full Python Runtime

If your script uses additional modules or requires the full Python environment:

python python_app_bundle_shield.py -f /path/to/your_script.py -a

The -a or --autoembed flag instructs the script to embed the full Python runtime and all installed packages.

Packaging a Compiled Python File

To package a compiled Python file (.pyc):

python python_app_bundle_shield.py -f /path/to/your_compiled_script.pyc

The script will handle version detection and packaging appropriately.

Packaging with Additional Options

You can combine multiple options to customize the packaging process:

  • Disable Console Window:

    python python_app_bundle_shield.py -f /path/to/your_script.py -w

  • Create a One-File Executable:

    python python_app_bundle_shield.py -f /path/to/your_script.py -o

  • Specify Additional Modules:

    python python_app_bundle_shield.py -f /path/to/your_script.py -m module1,module2

Full Example with All Options

python python_app_bundle_shield.py -f /path/to/your_script.py -a -w -o -m requests,psutil

This command will:

  • Package your_script.py into a one-file executable.
  • Embed the full Python runtime (-a).
  • Disable the console window (-w).
  • Include the additional modules requests and psutil (-m requests,psutil).

Additional Features

Integration with Code Protection Tools

The Python App Bundle Shield is designed to work seamlessly with other Alpha Beta Network tools:

By integrating these tools, you can enhance secure code sharing, enforce source code protection, and implement flexible licensing and usage restrictions.

Cross-Platform Compatibility

  • Operating Systems: Compatible with Windows, macOS, Linux/Unix.
  • Python Versions: Supports Python 3.6 and above.

Recommendations and Best Practices

  • Use Separate Environments: When embedding the full Python runtime, it's recommended to use a separate environment configured specifically for your script to keep the build size compact.

  • Test on Clean Systems: Test your application's autonomy on a clean virtual machine or sandbox where only the operating system is installed.

  • Handle External Dependencies: If your script uses external programs, include them in the _internal directory of the application build.

  • Avoid Untrusted Scripts: Do not use this tool to create applications based on Python scripts from unreliable or unknown sources, as the code is automatically executed for analysis.

  • Match Operating Systems: Create standalone applications on the operating system where future use is planned and with the same architecture.

  • Use Appropriate Python Version: Use the tool in an environment with the Python version that is directly required for your script's operation.

  • Leverage Command-Line Interface for Automation: Utilize the command-line interface for integrating the packaging process into your build automation scripts or continuous integration pipelines.

  • Leverage Python code protection tools: Combine this script with other tools from the Alpha Beta Network for multi-layered protection and enhanced security.

  • Maintain Secure Code Practices: Regularly update your tools and environments to benefit from the latest security enhancements.

Licensing

This project is currently in Beta Testing and available for free.

License Agreement

© 2024 αβ.net (alphabetanet.com) - Alpha Beta Network. All Rights Reserved.

For detailed license information, please refer to the LICENSE.md file.

Contact Information

If you experience issues or have questions not covered in this documentation, please contact the Alpha Beta Network Research Team.

Stay connected to receive updates, provide feedback, and get early access to extended functionality.

  • For more information about our Alpha Beta Network project and services, visit our Services page.

Frequently Asked Questions (FAQ)

Q1: Can I use this tool to package scripts that require external programs?

A1: Yes, but you may need to manually include these external programs in the _internal directory of the application build.

Q2: Do I need to make any changes to my original Python scripts before packaging?

A2: No, you can package your existing .py or .pyc files directly. However, if your script uses additional modules, ensure they are installed in your environment.

Q3: Can I update my application without requiring users to reinstall it?

A3: Yes, when using scripts protected by the Alpha Beta Network cloud platform, you can update the code seamlessly without end-users needing to reinstall the application.

Q4: Is it possible to implement usage restrictions on my packaged applications?

A4: Yes, by using scripts protected by our Python code protection tools, you can implement various usage restrictions such as expiration dates, hardware-bound licensing, and usage frequency limits.

Q5: Does the executable work on any operating system?

A5: The executable is platform-specific. You'll need to create the executable on the target operating system for best compatibility.

Alternative Solutions

Alpha Beta Network offers additional tools for code protection and optimization:

Appendix A: Installation of Required Packages

Ensure the following packages are installed:

pip install requests psutil cryptography decompyle3 xdis astor pyinstaller

If you encounter issues related to package versions or compatibility, consider creating a virtual environment for your project.

Appendix B: Cross-Platform Compatibility

The Python App Bundle Shield supports packaging applications for:

  • Windows
  • macOS
  • Linux/Unix

Notes:

  • Create the executable on the target operating system for best compatibility.
  • For Windows, the executable will have a .exe extension.
  • On macOS and Linux, you may need to run chmod +x on the executable to make it runnable.

For more information about our Alpha Beta Network project, please visit αβ.net.

For a comprehensive list of our tools and services, including the System Hardware ID Generator and the Python Performance Benchmark Tool, please visit our Services page.

© 2024 αβ.net (alphabetanet.com) - Alpha Beta Network. All Rights Reserved.

Clone this wiki locally