网络安全/信息安全/渗透必学SQL注入技巧（sql注入漏洞常用的函数包括）

1.1.Sql注入攻击原理SQL注入漏洞可以说是在企业运营中会遇到的最具破坏性的漏洞之一，它也是目前被利用得最多的漏洞要学会如何防御SQL注入，首先我们要学习它的原理针对SQL注入的攻击行为可描述为通过在用户可控参数中注入SQL语法，破坏原有SQL结构，达到编写程序时意料之外结果的攻击行为。

其成因可以归结为以下两个原因叠加造成的：程序编写者在处理应用程序和数据库交互时，使用字符串拼接的方式构造SQL语句未对用户可控参数进行足够的过滤便将参数内容拼接进入到SQL语句中注入攻击的本质，是把用户输入的数据当做代码执行。

这里有两个关键条件：用户能够控制输入原本程序要执行的代码，拼接了用户输入的数据1.2.Sql审计方法手动找的话，可以直接找到sqlmapper.xml文件或者直接搜索 select、update、delete、insert “String sql=”等关键词，定位SQL xml配置文件。

如果 sql 语句中有出现 $ 进行参数拼接，则存在SQL注入风险当找到某个变量关键词有 SQL 注入风险时，可以再根据调用链找到该存在注入风险的业务逻辑代码，查看参数来源是否安全、是否有配置SQL危险参数过滤的过滤器，最终确认是否存在SQL注入。

以下给出可能造成sql注入攻击的关键字，审计时可根据实际情况进项查找常见SQL语句关键词关键词解释ResultSet数据库结果集的数据表，通常通过执行查询数据库的语句生成executeQuery执行查询。

select数据库中的查询关键字insert数据库中的插入关键字update数据库中的修改关键字delete数据库中的删除关键字where数据库中的条件关键字union数据库中的联合查询关键字drop数据库中的删除数据库关键字

create数据库中的创建数据库关键字count数据库中的返回匹配行数关键字java.sql.Connection与特定数据库的连接类Statement是 Java 执行数据库操作的重要接口jdbcTemplate

最基本的Spring JDBC模板PreparedStatement预编译的 SQL 语句的对象queryForInt数据库查询方法关键字queryForObject数据库查询方法关键字queryForMap

数据库查询方法关键字getConnection获取sql连接outfile数据库中把表数据导出关键字load_file数据库中导入数据的关键字【一一帮助安全学习,以下都是免费获取，文末有领取方式~一一】

①网络安全学习路线②20份渗透测试电子书③安全攻防357页笔记④50份安全攻防面试指南⑤安全红队渗透工具包⑥网络安全必备书籍⑦100个漏洞实战案例⑧安全大厂内部教程1.3Sql注入漏洞危害1 、 攻击者可以做到

业务运营的所有数据被攻击对当前数据库用户拥有的所有表数据进行增、删、改、查等操作若当前数据库用户拥有file_priv权限，攻击者可通过植入木马的方式进一步控制DB所在服务器若当前数据库用户为高权限用户，攻击者甚至可以直接执行服务器命令从而通过该漏洞直接威胁整个内网系统

2、可能对业务造成的影响① 用户信息被篡改② 攻击者偷取代码和用户数据恶意获取线上代码被非法篡改，并造成为恶意攻击者输送流量或其他利益的影响1.4Sql注入漏洞代码示例Java 代码动态构建 SQLStatement stmt =

null; 1 o/ \; J4 d0 y. P! m' R2 a$ ?: ~# M ResultSet rs = null; 4 c6 E8 u- z# B6 A0 E* }8 H7 n+ }0 B6 b+ L! O8 N9 {- ^2 N try{ % p* x4 S+ I) `# y! i $ l/ L7 H3 ]3 p/ p String userName = ctx.getAuthenticatedUserName(); //this is a constant

String sqlString = "SELECT * FROM t_item WHERE owner=" + userName + " AND itemName=" + request.getParameter(

"itemName") + ""; 0 X7 L/ g) J$ g+ U- j% U* V! t3 F8 k0 H stmt = connection.createStatement(); $ V1 I' V- p# x) c4 M : L& c+ Q0 e! B% f" [+ G rs = stmt.executeQuery(sqlString);" r( l) I9 E) d: N. o- q + g+ W$ p* {, A& } // ... result set handling

$ {# T6 x& Y4 N( U5 o1 x$ b / ?, D% X- L/ Q3 P8 V' _6 D5 H) h7 T }6 y; L7 S- t- f' }/ E B; } % C( H$ l4 k' U& t# I @6 l% I; Q k( c catch (SQLException se){ & k& j T) h( ~) A$ H* s) P% C 8 C: C6 K" {- b2 a+ s- I. j8 I // ... logging and error handling 5 i+ c2 K7 @' S( X& k5 B- R/ \/ [$ _" ^% O) K }' J- ^: Z- A6 R 这里将查询字符串常量与用户输入进行拼接来动态构建SQL查询命令仅当itemName不包含单引号时，这条查询语句的行为才会是正确的。

如果一个攻击者以用户名wiley发起一个请求，并使用以下条目名称参数进行查询：name OR a = a 3 Q! |0 R& K7 |( O- ^2 n 那么这个查询将变成：SELECT * FROM t_item WHERE owner = wiley

AND itemname = nameORa=a;- R& F1 K* ?* _+ E6 D' { 此处，额外的OR ‘a’=a’条件导致整个WHERE子句的值总为真那么，这个查询便等价于如下非常简单的查询：SELECT * FROM t_item 9 M( P8 Z7 t, g! j, d* W 。

这个简化的查询使得攻击者能够绕过原有的条件限制：这个查询会返回items表中所有储存的条目，而不管它们的所有者是谁，而原本应该只返回属于当前已认证用户的条目在存储过程中动态构建SQLJava代码：CallableStatement = null - i5 `% @% N0 D6 t/ k* Z 1 Q) ^5 _; s' { ResultSet results = null; f: f- D0 E4 m& a; Z% h0 y 0 e2 _5 G3 `; @* j2 p* | try* [7 ^: S" h2 k 7 y4 S7 `1 r" o" x' D8 M6 S4 f; f { ( m3 E0 z4 k+ R" Z* P5 P. u y . E5 s5 f4 y# I7 W5 z5 j3 P String userName = ctx.getAuthenticatedUserName(); 。

//this is a constant 0 A5 |3 ~& @- ]" ?4 x6 e9 M l ; e4 v! q' z7 l, E) ]! m8 g+ R/ a; W String itemName = request.getParameter("itemName"); $ }% L7 u) Q5 {% \6 \2 R# E1 t' n$ Q y& G4 [( h7 M- J! h cs = connection.prepareCall(

"{call sp_queryItem(?,?)}");" z6 j& Y/ r- v4 n9 Z 6 ]; u: y2 x* y4 b$ N cs.setString(1, userName); 2 U4 `, _% P: l" ]0 y, v3 B6 K) q' A/ u; X& L* m cs.setString(2, itemName);( o$ d, C2 j9 o5 v5 i# n5 `2 V& Y 7 B. P( @3 t! p results = cs.executeQuery(); ' B+ a+ R9 w8 c# R3 c # p- L3 O& ~* F6 G" l

// ... result set handling" z1 p! j4 F' Y; R + `+ p- ], f& q* m7 S } . t, f0 N; u6 { % G# m- D0 U/ h$ u$ @( t catch (SQLException se)# Q2 {/ A X; F4 H 4 J0 O! d- K+ w+ M' y, m& w {5 N9 y6 v4 @$ A * V' B" s2 ^! F2 T7 K! [! S$ U // ... logging and error handling / @, P+ d+ C+ }9 O, F0 ^9 K# D& A8 Z. X/ F2 g/ q' ]4 S } & I7 v& c( E9 c' ?8 d6 \ * Z$ y: ]8 P2 K3 J0 P8 v( ~3 J SQL Server存储过程：- `0 m4 G+ J1 N4 ^8 b : F: X" Y& R6 s3 F/ K+ M CREATE PROCEDURE sp_queryItem. E" }7 T0 n4 o! B! \8 n 0 q c2 J/ W5 m: a' O @userName varchar(

50), ' r2 M# r9 S# c& [4 n) u: a( \5 _0 z9 ~# x. g; P$ L! Z+ Y @itemName varchar(50) # m A3 j' p' h+ q2 J1 l8 u' B( w$ F; C3 j9 { AS + V& K) I8 ?9 s" i9 \, \: F5 {/ W) a% c8 w! d- p4 b; A# I- w BEGIN " {2 f: J- c2 W2 }, u' a % G/ h( p( D5 D4 e! S0 x& G( L DECLARE @sql nvarchar(500); ; {$ {4 [, p! a6 q6 A5 x0 A) n9 T1 ^ SET @sql = SELECT * FROM t_item . I% ?* V( ~$ D3 e9 b+ j' ^/ R' [$ p WHERE owner =

+ @userName +2 k/ i9 F2 O& P+ V( z: u/ V 4 _+ y/ k( _! V' ~( d7 ` AND itemName = + @itemName + ; : s# O5 ?8 @5 U6 N / }9 r( j b) ~; X; Q4 @ EXEC(@sql); : }1 a3 f. u, d% P ; [4 z E7 I3 s' i5 r END( m+ K2 c, f8 L, r& p$ s' D 6 ]; ~) B8 Q3 a" R" T GO0 O9 b+ V0 O0 ?& r6 t / m6 K, p# Q/ ~+ S# E 在存储过程中，通过拼接参数值来构建查询字符串，和在应用程序代码中拼接参数一样，同样是有SQL注入风险的。

Hibernate 动态构建 SQL/HQL原生SQL查询：String userName = ctx.getAuthenticatedUserName(); //this is a constant & b$ k5 d6 z2 B' w& ?( k0 n, e8 G6 Y" n% D! U- } String itemName = request.getParameter(

"itemName"); & c' I2 ^7 U3 T8 [ x3 v; M % h& q! v. g! x! i! d' g6 E Query sqlQuery = session.createSQLQuery("select * from t_item where owner = " + userName +

" and itemName = " + itemName + ""); " A, w0 B7 a- p+ s9 Z: K5 m$ }& ]* `: ?+ q( }* F0 n# l List rs = (List) sqlQuery.list(); ) Q, q( M( }- I' j* v* y! P HQL查询：String userName = ctx.getAuthenticatedUserName();

//this is a constant ; z2 c. i8 R9 n' y S. b5 J k4 o1 r+ a& t/ f3 w String itemName = request.getParameter("itemName"); : a" ^4 V& _* w" j( O* O L2 b7 O" i' w2 L Query hqlQuery = session.createQuery(

"from Item as item where item.owner = " + userName + " and item.itemName = " + itemName + "");9 ~6 l7 O5 P8 \' Q# k 7 G9 p, |. ^2 V1 G' X+ r/ e2 k List hrs = (

List) hqlQuery.list(); 9 G; i3 u/ f& ?) E. M+ M2 {' }' ?+ x8 R' r 即使是使用Hibernate，如果在动态构建SQL/HQL查询时包含了不可信输入，同样也会面临SQL/HQL注入的问题HQL代码中，session.createQuery使用HQL语句将查询到的数据存到到list集合中，需要时在拿出来使用。

而参数中itemName是通过request.getParameter直接获取攻击者若在此处写入恶意语句，程序将恶意语句查询出来的数据存放在list集合中，再通过某处调用成功将数据显示在前台Mybatis注入分析

Mybatis框架下易产生SQL注入漏洞的情况主要分为以下三种：1）模糊查询like例如对人员姓名检索进行模糊查询，如果考虑安全编码规范问题，其对应的SQL语句如下：Select * fromuserwhere

namelike%#{name}%但由于这样写程序会报错，研发人员将SQL查询语句修改如下：Select * fromuserwherenamelike%${name}%在这种情况下我们发现程序不再报错，但是此时产生了SQL语句拼接问题，如果java代码层面没有对用户输入的内容做处理势必会产生SQL注入漏洞。

2）in之后的参数例如对人员姓名进行同条件多值检索的时候，如当用户输入001,002,003…时，如果考虑安全编码规范问题，其对应的SQL语句如下：Select * fromnamewhereidin (

#{id})但由于这样写程序会报错，研发人员将SQL查询语句修改如下：Select * fromnamewhereidin (${id})# n2 X+ ?' m+ W2 h9 Y$ h. p7 Q, u! U 修改SQL语句之后，程序停止报错，但是却引入了SQL语句拼接的问题，如果没有对用户输入的内容做过滤，势必会产生SQL注入漏洞。

3）order by之后(重点和区分点)当根据姓名、id序号等信息用户进行排序的时候，如果考虑安全编码规范问题，其对应的SQL语句如下：Select * fromuserwherename = qihoo

orderby#{id} desc但由于发布时间id不是用户输入的参数，无法使用预编译研发人员将SQL查询语句修改如下：Select * fromuserwherename = qihooorderby

${id} desc修改之后，程序未通过预编译，但是产生了SQL语句拼接问题，极有可能引发SQL注入漏洞1.5.实战案例-OFCMS SQL注入漏洞分析本文中使用ofcms进行SQL注入漏洞讲解，此CMS算是对新手学习代码审计比较友好的CMS。

上述为安装成功页面，如何安装CMS本章不在赘述。后台页面：http://localhost:8080/ofcms-admin/admin/index.html

漏洞点：ofcms-admin/src/main/java/com/ofsoft/cms/admin/controller/system/SystemGeneratrController.java# I6 i' _$ N4 i . \+ v k1 \7 @) l3 r5 h* F8 O4 I0 B- M& T create方法! Z; e/ r: S. t9 y# L) [ 6 Q) d: m( q7 t4 I1 l* @ | ! V' v/ B Z+ G. K; M* {# B7 z% t" P9 U) j* b' ~

/** ]0 S2 X8 d$ Q3 Q E% a ; J: y/ {2 v" [3 v$ n * 创建表! M/ ]3 j. W9 U9 i1 i 1 q$ j- i9 K- M8 P' {+ x! g* l */publicvoidcreate() { . e9 K; s4 x# [9 B f 8 p" U% w2 S. x; L( ?* ^ try { 6 J4 |$ X" g) R! w T1 s, |( j( n- n+ y6 ~9 d8 n+ ^ String sql = getPara("sql");' u) |3 R4 z1 T6 a ' e& S: i$ ]( w9 b% f0 v$ ^ Db.update(sql); & o5 W' S( {( b/ H+ E9 Q/ Q, j- l _ rendSuccessJson(); # G1 L4 Z; N" ^$ Q- ~( M 3 L7 x- {8 ? M( A3 T+ @ }

catch (Exception e) {1 Q* c2 @5 F4 l0 `( B1 t# X O; M D. j! E( |9 }8 L e.printStackTrace();0 N6 o; f+ z) a/ E y5 d5 v/ \3 C$ D' S! Z rendFailedJson(ErrorCode.get("9999"), e.getMessage());4 T' h9 e. E8 C, [0 z% a$ S : L: q( Z, P! f8 ~ V+ O- Z5 j } 7 Q3 n' \. L& I2 F0 s: ^: a J- F : c* t9 ^ f; U4 J2 f: r! Z }) P8 f$ M$ x- w; M+ g

上述代码中使用getpara获取sql的参数值，并update，跟进一下getpara和update方法跳转至jfinal-3.2.jar/com/jfinal/core/controller.class。

public String getPara(String name) { 7 `% G% h+ b' W1 U/ [$ q 9 j& r, E N: Q returnthis.request.getParameter(name); ; r: x( M. O6 ~" d" Z B/ o3 `0 h) L$ @6 Z } & `. P n1 j- U* j. B 上述代码无特殊用意，就是获取参数值，继续跟进 Db.update 方法。

跳转至jfinal-3.2.jar/com/jfinal/plugin/activerecord/Db.classpublicstaticintupdate(String sql){4 r# c. ?$ v* g0 B/ F6 O + n# ~$ W3 |% m) r& K9 G, | return MAIN.update(sql); 5 M8 u# S# ?* y( P, S5 o9 ^" C 6 ]. g# w' b5 @ }5 ^3 `0 t% E) q, o! }! d" i2 V

发现调用 MAIN.update , 继续跟进跳转至jfinal-3.2.jar/com/jfinal/plugin/activerecord/DbPro.classpublicintupdate(String sql)。

{ . x$ L1 r3 T& S * K; k* ]* g8 E8 o& c! d returnthis.update(sql, DbKit.NULL_PARA_ARRAY); 1 K+ [3 _" E5 y" J' N) q5 ?5 z; q* R4 V% G* Q }# v/ p, K% N- q4 `+ o 继续跟进到最后，发现华点public int update(String sql, Object... paras) {3 g- `6 ^. V2 i 4 a1 D) v" s6 b2 J! |, p$ C1 B Connection conn = 。

null;$ M, d8 e/ Y4 o+ {4 I 5 c1 j0 y4 ^4 d" }8 r7 h+ E2 J int var4;; l2 d% O, p8 o: q, n ) H G; B; l; y b1 P; b try {( T/ ?7 y4 u! V$ B2 v ^, T 1 V. F7 [8 l3 N. q& v) ~ conn = this.config.getConnection();//连接 $ B* @, l/ R# d 1 H: [- Y6 {+ z4 s" h! c& @$ p; C3 d var4 = this.update(this.config, conn, sql, paras);

//调用update更新 * \# a5 }9 ^/ y 7 ^$ ?1 A* X2 {8 K* z } catch (Exception var8) {: O% O; y5 ~( Y r C 5 o2 M& i b* d4 V3 T+ t throw new ActiveRecordException(var8); ! H2 z* n0 U0 v' Z0 g ' s9 ~1 x" ?0 v1 I& ^; t } finally {5 h7 I$ }0 j$ y$ u! w ( m1 x! M( N; U& D5 d this.config.close(conn); 6 w- F, x' n( ^+ Q$ o* ^3 X/ v + h1 H- p* [, O7 X$ f) A- i3 a }, p4 V9 O: i$ {! n+ S2 V # A. }8 o* l; O! T+ B* Q4 P% W

return var4; ( U! p+ g+ d/ O2 Z9 m3 K 8 G4 b/ }! v$ }; Y( i" l" S" c( C } : E% Z* Z$ R; P0 N1 g1 B! J 重点：Object…Object是所有类的基类，而 Object… 是不确定方法参数情况下的一种多态表现形式(可以传递多个参数)再继续跟进 update ，同文件代码int

update(Config config, Connection conn, String sql, Object... paras)throws SQLException { " I4 z6 \- W6 |* Q, B [; ^: X) J" @$ Q& U8 L; H2 n PreparedStatement pst = conn.prepareStatement(sql);/ N8 F5 |; E+ }% ^ + s0 y5 _, l! [ config.dialect.fillStatement(pst, paras);- O/ e/ h4 t! D! v5 P/ K" x+ Y5 r$ J ; g% p$ Y& t; l3 y

int result = pst.executeUpdate(); 1 j0 m" V9 b. U0 B% {1 E1 a4 | / o- Z+ x5 X' z7 I DbKit.close(pst);& r1 I" k3 w5 `; n ; C* m9 z9 |, o return result;. t/ O, f: P( V* v- [0 D+ I5 F $ s' O a' Z8 d7 p) W+ C } 8 A* \. G- K" o" X6 S; i 上述代码执行SQL语句，并返回结果至此，整个功能流程结束，在我们跟进的过程中，代码中无任何过滤语句，获取参数值，调用update方法更新，更新成功后返回结果。

漏洞验证

漏洞点打上断点，网页中输入poc进行验证update of_cms_topic set topic_url=updatexml(1,concat(0x7e,(user())),0) where topic_id =

1

根据如上截图可看出我们传入的SQL语句是被完整的接收，并未做任何过滤直接带入数据库执行，所以此处直接写入漏洞代码爆出当前数据库账户为 root上述为sqlmap工具跑出来的注入点1.6漏洞修复方法添加全局过滤器，过滤特殊字符

SQLFilter.java中：

PreparedStatement 参数化如果使用参数化查询，则在SQL语句中使用占位符表示需在运行时确定的参数值参数化查询使得SQL查询的语义逻辑被预先定义，而实际的查询参数值则等到程序运行时再确定参数化查询使得数据库能够区分SQL语句中语义逻辑和数据参数，以确保用户输入无法改变预期的SQL查询语义逻辑。

在Java中，可以使用java.sql.PreparedStatement来对数据库发起参数化查询在这个正确示例中，如果一个攻击者将itemName输入为name’ OR ‘a’ = ‘a，这个参数化查询将免受攻击，而是会查找一个itemName匹配name’ OR ‘a’ = a这个字符串的条目。

PreparedStatement stmt = null; L$ ^8 P" f& j" b, `, Q + j3 c3 h5 r# J ResultSet rs = nulltry A* k/ g4 s) W: T9 ^4 U: } $ F2 m" v4 z5 A$ {, i6 G, A { & t, y6 Q! i# K- R* ^. H; E( O+ g; J* T. i6 h# n3 d String userName = ctx.getAuthenticatedUserName();

//this is a constantString itemName = request.getParameter("itemName");$ y5 h# d- Y9 q 8 K! v; Y$ s4 n( H9 V* W' t( j // ...Ensure that the length of userName and itemName is legitimate

// ...String sqlString = "SELECT * FROM t_item WHERE owner=? AND itemName=?";+ o5 h1 W7 Y; I( O ; P" S2 Q& m2 C D. p0 O* {6 E0 ~ stmt = connection.prepareStatement(sqlString); . F: ?$ }& H ]% [ - j' F/ E0 E9 ]) K& F stmt.setString(

1, userName); 3 l- n7 K" F& r# e % V% E; ^1 M/ j! G: l: ~ stmt.setString(2, itemName);* e. e$ O& O% b5 } t: v ; d3 n# E3 n6 U! k0 S3 a: G- |8 u rs = stmt.executeQuery(); & F, d5 ?5 h. }6 d3 H' Q+ A - K5 S( n8 \# M2 `6 B* U$ J8 V0 D // ... result set handling, H! B& t/ j+ A. F + y# A7 x7 _) @5 ^1 C }* u4 ]4 }0 U6 r * S8 B% S5 ^0 }& b

catch (SQLException se) ( ^6 k8 F" n7 [1 A& J9 B/ ^- } , o- l2 D" s7 t/ ^1 K0 \! h( A {' A$ G$ H7 k! Y7 Y/ `% c: m / t* a3 t% }' I0 j0 c4 w3 X3 c! S // ... logging and error handling : j c$ ?6 B ~- I" {; h' h , F0 d$ A9 B/ a }. z/ V* y! T& q; |( u 存储过程参数化这个存储过程使用参数化查询，而未包含不安全的动态SQL构建。

数据库编译此存储过程时，会生成一个SELECT查询的执行计划，只允许原始的SQL语义被执行任何参数值，即使是被注入的SQL语句也不会被执行，因为它们不是执行计划的一部分CallableStatement =

null0 @# a- e+ M* p9 j! N # Q7 S4 j* k. B6 ^0 @ ResultSet results = null; 9 s( z. d' x7 l3 F. P9 [' z: E0 F' [' t& k: u1 N1 q8 E8 Z3 ]7 K try: x, H+ L W& ~# A: `* c 9 }; k$ ] m: ^8 J. z* S { & g) @$ ~, F! n, P" j6 o }4 s2 O4 \ / g" L8 `1 U( d String userName = ctx.getAuthenticatedUserName(); //this is a constant

String itemName = request.getParameter("itemName"); $ q. k; t! V9 ~7 [& W G6 P5 l* m. i* b; }8 B2 Z* ~) i+ m // ... Ensure that the length of userName and itemName is legitimate

// ...9 @3 u$ v( y/ k/ C8 x9 O ( G/ I, V8 C7 L, O( K. c+ i cs = connection.prepareCall("{call sp_queryItem(?,?)}");: j7 s: o" U8 `; @3 }3 r3 @$ L# m 0 j; f% }. b0 Y1 Z: B cs.setString(1, userName);* _( @: z f; A$ L' d% p1 t% r I- e; t; Z; V cs.setString(

2, itemName); ( S3 {4 v$ N% n6 f w: W$ k, a3 t ~ r& E results = cs.executeQuery(); ) @9 U, z4 w! F3 o4 R: Y 2 c/ Z5 u' x* v- y4 R" k // ... result set handling2 |1 h" {3 J5 s $ X0 Y/ N7 O1 s' p } , N9 \& X8 q s K7 d; X # z# i: W# z3 y" t7 ^ J7 p catch (SQLException se)2 {+ x0 r- J+ x+ `: k ) `) l. ]( q( ^+ } f& O { 1 E y# h8 {9 q) t& p( l. I+ h! T$ {) Y. A$ S

// ... logging and error handling, H0 K4 X( I2 z2 i* C. p K( } 6 e+ H4 y3 {9 l; ^1 V5 o }/ j% N+ e2 w4 c0 Y) A7 f Hibernate 参数化查询Hibernate支持SQL/HQL参数化查询为了防止SQL注入以及改善性能，以上这些示例使用了参数化绑定 的方式来设置查询参数。

String userName = ctx.getAuthenticatedUserName(); //this is a constant V. k7 w6 r) R5 f0 x + ]1 h9 R( v% ~( O% v String itemName = request.getParameter(

"itemName");( T+ k$ u# [6 h u. W7 k 4 ~ y) S0 H3 L- e& F Query hqlQuery = session.createQuery("from Item as item where item.owner = ? and item.itemName = ?"

);- A: v$ e& F% P% x3 d6 R7 w / s- g& d: L( G, ]4 A5 m hqlQuery.setString(1, userName); X6 X/ W' e/ i( ]" Y+ F/ A v" u7 o3 R! g hqlQuery.setString(2, itemName); ! ~/ y5 k" z( g: X2 g7 O/ y( y, ? . d+ N& l) u0 W- s3 t2 l List rs = (List) hqlQuery.

list();5 n4 M8 D& O e+ R v* _ B: L- e HQL基于名称的参数化查询String userName = ctx.getAuthenticatedUserName(); //this is a constant" l, r t& Z9 P- r W( k% D# A ) o/ U- y2 C# [) ~: q9 P4 e; B String itemName = request.getParameter(

"itemName"); * f4 b+ \. X- [2 @( K, e! ?% i) Y* N( S- Q5 d' z Query hqlQuery = session.createQuery("from Item as item where item.owner = wner and item.itemName = :itemName"

);/ N' ^' E. z! C! _1 ? , X& _ q' z! n8 N8 @ hqlQuery.setString("owner", userName); & g% f, F K- V- N2 [& d4 |# B6 h$ {. ]8 D$ K- ? hqlQuery.setString("itemName", itemName);7 M- |: N) y* I8 l9 {: A' y / t! x6 G) b8 V& _ List rs = (

List) hqlQuery.list();1 O6 D6 R* @( F 原生参数化查询String userName = ctx.getAuthenticatedUserName(); //this is a constant

* g3 Z$ A. V( m" O 5 z6 O# M" z; E7 |) N String itemName = request.getParameter("itemName");; _8 O5 s! I1 [: b- i/ l8 m 5 ~( U: p8 M+ e. { Query sqlQuery = session.createSQLQuery("select * from t_item where owner = ? and itemName = ?"

); ; |3 r n' E- f4 W) P/ o) R: K" q1 W& l( B O6 X( u1 o sqlQuery.setString(0, owner);3 @0 e1 ^6 ^ ]; Q & s9 r; h# }- _! j' T sqlQuery.setString(1, itemName);0 P! h( B% B( V1 @! E' q 4 U) g( T A6 M1 B) b/ E+ H) j5 Z List rs = (List) sqlQuery.

list(); * b9 I& `, K" N/ z: q" c5 m7 K MyBatis框架的修复方案尽量使用#描述参数，如果一定要使用$，则需要自己过滤用户输入模糊查询like SQL注入修复建议按照新闻标题对新闻进行模糊查询，可将SQL查询语句设计如下：select

* from news wherenamelikeconcat(‘%’,#{name }, ‘%’)采用预编译机制，避免了SQL语句拼接的问题，从根源上防止了SQL注入漏洞的产生in之后的参数SQL注入修复建议。

在对新闻进行同条件多值查询的时候，可使用Mybatis自带循环指令解决SQL语句动态拼接的问题：select * from news whereidin

item="item"open="("separator=","close=")">#{item} order by SQL注入修复建议在Java层面做映射预编译机制只能处理查询参数，其他地方还需要研发人员根据具体情况来解决。

如前面提到的排序情景：Select * from news where title =‘淘宝’ orderby#{time} asc，这里time不是查询参数，无法使用预编译机制，只能这样拼接：Select

* from news where title =‘淘宝’ orderby ${time} asc针对这种情况研发人员可以在java层面做映射来进行解决如当存在发布时间time和点击量click两种排序选择时，我们可以限制用户只能输入1和2。

当用户输入1时，我们在代码层面将其映射为time，当用户输入2时，将其映射为click。而当用户输入1和2之外的其他内容时，我们可以将其转换为默认排序选择time(或者click)。