使用 GPT-3 检测代码中的安全漏洞实验

摘要：GPT-3 在这个 Git 仓库 中发现了 213 个安全漏洞。相比之下，市场上一款较优秀的商业工具（来自一家信誉良好的网络安全公司）仅检测出 99 个问题，不过该工具以更结构化的格式提供了上下文信息。在手动审查了 GPT-3 检测到的 213 个漏洞中随机抽取的 60 个样本后，仅有 4 个属于误报。两款工具都存在大量漏报。

本 README 的全文已作为 Medium 文章发布，点击此处 查看。

引言

近年来，人工智能和机器学习领域取得了迅猛发展，开辟了全新的可能性。其中一个备受关注的方向是基于 AI 的代码分析，尤其是利用 AI 模型来检测代码中的安全漏洞。在本次实验中，我们使用了 OpenAI 的 GPT-3 来查找一个包含 129 个易受攻击文件的 代码仓库 中的安全漏洞。

工作原理

我使用的 GPT-3 变体（text-davinci-003）具有 4000 个 token 的上下文窗口，大约相当于 3000 个英文单词。这意味着每次请求最多只能处理几百行代码。遗憾的是，GPT-3 当前的架构无法一次性处理整个代码库。

为了解决这个问题，我不得不单独用 GPT-3 扫描每个文件。这就意味着，对于那些需要多文件交互才能暴露的安全漏洞，GPT-3 可能难以发现，除非导入或导出语句足够清晰，能够仅凭这些信息就推测出相关函数的功能，而无需直接查看具体代码。这种情况经常发生，尤其是在源代码使用了诸如 express.js、Flask、Python 标准库、C 标准库等常见库时。很可能 GPT-3 对许多常用库已经部分记忆、完全记忆，或者以其他方式进行了编码。在本文所分析的代码中，GPT-3 对导入的库已有足够的先验知识，因此能够在不检查任何被导入库代码的情况下准确检测出安全漏洞。

公平地说，我怀疑许多现有的商业漏洞扫描工具在进行静态分析时也并不会检查被导入的库代码——因此，GPT-3 的工作方式与市面上某些工具并无本质区别。

被分析的代码

该仓库中的每个文件夹都以一种特定类型的安全漏洞命名，并包含带有单个或多个漏洞的示例代码文件。其中一些文件非常简单，但许多都是你在生产环境中可能遇到的真实代码片段（需要注意的是，它们仍然是代码片段，因此缺乏更大代码库的上下文）。每个文件夹中的 README.md 文件包含了 GPT-3 对该文件夹内所有文件中安全漏洞的分析结果。

让我们通过几个例子来看看 GPT-3 的表现吧！

示例 1（简单）

以下是一个易受格式化字符串攻击的 简单的 C 程序：

#include <stdio.h>
 
int main(int argc, char **argv) {
    printf(argv[1]);
 
    return 0;
}

以下是 GPT-3 的分析结果（正确）：

检测到的漏洞：
1. 未验证的用户输入：程序未检查用户输入的长度，可能导致缓冲区溢出攻击。
2. 格式化字符串漏洞：程序未对用户输入的格式进行检查，可能导致格式化字符串攻击。

示例 2（稍复杂）

接下来我们来看一个更高层次语言编写的稍复杂的程序，比如这个包含日志伪造漏洞的 C# 程序。我个人曾在开源项目和生产代码库中见过类似的代码（虽然没有这么复杂）：

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace WebFox.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class LogInjection : ControllerBase
    {
        private readonly ILogger<LogInjection> _logger;


        public LogInjection(ILogger<LogInjection> logger)
        {
            _logger = logger;
        }

        [HttpGet("{userInfo}")]
        public void injectLog(string userInfo)
        {
            _logger.LogError("error!! " + userInfo);
        }
    }
}

GPT-3 的输出如下：

检测到的漏洞：
1. 日志注入漏洞：代码存在日志注入漏洞，因为用户输入未经任何清理就被直接记录下来。

GPT-3 的评估是正确的——这段代码确实存在日志注入漏洞。

示例 3（非平凡）

以下是一个C程序，用于读取和操作图像。该程序包含大量安全漏洞，包括越界读取和写入：

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

struct Image
{
    char header[4];
    int width;
    int height;
    char data[10];
};

int ProcessImage(char* filename){

    FILE *fp;
    char ch;
    struct Image img;

    fp = fopen(filename,"r"); 

    if(fp == NULL)
    {
        printf("\n无法打开文件或文件不存在。");
        exit(0);
    }

    printf("\n\tHeader\twidth\theight\tdata\t\r\n");

    while(fread(&img,sizeof(img),1,fp)>0){
        printf("\n\t%s\t%d\t%d\t%s\r\n",img.header,img.width,img.height,img.data);
    
        int size1 = img.width + img.height;
        char* buff1=(char*)malloc(size1);

        memcpy(buff1,img.data,sizeof(img.data));
        free(buff1);
    
        if (size1/2==0){
            free(buff1);
        }
        else{
            if(size1 == 123456){
                buff1[0]='a';
            }
        }

        int size2 = img.width - img.height+100;
        //printf("Size1:%d",size1);
        char* buff2=(char*)malloc(size2);

        memcpy(buff2,img.data,sizeof(img.data));

        int size3= img.width/img.height;
        //printf("Size2:%d",size3);

        char buff3[10];
        char* buff4 =(char*)malloc(size3);
        memcpy(buff4,img.data,sizeof(img.data));

        char OOBR_stack = buff3[size3+100];
        char OOBR_heap = buff4[100];

        buff3[size3+100]='c';
        buff4[100]='c';

        if(size3>10){
                buff4=0;
        }
        else{
            free(buff4);
        }

        free(buff2);
    }
    fclose(fp);
}

int main(int argc,char **argv)
{
    ProcessImage(argv[1]);
}

GPT-3的输出：

检测到的漏洞：
1. 未检查返回值：fopen()函数的返回值未被检查，可能导致空指针解引用。
2. 越界读取：memcpy()函数用于将数据从img.data复制到buff1和buff2，但未检查目标缓冲区的大小，可能导致越界读取。
3. 越界写入：buff3和buff4数组在未检查源缓冲区大小的情况下被写入，可能导致越界写入。
4. 未初始化内存访问：OOBR_stack和OOBR_heap变量在未初始化的情况下被访问，可能导致未定义行为。
5. 内存泄漏：如果size3变量大于10，则不会释放buff4数组，可能导致内存泄漏。

GPT-3在这5个漏洞中正确识别了4个。其中，漏洞1属于误报，因为代码中已经通过if(fp == NULL)语句检查了fopen()的返回值。此外，漏洞4的表述存在误导性——虽然确实存在两条未初始化内存访问的错误，但所提及的变量名并不准确。

示例 4

最后一个Java示例是我最喜欢的，因为遗憾的是，我第一次阅读这段代码时并未发现任何问题。在我看来，这段代码显得完全无害且“熟悉”——我在实际项目中见过类似的代码，却从未对此产生过任何疑虑。

class Utils
{
    // 将对象序列化并写入文件的函数
    public static void SerializeToFile(Object obj, String filename)
    {
        try
        {
            FileOutputStream file = new FileOutputStream(filename);
            ObjectOutputStream out = new ObjectOutputStream(file);

            // 对对象进行序列化并写入文件
            System.out.println("正在将 " + obj.toString() + " 序列化到 " + filename);
            out.writeObject(obj);

            out.close();
            file.close();
        }
        catch(Exception e)
        {
            System.out.println("异常: " + e.toString());
        }
    }

    // 从文件反序列化对象的函数
    public static Object DeserializeFromFile(String filename)
    {
        Object obj = new Object();

        try
        {
            FileInputStream file = new FileInputStream(filename);
            ObjectInputStream in = new ObjectInputStream(file);

            // 对对象进行反序列化
            System.out.println("正在从 " + filename 反序列化");
            obj = in.readObject();

            in.close();
            file.close();
        }
        catch(Exception e)
        {
            System.out.println("异常: " + e.toString());
        }

        return obj;
    }
}

GPT-3的输出：

检测到的漏洞：
1. 不安全的反序列化：反序列化不受信任的数据可能导致远程代码执行。
2. 文件权限不安全：所写入或读取的文件可能具有不安全的权限，从而允许未经授权的访问。

GPT-3再次给出了正确的结论。

网络安全领域的终极“左移”

“左移”是指在开发流程的早期阶段就应用安全实践，例如在代码部署到生产环境之前就进行安全漏洞测试。

人工智能代码分析可以被视为网络安全领域终极意义上的“左移”，因为它能够在开发者编写和提交代码的过程中应用最佳安全实践，并对其进行网络安全教育。这不仅能够真正培养组织内部强大的安全文化，甚至有可能预防下一次重大黑客攻击，然而……

不可否认的是，目前这项技术仍不够完善，它遗漏了一些经验丰富的网络安全专业人员在审计过程中绝不会忽视的问题。尽管如此，作为一款通用的大语言模型，它的表现仍然令人震惊，而且成本远低于其他替代方案。

GPT-4目前尚未公布发布日期，但我相信随着其能力的不断提升，这类大语言模型将继续快速发展。

误报

在手动审查 GPT-3 检测到的 213 个漏洞中的大约 60 个之后，我发现的一个值得注意的误报出现在这个 JavaScript 程序 的第 13 行：

var express = require('express');
var cookieParser = require('cookie-parser');
var escape = require('escape-html');
var serialize = require('node-serialize');
var app = express();
app.use(cookieParser())
 
app.get('/', function(req, res) {
 if (req.cookies.profile) {
   var str = new Buffer(req.cookies.profile, 'base64').toString();
   var obj = serialize.unserialize(str);
   if (obj.username) {
     res.send("Hello " + escape(obj.username)); // <--- GPT-3 在这里犯了错误
   }
 } else {
     res.cookie('profile', "eyJ1c2VybmFtZSI6ImFqaW4iLCJjb3VudHJ5IjoiaW5kaWEiLCJjaXR5IjoiYmFuZ2Fsb3JlIn0=", {
       maxAge: 900000,
       httpOnly: true
     });
 }
 res.send("Hello World");
});
app.listen(3000);

GPT-3 的输出：

检测到的漏洞：
- Cookie 设置不安全（未设置 secure 标志）
- 对用户输入（Cookie）进行未经验证的反序列化
- 由于未对用户输入（用户名）进行转义，可能存在 XSS 漏洞

GPT-3 对前两个漏洞的判断是正确的，但第三个漏洞属于误报——obj.username 实际上已经进行了转义，而 GPT-3 却认为没有进行转义。

结果

实验结果显示，GPT-3 能够在扫描的 129 个文件中检测出 85 个文件存在安全漏洞。这一结果相当令人印象深刻！

脚本 summarize_results.py 会生成 GPT-3 检测结果的摘要：

在 129 个文件中，共检测出 86 个文件存在漏洞。
总共检测出 213 个漏洞。

GPT-3 回答中常用开场句的频率（每扫描一个文件生成一条回答）：
{'vulnerabilities detected': 73, 'no vulnerabilities detected.': 43, 'vulnerability detected': 6, 'answer': 2, 'potential vulnerabilities detected': 2, 'analysis': 1, 'security vulnerabilities detected': 1, 'no response given': 1} 

扫描文件类型的分布： 
总共 129 个代码文件（不包括 Markdown 和纯文本文件）
{'.php': 50, '.js': 20, '.cs': 16, '.c': 14, '.java': 9, '.py': 8, '.rb': 5, '.asp': 3, '.ts': 2, '.go': 1, '.html': 1}

与商业产品的对比

为了完善本次实验，我将 GPT-3 的检测结果与一款商用代码漏洞扫描工具 Snyk Code 进行了比较。Snyk Code 是由 Snyk 公司开发的，我认为该公司的产品非常出色。使用 Snyk Code 扫描该仓库后，共发现了 99 个安全漏洞，而 GPT-3 则检测出了 213 个。

造成这一差异的一个因素是，Snyk Code 只支持部分编程语言，因此它仅能扫描约 103 个文件，而 GPT-3 则扫描了 129 个文件。

最后的话

如果您有兴趣看到这项实验最终发展成一款完整的产品，请通过这份简短的 Google 表单 表达您的兴趣。

此仓库中的漏洞代码片段均来自 snoopysecurity/Vulnerable-Code-Snippets，这是一个非常优秀的资源。我尽量移除了代码片段中可能暗示其中包含哪些安全漏洞的注释。为此，我还删除了那些包含这些示例片段来源博客文章和资料链接的注释。原始仓库中的所有引用信息都可以在 attributions.md 文件中找到。

gpt3_security_vulnerability_scanner 快速上手指南

本工具是一个实验性项目，旨在利用 OpenAI 的 GPT-3 模型（text-davinci-003）检测代码中的安全漏洞。它通过逐文件分析源代码，识别如缓冲区溢出、日志注入、不安全反序列化等常见安全问题。

注意：本项目主要作为概念验证（PoC），依赖 OpenAI API 密钥，并非传统的“一键安装”命令行工具。以下指南将指导您如何配置环境并运行扫描逻辑。

环境准备

在开始之前，请确保您的开发环境满足以下要求：

• 操作系统：Linux, macOS 或 Windows (需配备 Python 环境)
• Python 版本：Python 3.8 或更高版本
• 依赖项：
  • openai Python 库
  • 有效的 OpenAI API Key (需访问 text-davinci-003 或兼容的 GPT-3.5/4 模型)
• 网络环境：能够访问 OpenAI API 服务（国内用户可能需要配置代理或使用镜像中转服务）

安装步骤

1. 克隆项目仓库 获取源代码到本地：

   git clone https://github.com/chris-koch-penn/gpt3_security_vulnerability_scanner.git
   cd gpt3_security_vulnerability_scanner
   

2. 安装 Python 依赖 项目中通常包含 requirements.txt，如果没有，请手动安装核心依赖：

   pip install openai
   # 如果项目根目录有 requirements.txt，推荐使用：
   # pip install -r requirements.txt
   

3. 配置 API 密钥 设置环境变量以授权访问 GPT-3 模型。

   Linux/macOS:

   export OPENAI_API_KEY="sk-your-api-key-here"
   

   Windows (PowerShell):

   $env:OPENAI_API_KEY="sk-your-api-key-here"
   

基本使用

由于该工具的核心逻辑是调用 LLM 对代码片段进行分析，使用方法主要分为直接查看示例结果和编写脚本调用 API两种方式。

方式一：查看内置分析示例

项目仓库已按漏洞类型分类整理了大量测试用例，并附带了 GPT-3 的分析结果。您可以直接浏览这些文件了解检测效果。

例如，查看格式字符串攻击的检测示例：

cat "Format String Attacks/README.md"

或者查看具体的漏洞代码与分析对比：

# 查看 C 语言漏洞源码
cat "Format String Attacks/FormatString.c"

# 查看对应的 GPT-3 分析报告 (通常在文件夹内的 README 中)
cat "Format String Attacks/README.md"

方式二：自定义扫描脚本

您可以编写一个简单的 Python 脚本来扫描自己的代码文件。以下是最小化实现示例：

import openai
import os

# 初始化客户端 (确保已设置 OPENAI_API_KEY 环境变量)
client = openai.OpenAI()

def scan_file_for_vulnerabilities(code_path):
    with open(code_path, 'r', encoding='utf-8') as f:
        code_content = f.read()

    # 构建提示词
    prompt = f"""
    Analyze the following code for security vulnerabilities. 
    List each vulnerability found with a brief explanation.
    
    Code:
    {code_content}
    """

    try:
        response = client.chat.completions.create(
            model="gpt-3.5-turbo", # 或 text-davinci-003 (如果可用)
            messages=[{"role": "user", "content": prompt}],
            max_tokens=1000,
            temperature=0
        )
        print(response.choices[0].message.content)
    except Exception as e:
        print(f"Error: {e}")

# 使用示例
# scan_file_for_vulnerabilities("./path/to/your/code.py")

使用说明：

1. 将上述代码保存为 scanner.py。
2. 修改 scan_file_for_vulnerabilities 函数中的路径为您想要检测的文件。
3. 运行脚本：

   python scanner.py
   

限制说明：

• 上下文窗口：GPT-3 上下文限制约为 4000 tokens（约 3000 英文单词），因此每次只能扫描单个文件或较小的代码片段。
• 跨文件依赖：工具难以检测涉及多个文件交互的复杂漏洞，除非导入/导出关系非常明确。
• 误报率：根据原作者测试，随机抽样中约有少量误报，建议结合人工复核。