Appacker

This tool takes a folder with application and packs it into a single executable file (without compression) for easy distribution, portability or whatnot.

KNOWN ISSUE

Appacker and packages created by it can be detected as malware by some antivirus software. That's because of a hacky way i used to package files: packed app reads its own executable and extracts other files from it, which antiviruses find hella suspicious. It's false positive, but it still gets in the way of using this app. I can't fix this, which renders this app not very useful. ¯\_(ツ)_/¯

Still want to download it for some reason? Well, here you go then: Download the latest version.

Usage

To pack an application you have to:

1. Select a folder that contains all the files of the target application.
   You can drag'n'drop the folder to the first textBox or the treeView.
2. Select save location for the package (it must be an .exe file).
   You can drag'n'drop an existing .exe into the second textBox; in this case it will be replaced by the package.
3. Select the main executable file of the target application inside the treeView, it will display target application's files after the step #1.
4. [Optional] Check the self-repackable checkbox.
5. Press the Pack! button and it's done. It may take some time if the target application is big enough / has a lot of files.

How to use Appacker via command line

It can be used in GUI-less mode via command line. If you provide no arguments it will launch GUI.

Usage: appacker.exe [-r] [-q] <-s "source_folder"> <-e "main_exe"> [-d "save_location"] [-i "icon_path"]

Options:
  -s, --src, --source-folder=VALUE
                             Directory containing all the files of the target
                               application.
  -e, --exe, --main-exe=VALUE
                             Local path to the main executable inside the
                               source app folder. This is the application that
                               will launch whenever the packed app extracts
                               itself.
  -d, --dst, --destination, --output=VALUE
                             Location where packed app will be created.
  -i, --ico, --icon=VALUE    Custom icon for the packed application.
  -r, --repack, --self-repack
                             Sets the packed application to refresh itself
                               after the main executable closes. Refreshing
                               adds and replaces files in the packed executable
                               with those created and modified during runtime.
  -q, --quiet, --silent      No progress messages will be shown during the
                               packing process.
  -h, --help, -?             Show this message and exit.

This will launch Appacker in GUI mode:

C:\>appacker.exe

This will launch Appacker in console mode:

C:\>appacker.exe -r -src "d:\users\sergreen\desktop\vault\coolapp" -exe "bin\launcher.exe" -dst "d:\users\sergreen\desktop\vault\CoolApp packed.exe" -ico "d:\cool_icon.png"

You can also run it in silent mode by adding --quiet flag, in this mode only error messages are shown.

How does it work

The principle behind Appacker is that you can write whatever you want to the end of an .exe file and it will still work fine.
This app simply appends all the necessary files to the end of a wrapper executable and when the wrapper is launched, it extracts all the files from its own .exe, places them into a temporary folder and starts extracted application. When target app is closed, wrapper removes temp folder.

Also you can set self-repack flag and Appacker will append to the wrapper executable the packer tool, that will repack target application once it's closed from the temporary folder and replace the original package with the updated one. This can be used to create portable application that can keep any changes made to its files (like settings, that are stored inside application directory).

What happens when you run packed application

Packed application is in fact an unpacker.exe with appended files. Application's lifecycle differs a bit for self-repackable and regular packages.
For the example, let's take the CoolApp.exe package from the screenshot above and see what it does when launched.

If it's NOT a self-repacking application, CoolApp.exe does the following:

1. Creates a temporary folder for the target application files in C:\Users\%UserName%\AppData\Local\Temp
2. Extracts all the appended files from its own exe into the temp folder
3. Runs the main executable of the extracted app (for CoolApp.exe it's Launcher.exe) and waits for it to finish
4. Deletes the temporary folder and quits

If it is a self-repacking application, CoolApp.exe does the following:

1. Creates a temporary folder A for the target application files in C:\Users\%UserName%\AppData\Local\Temp
2. Creates a temporary folder B for the packer.exe and unpacker.exe tools
3. Extracts packer.exe and unpacker.exe from its own exe into the temp folder B
4. Extracts all the appended files from its own exe into the temp folder A
5. Runs the main executable of the extracted app (for CoolApp.exe it's Launcher.exe) and waits for it to finish
6. Launches the packer.exe from temp folder B and quits
7. Packer takes all the files from the temp folder A and packs them into a new package. New package replaces the original CoolApp.exe
8. Packer deletes the temp folder A
9. Packer launches new CoolApp.exe with the special flag -killme and asks it to delete the temp folder B (because packer.exe can't delete itself); packer quits
10. New CoolApp.exe deletes temp folder B and quits

Solution structure

• Appacker — WinForms main application project
• Packer — Console tool that creates packages
• Unpacker — Console wrapper that is used as the core of a package
• ProgressBarSplash — WinForms splashscreen tool, that is used by packer and unpacker tools
• IconLib — DLL project for saving Windows .ico files (vanilla .NET can't save Windows icons correctly ¯\_(ツ)_/¯ )
• IconInjector — DLL project for replacing icons of external executables

Dependancies and credits

• IconLib by Gustavo Franco — Library for work with windows .ico images.
• IconInjector by 'some chinese guy' — Library for injecting icons into external executables.
• Fody.Costura by Simon Cropp — NuGet package for embedding .exe and .dll files into the main executable.
• Resource.Embedder by MarcStan — NuGet package for embedding localization satellite assemblies into the main executable.
• CultureManager by Grant Frisken — WinForms component that allows dynamically update language and UI Culture of the form without closing and recreating it.
• XDMessaging by TheCodeKing — Lightweight easy-to-use library for inter-process communication.
• CueProvider by Ravi Bhavnani — Lightweight class that lets you add cue banners to a TextBox.
• NDesk.Options — NuGet package for parsing program arguments.
• VerInfoLib by Denis Zabavchik — Library that provides an easy way to read, modify, and save version information resource(s) (RT_VERSION) in compiled executable modules (EXE, DLL, OCX, SCR etc.).