The query in the code builds a dynamic query as seen in the previous example. The query is build by concatenating strings making it susceptible to string SQL injection:
"SELECT * FROM user_data WHERE first_name = 'John' AND last_name = '" + lastName + "'";
Using the form below try to retrieve all the users from the users table. You shoud not need to know any specific user name to get the complete list.
์ฐ๋ฆฌ๋ ์ฌ๊ธฐ์ ๋ชจ๋ ์ ์ ์ ์ ๋ณด๋ฅผ ๋ณผ ์ ์๋ injection์ ์ฑ๊ณตํ๊ธฐ ์ํด ์ฟผ๋ฆฌ๋ฌธ์ ๋์ ์๋ง์ ์คํธ๋ง์ ์ถ๊ฐํด์ค์ผ ํ๋ค.
์ฃผ์ด์ง ์ฟผ๋ฆฌ ์คํธ๋ง์ ๋ณด๋ฉด last_name = "
ํ๊ณ ๋ฐ์ดํ๊ฐ ์ค๊ธฐ ๋๋ฌธ์ string injection ๊ธฐ๋ฒ์ ์ฌ์ฉํด์ผ ํ๋ค. ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์จ๋ ์๊ด ์์ง๋ง, ์ฝ๊ฒ ๊ฐ๊ธฐ ์ํด์ ์ฐ๋ฆฌ๋ or
๊ตฌ๋ฌธ์ ์ด์ฉํด์ ์ฐํํ ๊ฒ์ด๋ค.
or
์์ชฝ์๋ ์๋ฌด ๋ฌธ์ฅ์ด๋ ์๋ ๋๋ค. ์๋๋ฉด ์์ชฝ์ false๊ฐ ๋ผ๋ ์๊ด์ด ์๊ธฐ ๋๋ฌธ์ด๋ค. ์์ธํ ๊ฑด ์ผ๋จ ์ฟผ๋ฆฌ๋ฅผ ๋ฃ์ด๋ณด๊ณ ๋ณด์.
'๊ฐ์' or '1'='1
์ด๋ ๊ฒ ๋ฃ์ผ๋ฉด lastName
์ ์ฐ๋ฆฌ๊ฐ ์
๋ ฅํ ๊ฐ์ด ๋ค์ด๊ฐ๊ธฐ ๋๋ฌธ์
SELECT * FROM user_data WHERE first_name = 'John' AND last_name = '๊ฐ์' or '1'='1'
์ ์ฟผ๋ฆฌ๋ฌธ์ด ์คํ๋๋ค.
์ง๊ธ ์์ฑ๋ ์ฟผ๋ฆฌ๋ฌธ์ ๋ณด๋ฉด WHERE
์ ์ด
false AND false or true
์ ํํ๋ฅผ ๋ ๊ณ ์๋ค. ์ด ๋, ์ฐ์ฐ ์์๋ and๊ฐ ๋จผ์ ์ด๋ฏ๋ก and ์คํ ํ์๋ false
or '1'='1'
๊ฐ ๋๊ณ , '1'='1'
์ ํญ์ true
์ด๊ธฐ ๋๋ฌธ์ WHERE
์ ์ด ๋ฌด์กฐ๊ฑด true
๊ฐ ๋๋ ๊ฒ์ด๋ค.
์ด ๋ฌธ์ ์ฒ๋ผ ์ ์ ํ ์ํฉ์์ or [true๊ฐ ๋๋ ๋ฌธ์ฅ]
์ ํํ๋ก ๋ง์ง๋ง์ ๋ฃ์ด์ฃผ๋ฉด ์ฐํํ ์ ์๋ค. ์์ฒญ ์ฝ๋ค์^_^
The query in the code builds a dynamic query as seen in the previous example. The query in the code builds a dynamic query by concatenating a number making it susceptible to Numeric SQL injection:
"SELECT * FROM user_data WHERE login_count = " + Login_Count + " AND userid = " + User_ID;
Using the two Input Fields below, try to retrieve all the data from the users table.
Warning: Only one of these fields is susceptible to SQL Injection. You need to find out which, to successfully retrieve all the data.
์ด๋ฒ ๋ฌธ์ ๋ Numeric injection์ ์ด์ฉํ๋ ๋ฌธ์ ์ธ๋ฐ, ์ฌ์ค ์์ String injection๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋งจ ๋ค์์ or [true๊ฐ ๋๋ ๋ฌธ์ฅ]
์ ์ถ๊ฐํด์ฃผ๋ฉด ๋์ด๋ค.
์ฐธ ์ฝ๋ค.
If a system is vulnerable to SQL infections, aspects of that system's CIA triad can be easily compromised. In the following three lessons you will learn how to compromise each aspect of the CIA triad using techniques like SQL string injections or query chaining.
In this lesson we will look at confidentiality. Confidentiality can be easily compromised by an attacker using SQL injection to read sensitive data from a database.
You are an employee named John Smith. The company has an internal system that allows all employees to see their own internal data - like the department they work in and their salary.
The system requires the employees to use a unige authentication TAN to view their data.
Your current TAN is 3SL99A.
Since you alwqys have the urge to be the most earning employee, you want to exploit the system and instead of viewing your own internal data, you want to take a look at the data of all your colleagues to check their current salries.
You already found out that the query performing your request looks like this:
"SELECT * FROM employees WHERE last_name = '" + name + "' AND auth_tan = '" + auth_tan + "'";
String injection์ ํ๊ธฐ ์ํด์๋ ์ฑ๊ธ์ฟผํฐ๋ฅผ ์ฐ๋ฉด ๋๋ค. ์ฐ๋ฆฌ๊ฐ ๋ณดํต ์ฌ์ฉํ๋ ์์ ํ ์น์ฌ์ดํธ์๋ ๋ฌ๋ฆฌ, ์ฐ๋ฆฌ๊ฐ ์ธ์ ์ ์ ์ฐ์ตํ ์ ์๋๋ก ์ทจ์ฝํ๊ฒ ๋ง๋ค์ด์ง ์น๊ณ ํธ๋ ๋ณ๋ค๋ฅธ ํํฐ๋ง์ด ์ ์ฉ๋์ง ์์ผ๋๊น ์ ๊ฒฝ์ฐ์ง ์์๋ ๋๋ค.
์ง๊ธ ์ฐ๋ฆฌ์ ์ ๋ ฅ์ด ๋ณด๋ด์ง๋ ์นธ์ ์ด๋ ๊ฒ ์๊ฒผ๋ค.
์ฐ์ injection์ ์๋ํ๊ธฐ ์ ์ ํ ์ด๋ธ์ด ์ด๋ป๊ฒ ์๊ฒผ๋์ง ๋ณด๊ธฐ ์ํด์, ์ ์์ ์ผ๋ก ๋ด ์ด๋ฆ๊ณผ TAN์ ์ ๋ ฅํ๋ฉด
์ ์๋์์ ํ์ง๋ง ๋ด ๊ณ์ ์ ๋ณด๋ง ๋์ค๊ธฐ ๋๋ฌธ์ ๋ฌธ์ ๋ฅผ ํต๊ณผํ์ง ๋ชปํ๋ค๊ณ ๋ฌ๋ค.
์๋ง๋ ์ฟผ๋ฆฌ๋ฌธ์ด ์ด๋ฐ ์์ผ๋ก ์๊ฒผ์ ๊ฒ์ด๋ค.
SELECT * FROM USERS WHERE last_name="" AND auth_tan=""
์ด์ ์ด ์ฟผ๋ฆฌ๋ฌธ์ ์ด์ฉํด์ sqli๋ฅผ ํ๋ฉด ๋๋ค. ์ฐ์ ์ฐ๋ฆฌ๊ฐ ๋ฐฐ์ด injection์ ์ด์ฉํ๊ธฐ ์ํด์๋ name์ ์ฐธ/๊ฑฐ์ง ์ฌ๋ถ๋ ์ค์ํ์ง ์์ผ๋ฏ๋ก name์๋ ๊ทธ๋ฅ ์๋ฌด๊ฑฐ๋ ์ฐ๊ณ TAN์์ string injection์ ํ๋ฉด ๋๋ค.
๊ทธ๋์ ๋๋ name์ 'hi'๋ฅผ, TAN์๋ String Injection์ ์ฌ์ฉํด์ ์ด ๋ฌธ์ ๋ฅผ ํ์๋ค!
sql๋ฌธ์ ๋ณด๋ฉด ์ฑ๊ธ์ฟผํฐ๋ก TAN์ด ๊ฐ์ธ์ ธ์๊ธฐ ๋๋ฌธ์ ๊ทธ๊ฑธ ํด๊ฒฐํด์ฃผ๊ธฐ ์ํด ์ฒ์์๋ ๋ซ์์ฃผ๊ณ , ๋ง์ง๋ง์๋ ์ ์ ๋ก ๋ซํ๋๋ก ์ด์ด์ค ์ํ๋ก ๋ฃ์ด์ฃผ๋ฉด ๋๋ค.
๊ทธ๋ฌ๋ฉด ์ ์ฟผ๋ฆฌ๋ฌธ์ ๋ค์ด๊ฐ์ ๋๋ auth_tan = '1' or '0' = '0';
์ด๋ ๊ฒ ๋ผ์ ์ฟผ๋ฆฌ๋ฅผ ์คํํ๋ฉด ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ๋ณด์ฌ์ฃผ๋ ๊ฒ์ด๋ค.
After compromising the confidentiality of data in the previous lesson, this time we are gonna compromise the integrity of data by using SQL query chaining.
The integrity of any data can be compromised, if an attacker per example changes information that he should not even be able to access.
Query chaining is exactly what it sounds like. When query chaining, you try to append one or more queries to the end of the actual query. You can do this by using the ; metacharacter which marks the end of a query and that way allows to start another one right after it within the same line.
You just found out that Tobi and Bob both seem to earn more money than you! Of course you cannot leavve it at that.
Better go and change your own salary so you ar earning the most!
Remember: Your name is John Smith and your current TAN is 3SL99A.
์ผ๋จ ๋ชจ๋ ์ ์ ์ ๋ํ salary
๋ฐ์ดํฐ๋ฅผ ๋ด์ผ ํ๋ค. ๊ทธ๋์ผ ๊ฐ์ฅ ๋์ ๊ธ์ก์ ์๊ณ ๋์ ๊ทธ๊ฒ๋ณด๋ค ๋ ๋์ ๊ธ์ก์ผ๋ก ๋ด ์๊ธ์ ๋ฐ๊พธ๋ฉด ๋๋ค. ๊ทธ๋์ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ๋ณด๊ธฐ ์ํด ์ง๊ธ๊น์ง ์ผ๋ sqli๋ฅผ ์ด์ฉํ๋ฉด ๋๋ค.
์ด๋ฒ ๋ฌธ์ ๋ ์์ ๋ฌธ์ ์ฒ๋ผ ์ฟผ๋ฆฌ๋ฌธ์ ํํ๊ฐ ์์ฃผ์ด์ ธ์ SELECT
์ ์ด๊ฒ ๊ตฌ๋ ํ๊ณ ์์ํ๋ฉด์ ๋ฌธ์ ๋ฅผ ํ๋ ค๊ณ ํ๋ค.
์ฐ์ ๋ชจ๋ ์ ๋ณด๋ฅผ ์กฐํํ๊ธฐ์ํด์ WHERE
์ ์ true
๋ก ๋ง๋๋ numeric injection์ ์ฌ์ฉํ๊ณ ๊ทธ ๊ฒฐ๊ณผ๋ก ๋ชจ๋ ์ ์ ์ ์ ๋ณด๊ฐ ๋์๋ค. ๊ทผ๋ฐ ๊ฐ์ฅ ๋์ ๋ง์ด ๋ฐ์์ผ ํ Smith๊ฐ ๋์ ์ ์ผ ์กฐ๊ธ ๋ฐ๊ณ ์๋ค.๐ ์ฐ๋ฆฌ๊ฐ ๋ฐ๊ฟ์ฃผ์!
์ด์ ์ฐ๋ฆฌ๋ ์ ๋ณด๋ฅผ ์์ UPDATE
ํด์ผํ๋ค.
๊ทธ ์ ์ update์ ์ ๊ธฐ๋ณธ ๊ตฌ์กฐ๋ถํฐ ๊ฐ๋จํ ์ดํด๋ณด๊ณ ๊ฐ์.
UPDATE [ํ
์ด๋ธ๋ช
] SET [์ปฌ๋ผ๋ช
] = [์ํ๋ ์ปฌ๋ผ๊ฐ] WHERE [์กฐ๊ฑด];
์ฐ๋ฆฌ๋ ์ผ๋จ ์ form์ ์
๋ ฅํ๋ ๊ฐ์ด SELECT
์ ์ ๋ค์ด๊ฐ๋ ๊ฒ์ ์๊ณ ์๊ธฐ ๋๋ฌธ์, ์ฐ๋ฆฌ๊ฐ ์ํ๋ UPDATE
์ ์ ์คํ์ํค๋ ค๋ฉด Query Chaining
์ ์ด์ฉํด์ผํ๋ค. Query Chaining
์ ์ฟผ๋ฆฌ๊ฐ ๋๋๋ ๋ถ๋ถ์์ ์ธ๋ฏธ์ฝ๋ก ์ ์จ์ ๋ค์ ์ํ๋ ์ฟผ๋ฆฌ๋ฌธ์ ํ๋ ๋ ๋ฃ์ด์ฃผ๋ ๊ฒ์ด๋ค.
๊ทธ๋์ ๋๋ Employee Name ์ ๋ ฅ ์นธ์ ๋ค์๊ณผ ๊ฐ์ด ์ผ๋ค.
1'; UPDATE EMPLOYEES SET SALARY = 90000 WHERE LAST_NAME = 'Smith';--
์คํ๋๋ ์ฟผ๋ฆฌ:
SELECT * FROM EMPLOYEES WHERE last_name='1'; UPDATE EMPLOYEES SET SALARY = 90000 WHERE LAST_NAME = 'Smith';--AND auth_tan='(TAN์
๋ ฅ๊ฐ)'
์ฐ์ ์ฑ๊ธ์ฟผํฐ๋ก ์ด๋ ค์๋๊ฑธ 1'
๋ก ๋ซ์์ฃผ๊ณ ๋ฌธ์ฅ์ ๋๋ด์ฃผ๋ ;
์ธ๋ฏธ์ฝ๋ก ์ ์ด ํ UPDATE
์ ์ ์ผ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ง์ง๋ง์๋ ์ฃผ์์ฒ๋ฆฌ๋ฅผ ํด์ฃผ์๋ค. ์ฃผ์์ฒ๋ฆฌ๋ฅผ ํด์คฌ๊ธฐ ๋๋ฌธ์ ๋ค์ ์ค๋ ์กฐ๊ฑด์ด์๋ auth_tan์ ๋ฌด์๊ฐ ๋๊ณ , ๊ฒฐ๊ณผ์ ์ผ๋ก ํ์์๋ ๊ฐ์ด ๋๊ธฐ ๋๋ฌธ์ ์นํ์ด์ง ์์์ TAN ์นธ์๋ ์๋ฌด๊ฑฐ๋ ๋ฃ์ด์ค๋ ๋๋ค.
๊ฒฐ๊ณผ๋
Well done!
After successfully compromising confidentiality and integrity in the previous lessons, we now are going to compromise the third element of the CIA triad: abailability.
There are many different ways to violate vailability. If an account is deleted or the password gets changed, the actual owner cannot access it anymore. Attackers could also try to delete parts of the databse making it useless or even dropping the whole database. Another way to compromise availablity would be to per example revoke access-rights from admins or any other users, so that nobody gets access to the database.
Now you are the top earner in you company. But do you see that? There seems to be a access_log table, where all your actitons have been logged to!
Better go and delete it completely before anyone notices.
๊ฒ์์ด๋ผ๋ ๊ฑฐ๋ like์ฐ์ฐ์๊ฐ ์ฌ์ฉ๋ผ์ผํ๋ค. ๊ฒ์ํ ํค์๋๋ฅผ ํฌํจํ๋ ๊ฒ๋ค์ ๋ด์ผํ๊ธฐ ๋๋ฌธ์ด๋ค.
SELECT * FROM ACCESS_LOG WHERE ACTION LIKE '%[๊ฒ์์ด]%';
์ด๋ฐ์์ผ๋ก ํ๋ฉด ACTION์ด ๊ฒ์์ด๋ฅผ ํฌํจํ๋ data๋ค์ ์ถ๋ ฅํ ์ ์๋ ๊ฒ์ด๋ค. ์ ๊ฒ์์ด์ ์ฐ๋ฆฌ๊ฐ ์
๋ ฅํ๋ ๊ฒ ๋ค์ด๊ฐ๋๊น ์ด ๋ฌธ์ ๋ query chaining
์ ์ด์ฉํ๋ฉด ๋๋ค!
๋ค๋ฅธ ์ ์ผ๋ก๋, ์ด๋ฒ ๋ฌธ์ ์์ ํ
์ด๋ธ์ ์ง์ฐ๋ผ๊ณ ํ์ผ๋๊น DROP
์ ์ chainingํ๋ฉด ๋๋ค.
DROP TABLE ACCESS_LOG--
์ด๋ ๊ฒ ํ๋ฉด access_log ํ ์ด๋ธ์ด ์์ ์ง์์ง๋ค!
์
๋ ฅ๊ฐ: 1' drop table access_log--
๊ฒฐ๊ณผ
SQL injection Intro ๋!