kiteshield - Packer/Protector for x86-64 ELF binaries on Linux

项目说明

Kiteshield

A packer/protector for x86-64 ELF binaries on Linux. Kiteshield wraps ELF
binaries with multiple layers of encryption and injects them with loader code
that decrypts, maps, and executes the packed binary entirely in userspace. A
ptrace-based runtime engine ensures that only functions in the current call
stack are decrypted at any given time and additionally implements a of
anti-debugging techniques in order to make packed binaries as hard to
re as possible. Both single and multithreaded binaries are
supported.

See the Architecture and Codebase Layout
sections below for a bird's-eye view of how Kiteshield works.

Kiteshield is intended to be a fun academic exercise in binary obfuscation
rather than something that can be used in the real world given the source code,
and thus how it works, is public.

Named for the shields preferred by
the Normans in the 11th century (alternatively: the kiteshields that are so
pre in Old School Runescape).

Building Kiteshield

Kiteshield requires the Bitdefender
disassembler library to decode
instructions in the packer. It is included as a submodule at packer/bddisasm.
To build it from a fresh clone, run the following (note you will need to have
CMake installed):

You can now build Kiteshield in release mode by running make from the top
le. Alternatively you can create a debug build with make debug.
Debug builds of Kiteshield disable all anti-debugging features and turn on the
loader's very debug logging.

In order to debug the actual anti-debugging functionality, you can build
Kiteshield in debug mode with anti-debugging functionality turned *on* using
make debug-antidebug.

Using Kiteshield

To pack a binary called program and output the packed binary to packed.ks,
run:

packed.ks can now be run and should be functionally equi to program,
but encrypted and hard to reverse engineer. Note that for layer 2 encryption to
be applied, the input binary *must not* be stripped as Kiteshield relies on the
symbol table being present. On most Linux distros, standard system utilities
(eg. /bin/ls) are generally stripped.

You can still however pack stripped binaries without layer 2 encryption using
the -n flag:

This will produce an output binary packed with only layer 1 encryption and the
runtime engine omitted.

<a name="codebase-layout"></a> Codebase Layout

Kiteshield is composed of two separate parts. The packer is a regular C
application that reads, instruments, and encrypts input binaries. The loader is
a freestanding C application responsible for dynamic function decryption and
anti-debugging functionality that is injected into input binaries by the
packer. It recei control from the kernel, maps all appropriate
segments of the binary into memory (including the dynamic linker if
applicable), and hands off control to the application. The loader also contains
the runtime engine, which dynamically decrypts and encrypts functions as they
are entered and exited at runtime.

Since the loader recei control from the kernel (ie. before any
shared libraries would normally be mapped by the dynamic linker), it does not
ha to libc and thus all needed functionality provided by libc is
re-implemented in the loader code.

Packer and loader code can be found in the packer/ and loader/ directories
respectively. Code that is common to both can be found in the common/
directory. A high-le of the important parts of the codebase is as
follows:

<a name="architecture"></a> Architecture

Kiteshield wraps input ELF binaries in two (or one, if using the -n flag)
layers of RC4 encryption such that the binary on disk is fairly well
obfuscated. These layers are stripped off at runtime by the loader.

Layer 1

The first layer of encryption (referred to in the codebase as the "outer
layer") consists of a single RC4 pass over the entire input binary. This is
designed primarily to fight static analysis. Due to the way the key is
deobfuscated (which is dependent on the loader code) the first layer of
encryption also effectively checksums the loader code before executing the
packed binary, making Kiteshield resistant to code patching.

Layer 2

The second layer of encryption (referred to in the codebase as the "inner
layer") consists of indi encryption of almost every function in the input
binary (identified via the symbol table at pack-time). A ptrace-based runtime
engine is triggered on every function entry and exit of each
function's entry instruction and all its return instructions with int3
instructions (which deliver a SIGTRAP when executed). Upon receiving a trap,
the runtime engine looks up the current function and encrypts or decrypts it as
needed such that only functions within the current call stack are decrypted at
any point in time.

After stripping off layer 1, Kiteshield effectively re-implements the exec
syscall in userspace (See loader/loader.c. This technique is commonly
referred to in literature as a "userspace exec" or "userland exec".) to map the
packed binary into memory via a series of mmap/mprotect calls before
forking and handing control off to the packed binary in the child and the
runtime engine in the parent (which attaches to the child using ptrace).

In addition to encryption, Kiteshield's loader code also contains a number of
anti-debugging features designed to make it as difficult as possible to analyze
a running packed binary (See loader/anti_debug.c and
loader/include/anti_debug.h).

To give a concrete example of Kiteshield in action, consider the following
hello world program, which we will pack with Kiteshield in debug mode.

When packed in debug mode, loader code in packed binaries will log very
debug information. The following is the log from a packed binary corresponding
to the abo. It has been annotated (and additional newlines added for
clarity) to provide a concrete example of Kiteshield in action:

Testing

Kiteshield has an extensive set of integration tests to correctness
across several different platforms. See testing/README.md for details.

Limitations

Kiteshield was written with obfuscation in mind, not speed. Trapping into the
Kiteshield runtime on every function entrance and exit is very expensive.
Programs packed with layer 2 encryption should expect a serious performance
hit.

License

MIT &#x00a9; Rhys Rustad-Elliott

项目信息

开发语言：C

Star 数：245

技术要点

该项目属于病毒分析方向的开源资源，代码结构清晰，适合安全研究人员学习参考。项目围绕Packer/Protector for x86-64 ELF binaries on Linux展开，提供了可运行的实现，对理解相关安全机制、工具原理与攻防技术具有较高的研究价值。

从技术实现角度看，此类项目的核心在于对底层原理的深入理解与工程化落地。开发者在研究过程中可以结合官方文档与社区讨论，梳理项目的初始化流程、核心模块职责与数据流转，逐步掌握其中的技术细节与设计思路。

使用与学习建议

1. 下载源码压缩包，解压到本地环境。

2. 根据项目类型准备对应的运行环境与依赖。

3. 按照 README 中的步骤完成配置与部署。

4. 在隔离的测试环境中运行验证，避免影响生产系统。

免责声明

本资源来源于开源社区，仅供安全研究、技术学习与合法授权范围内的攻防演练使用，请勿用于任何非法或侵害他人权益的用途。使用本项目产生的一切后果由使用者自行承担。