Preview
Про Product Security легко рассказывать списком технологий. SAST, DAST, SCA, threat modeling, Kubernetes, IAM, SIEM — всё знакомо, всё полезно. Но это не раскрывает суть продуктовой безопасности как security software engineering. Оттого ProdSec как самостоятельное направление безопасности часто путают с отдельными активностями AppSec, DevSecOps. Поэтому интереснее идти не от тулов, а от одного сквозного сценария. Именно на базе кейса разберем что, где и как. Ну, готовы!? let's go!
И, да, парни, учитывая что все текущие платформы\продукты с чем мне приходилось иметь дело были англоязычные, а так же корпус понятий и терминов из кибербеза нативно идет на английском, а иногда не имеет адекватного\точного перевода на русский, то далее в материале буду использовать понятийное native ядро с описанием остального контекста русским текстом.
Возьмём условную consumer fintech-платформу с инвестиционным кабинетом. Пользователь проходит KYC, пополняет счёт, покупает и продаёт активы, видит позиции и денежные остатки, добавляет банковские реквизиты и выводит доступные средства. Внутри — web и mobile clients, публичное API, несколько backend-сервисов, брокерская или custodial-интеграция, внутренний ledger, платёжный provider, Kafka, Kubernetes в AWS и CI/CD.
Disclaimer
Это не разбор реального финтех кейса (банка, брокера или биржи), но не утверждение, что у какой-либо компании\продукта есть описанные ниже проблемы. Архитектура составная. Я беру типовые паттерны из публично описанных financial systems и намеренно упрощаю детали, которые не нужны для разговора о Product Security. Все что не под NDA будет в тексте, остальное, ребята, извините:)
Что за финтех система в рассматриваемом кейсе
Основной пользовательский путь будет таким:
Продать актив → дождаться состояния, в котором деньги можно выводить → зарезервировать сумму во внутреннем ledger → добавить или выбрать банковский счёт → инициировать payout → пройти проверки → отправить перевод через payment provider → сверить внешний и внутренний результат.
Здесь есть важная бизнес-деталь. Исполненная сделка и деньги, доступные для вывода, — не всегда одно и то же состояние. Если представить, например, американские акции, стандартный settlement для большинства сделок с 28 мая 2024 года — T+1: продажа сегодня обычно рассчитывается на следующий рабочий день. В других рынках и продуктах правила могут отличаться, поэтому в нашей модели лучше явно различать хотя бы trade_executed, settled_cash, available_to_withdraw и reserved_for_payout, а не складывать всё в одно поле balance. SEC о переходе на T+1; для примера того, как брокер отдельно показывает доступность средств для вывода, можно посмотреть описание Cash Available to Withdraw у Fidelity.
Ledger здесь — не блокчейн, а внутренний финансовый журнал: система записей, по которым продукт понимает, кому принадлежит экономическая стоимость, почему она изменилась и какие операции уже произошли. Payout — вывод средств за пределы платформы. Эти два понятия дальше будут встречаться постоянно.
Если какие-то из затронутых доменов хочется потом разобрать отдельно — AppSec, API Security, DevSecOps, Cloud/Kubernetes, Threat Modeling или Secure SDLC — я собираю более широкую карту материалов в своей Product Security Knowledge Base. Здесь же останемся внутри одного кейса и посмотрим, как эти области встречаются в одном продукте.
Я сознательно не буду превращать материал в compliance-гайд по PCI DSS, PSD2, DORA, SEC/FINRA или локальному финансовому регулированию. В реальном проекте требования compliance и legal обязательно войдут в дизайн, но набор будет зависеть от страны, лицензий и модели бизнеса. Здесь нас интересует именно инженерная логика Product Security.
1. База продукта и что под капотом
Представим, что у платформы есть web и mobile clients, API Gateway, Identity Service, Portfolio Service, Trading Service, Ledger Service, Payout Service и отдельная административная плоскость для Operations. Внутри используются Kafka, PostgreSQL и Redis; workloads работают в Amazon EKS; инфраструктура описана Terraform; delivery идёт через GitLab CI, registry и GitOps. Снаружи находятся KYC/Fraud services, market-data provider, broker/execution venue или custodian и payment provider.
Упрощённо это можно представить так:
Web / Mobile
|
+-------------------+
| CDN / WAF / Edge |
+-------------------+
|
+-----------------+
| API Gateway |
+-----------------+
/ | \
/ | \
+---------+ +---------+ +----------+
| Identity| |Portfolio| | Trading |
+---------+ +---------+ +----------+
| | |
| | +-----------> Broker / Custodian
| | / Execution Venue
| v
| +---------+
+------>| Ledger |<----- trade / cash events
+---------+
|
reserve / release
|
+-----------+ +-------------+
Operations / Admin ---->| Payout |------>| Payment |
+-----------+ | Provider |
^ +-------------+
|
KYC / Fraud / Risk
Async flows -> Kafka / queues / provider webhooks
State -> PostgreSQL / ledger store / Redis where appropriate
Runtime -> Amazon EKS / AWS IAM / KMS / Secrets Manager
Delivery -> GitLab CI / Registry / GitOps
Смысл схемы не в выборе конкретных AWS-сервисов. Важнее увидеть несколько разных источников правды и trust boundaries. Trading domain знает, была ли сделка исполнена и рассчитана. Ledger отвечает за внутреннее денежное состояние. Payout domain управляет жизненным циклом вывода и резервирует средства. Payment provider знает, что произошло на внешнем платёжном rail. Identity/Fraud дают сигналы и решения, но не должны произвольно переписывать финансовую историю. Admin plane умеет делать очень мощные вещи и поэтому заслуживает отдельной модели доверия.
Такие идеи не взяты из воздуха. Square публично описывал Books как immutable double-entry accounting service, где ошибку исправляют новой компенсирующей записью, а не тихим UPDATE старой истории. Uber в актуальном обзоре своей Payments Platform описывает zero-sum money orders, ledger, entity changelog, Kafka-based asynchronous processing и audit trail; в более раннем разборе Gulfstream отдельно обсуждаются idempotency, versioning и reconciliation между асинхронными системами. Мы не копируем их архитектуру — это просто хорошие публичные подтверждения того, что financial correctness строится как отдельная инженерная система, а не как таблица users.balance.
На такой схеме security-инженер уже видит десятки потенциальных поверхностей атаки. Но если сразу побежать рисовать красные стрелки, легко утонуть в деталях. Я обычно сначала фиксирую security invariants — свойства продукта, которые должны оставаться истинными независимо от того, как именно атакующий пытается их нарушить.
Для payout flow инварианты будут примерно такими:
- пользователь не может распорядиться чужими деньгами;
- баланс нельзя увеличить без легитимной финансовой операции;
- один бизнес-payout не должен привести к двум фактическим переводам;
- смена payout-реквизитов не должна превращать обычный account takeover в мгновенную потерю денег;
- администратор не может незаметно провести чувствительную операцию в обход утверждённого workflow;
- внешний provider не становится источником абсолютной истины только потому, что сообщение пришло от него;
- компрометация одного workload не должна автоматически давать права на весь AWS account;
- в production должен попадать ожидаемый артефакт из ожидаемого source/build process.
Это уже хороший фундамент. Вместо абстрактного «нам нужен SAST» появляется вопрос: какое свойство системы мы защищаем, каким контролем и как потом проверим, что контроль реально работает?
Для общей базы требований пригодятся OWASP ASVS, NIST SSDF и OWASP SAMM. На сентябрь 2026 у ASVS актуальной стабильной версией является 5.0.0. Но framework всё равно не знает твою бизнес-логику — он помогает не забыть классы требований, а не заменяет инженерное понимание продукта.
2. Threat model: строим attack path
Для нового payout flow я бы не начинал встречу с вопроса «какие у нас тут STRIDE-категории». STRIDE полезен как способ не забыть классы угроз, но команде проще работать с конкретным сценарием: как атакующий превращает первоначальный доступ в деньги, данные или контроль над системой?
Например, довольно быстро появляются такие цепочки:
Stolen session
-> add attacker's payout account
-> no recent re-authentication
-> no risk-based step-up
-> create payout
-> fraud service timeout fails open
-> money leaves platform
Или:
RCE in Payout Service
-> read workload credentials
-> IAM role allows broad Secrets Manager access
-> obtain another service credential
-> call privileged internal API
-> manipulate payout workflow
Или supply-chain вариант:
Compromised CI token
-> modify pipeline definition
-> inject malicious build step
-> normal signing stage signs produced image
-> deployment policy sees valid signature
-> malicious but "legitimate" image reaches production
Здесь особенно хорошо видно, почему Product Security нельзя свести к поиску CVE. В первом сценарии каждый компонент может работать ровно так, как его написал разработчик, а атака всё равно получится из комбинации допустимых продуктовых решений.
На threat-model review мне нужен не красивый док в Confluence, а несколько вещей, с которыми команда сможет работать дальше: как-то опасные abuse cases, конкретные security requirements, владельцы контролей, способ проверки, нужная telemetry и решение о том, что будет release blocker. Логика близка к OWASP Threat Modeling Cheat Sheet: что мы строим, что может пойти не так, что мы с этим делаем и достаточно ли хорошо это сделали.
Возьмём смену payout-реквизитов. Требование «обеспечить безопасность функции вывода» бесполезно — его нельзя нормально ни реализовать, ни протестировать. Гораздо лучше написать так:
- добавление нового payout account требует недавней re-authentication или step-up authentication;
- backend проверяет ownership счёта и право конкретного subject использовать его для payout;
- изменение реквизитов влияет на уже созданные, но ещё не исполненные операции предсказуемым образом;
- для высокого риска можно применить cooling-off period, лимит суммы или дополнительное подтверждение;
- внешний callback не меняет финансовое состояние без аутентификации, replay protection и проверки допустимого state transition;
- административное исключение требует повышенной роли, сильной аутентификации и tamper-resistant audit trail.
Step-up — это дополнительная проверка личности именно перед чувствительным действием: например, повторная аутентификация, passkey/WebAuthn или другой сильный фактор. Maker-checker — принцип, при котором один сотрудник создаёт критическую операцию, а другой независимо её подтверждает.
Если свести весь подход к одной цепочке, получится так:
Abuse case
-> security requirement
-> architecture / control
-> test
-> runtime signal
-> release / risk decision
Эту цепочку полезно держать перед глазами почти на всём протяжении проекта.
3. API и деньги: authorization, state machine и асинхронность
В fintech API неприятные проблемы часто начинаются не с того, что злоумышленник смог войти, а с того, что система разрешила ему сделать после успешной аутентификации. Это важное различие: authentication отвечает «кто ты», authorization — «что именно тебе можно сделать сейчас с этим объектом».
В OWASP API Security Top 10 2023 несколько категорий напрямую связаны с authorization: BOLA, Broken Object Property Level Authorization и Broken Function Level Authorization.
Представим endpoint:
POST /api/v1/payouts
Authorization: Bearer <token>
Content-Type: application/json
{
"portfolio_id": "pf-19482",
"bank_account_id": "ba-8841",
"amount": 25000,
"currency": "EUR"
}
Слабая реализация может проверить только валидность token, наличие bank account и достаточный balance. На реальном review меня интересует больше:
Does this subject own or control portfolio pf-19482?
Can this subject use bank account ba-8841?
Is the account verified and in an allowed state?
Was payout destination changed recently?
Does the operation require step-up?
Is the amount allowed by current limits and risk state?
Is this state transition legal?
Has this business operation already produced an external transfer?
То есть authorization привязывается не к наличию кнопки и не просто к URL. Нужны subject + action + resource + context.
Например:
subject: user-42819
action: payout.create
resource: portfolio-pf-19482
amount: 25000 EUR
risk_state: elevated
recent_auth: false
Результат политики может быть не только allow или deny, но и require_step_up. В большой системе стоит заранее решить, где живёт эта логика: в каждом сервисе, общей library, policy engine или отдельном authorization service. Какой вариант лучше — зависит от архитектуры. Плохой вариант почти всегда один: пять сервисов, которые по-разному понимают одно и то же право.
Не путай mobile client с доверенной зоной (Zero trust always)
Мобильное приложение добавляет UX и дополнительные security-сигналы, но не переносит trust boundary на устройство пользователя. Клиент контролирует своё устройство, сеть и локальную копию приложения, поэтому сервер не должен принимать решение о balance, KYC state, payout limit или authorization на основании того, что «это прислал наш официальный APK».
Для native authentication flow сейчас разумно ориентироваться на OAuth/OIDC best practices: external user-agent для авторизации и Authorization Code Flow с PKCE для public clients. Это закреплено в RFC 8252 и актуальном OAuth Security BCP RFC 9700. Для проверки самого mobile client полезен OWASP MASVS.
Device attestation, root/jailbreak detection и certificate pinning могут быть дополнительными сигналами и повышать стоимость атаки, но я бы не делал из них единственную границу безопасности. Если атакующий модифицировал приложение и начал вызывать API напрямую, серверные invariants должны всё равно сохраниться.
Business logic: то что выше "шестеренок под капотом"
Теперь более интересная часть. Допустим, после settlement у пользователя есть available_to_withdraw = 15 000 EUR, дневной payout limit — 10 000 EUR, а резервирование средств и проверка лимита реализованы разными операциями. Два worker одновременно получают по запросу на 9 000 EUR, оба читают старое состояние и оба считают операцию допустимой.
В итоге система может зарезервировать или попытаться вывести 18 000 EUR. Это не обязательно выглядит как классическая «уязвимая строка кода». Проблема живёт в конкурентной обработке финансового состояния.
Для денежных workflow я предпочитаю явно записывать invariants:
available_to_withdraw must not become negative
unless the product explicitly supports credit
settled_cash + unsettled_cash + reserved_for_payout
must reconcile with the ledger model
one business payout ID must not result
in more than one effective external transfer
confirmed payouts in a window
must not exceed the effective limit
an external provider event may move a payout
only through an allowed state transition
Сам payout удобно воспринимать как state machine, например:
requested -> risk_review -> reserved -> submitted
-> rejected -> failed
-> completed
-> reconciliation_required
Конкретные состояния могут быть другими, но смысл такой: не каждый входящий event имеет право перевести объект из любого состояния в любое. completed после уже отменённой операции, повторный submitted или callback для другого external payment ID должны либо быть безопасно отвергнуты, либо отправить операцию в явное состояние разбирательства.
После этого появляются понятные тесты: concurrent requests, duplicate webhook delivery, out-of-order Kafka events, retry после timeout, задержанная доставка события, изменение payout account во время pending operation, rollback одного сервиса после успешной операции другого.
Здесь есть важная инженерная тонкость. Фраза «сделаем exactly-once» сама по себе ничего не гарантирует. Внутри контролируемой транзакционной границы или собственного order-processing pipeline можно построить exactly-once semantics через strong consistency, immutable identifiers и idempotency — Uber, например, публично описывает такой подход для своих payment orders. Но на границе с внешним payment provider остаётся классический неприятный случай: provider уже произвёл перевод, а сеть оборвалась до того, как наш сервис получил подтверждение.
Поэтому защита строится слоями: durable business identifier, идемпотентная команда на внешнем API, atomic reservation внутри ledger boundary, database constraints/locking там, где это оправдано, transactional outbox или другой надёжный способ публикации событий, дедупликация на consumer side и обязательная reconciliation. Stripe, например, прямо рекомендует idempotency keys для безопасных retry, а в документации webhooks предупреждает о повторной доставке, retries и отсутствии гарантии порядка событий.
Если запрос завис после отправки, правильный вопрос не «повторить ли HTTP POST», а «можем ли мы доказать, был ли уже произведён экономический эффект». Если доказать нельзя, это отдельное бизнес-состояние, а не повод оптимистично поставить failed и отправить деньги ещё раз.
Это хороший пример границы между Application Security (привет инженерам) и архитектурой (привет архитектору). Security здесь не диктует команде конкретный паттерн транзакций, но обязан заметить, что нарушение consistency приводит не к красивой ошибке в логах, а к реальным деньгам.
4. Secure SDLC: переводим решения из встреч в delivery process
Если Product Security впервые видит новую payout feature после того, как код уже написан, обсуждать архитектуру поздно и дорого. Поэтому security должна появляться в обычном delivery process не отдельной церемонией в конце, а в нескольких точках, где решение ещё можно изменить. Более широкую карту того, как я связываю Secure SDLC, AppSec и DevSecOps, я держу в Product Security Knowledge Base; здесь оставим только те элементы, которые реально нужны нашему payout flow.
Я бы построил поток примерно так:
Product idea
-> security triage
-> threat model if risk is material
-> security requirements
-> design / implementation
-> automated checks + review
-> targeted validation
-> release decision
-> runtime telemetry
-> feedback
Security triage не обязан быть часовым митингом. Это может быть несколько вопросов в design/RFC template: появились ли новые sensitive data, privileged action, external integration, authentication/authorization flow, financial state transition, internet-facing endpoint, file processing, server-side URL fetching или новая IAM boundary. Если ответов «да» много, задача автоматически уходит на более глубокий review.
Здесь же полезно разделить одноразовые решения и повторяемые решения. Если каждый новый сервис заново выбирает, как валидировать JWT, логировать audit event, получать cloud identity или проверять webhook signature, security-команда будет бесконечно ревьюить одну и ту же проблему. Лучше один раз сделать approved library, reference implementation или platform capability и превратить это в paved road — безопасный путь по умолчанию, которым разработчику проще воспользоваться, чем обойти.
Security Champions помогают масштабировать такой подход внутри engineering teams. Их задача не в том, чтобы превратить backend-разработчика в pentester. Гораздо полезнее, если champion знает локальный контекст команды, понимает approved patterns и может рано заметить, что новая feature меняет trust boundary или business invariant.
На этом этапе также появляется понятие evidence. Если requirement говорит «критический endpoint использует централизованный authorization middleware», хорошо, когда у тебя есть не только запись в wiki, но и способ автоматически проверить это в code review или integration test. Чем больше повторяемых решений превращаются в проверяемые guardrails, тем меньше security зависит от памяти конкретного человека.
5. Конвейер CI/CD
Допустим, разработчик меняет Payout Service. Pipeline может выглядеть так:
commit
-> pre-commit / local checks
-> merge request
-> unit tests
-> SAST
-> secret scanning
-> SCA
-> IaC checks
-> build
-> SBOM
-> image scan
-> integration / abuse tests
-> provenance / signing
-> registry
-> deployment policy
-> production
Инструменты здесь полезны, но проблема начинается, когда каждая найденная High автоматически превращается в pipeline failed. Через несколько недель разработчики либо привыкают к красному pipeline, либо находят способ его обходить.
Для SAST можно использовать Semgrep, CodeQL, SonarQube, Checkmarx, Veracode и другие решения. Но реальная зрелость появляется, когда кроме generic SQLi/XSS rules команда начинает кодировать свои архитектурные ограничения. Например: privileged endpoint обязан использовать approved authorization middleware; full bank account нельзя писать в log; low-level payout client нельзя вызывать за пределами определённого service layer; отключение webhook verification должно быть невозможно простым feature flag.
Secret scanning полезно делать и локально, и на server side: Gitleaks, TruffleHog, Trivy или возможности самого SCM. Если production credential уже попал в Git history, удаления строки недостаточно — его надо считать exposed и ротировать.
В SCA я бы смотрел не только на CVSS. Важны direct/transitive dependency, reachability, runtime exposure, публичный exploit, наличие фактической эксплуатации и asset context. Для prioritization можно учитывать, например, CISA Known Exploited Vulnerabilities и EPSS, но ни один такой сигнал не является готовым risk score: EPSS оценивает вероятность эксплуатации CVE в ближайшие 30 дней и сам FIRST отдельно подчёркивает, что environmental impact он не знает.
Blocker или то что действительно должно остановить release
Для нашего продукта я бы ожидал блокировку при подтверждённом authorization bypass в payout/trading flow, double payout, возможности подделать provider event и изменить финансовое состояние, production secret в репозитории, internet-reachable admin surface без ожидаемого access control или реальном пути от RCE к чрезмерно привилегированной cloud identity.
Dependency issue тоже может быть blocker, если эксплуатация подтверждена или правдоподобна, vulnerable path действительно используется и impact для конкретного workload высок. Но «High в dev dependency, который не попадает в runtime» и «известно эксплуатируемая RCE в internet-facing parser» — это две совершенно разные задачи, даже если scanner окрасил обе строки одинаково.
Полезно воспринимать scanner severity как один вход в решение, а не само решение. Обычно важны exploitability, reachability, exposure, asset criticality, business impact, compensating controls и uncertainty. Неопределённость тоже фактор: если ты не можешь доказать, что критичный путь недостижим, это не автоматически делает риск низким.
Supply chain
Теперь вернёмся к сценарию с украденным CI token. Атакующий меняет pipeline, добавляет malicious build step, после чего обычная система подписывает созданный image. Подпись валидна — просто подписали уже не тот результат.
Поэтому software supply chain начинается раньше container registry. Нужно защищать source repository и pipeline definitions, требовать review для критичных изменений, ограничивать CI identities, по возможности использовать isolated/ephemeral runners, разделять build и signing authority, хранить provenance и проверять identity артефакта перед deployment.
Для формализации удобно смотреть на SLSA v1.2: в этой версии есть отдельные Build и Source tracks. Для SBOM подойдут CycloneDX и SPDX, для подписи и attestations — Sigstore/Cosign.
Сам SBOM ничего не «защищает», это не тула, а скорее док с содержанием. Он становится полезным, когда после новой CVE ты можешь быстро ответить: в каких production workloads есть компонент X, какой именно версии, откуда он попал в build и где vulnerability реально достижима?
6. Kubernetes и AWS
Допустим, в Payout Service появился RCE. Частая ошибка — сразу обсуждать container escape. Я бы первым делом посмотрел, что атакующий получает без всякого escape, используя уже выданные workload права.
Если pod работает privileged, с hostPath, CAP_SYS_ADMIN, writable root filesystem и чрезмерными Kubernetes RBAC permissions, компрометация действительно может быстро уйти в cluster layer. Для обычных application workloads разумный baseline — non-root, allowPrivilegeEscalation: false, минимальные capabilities, seccomp, отсутствие hostPath и privileged mode без обоснования. В Kubernetes для этого есть Pod Security Standards, где профиль Restricted — полезная отправная точка для большинства обычных workloads.
Политику лучше превращать в admission control, а не держать только в wiki. В зависимости от стека это могут быть Kyverno, OPA Gatekeeper или native ValidatingAdmissionPolicy/CEL. Но rollout policy тоже является инженерной задачей: включить жёсткий enforce на старом cluster без baseline — хороший способ остановить deployment. Практичнее пройти путь audit -> fix baseline -> warn -> enforce.
Для posture scanning пригодятся Trivy, Kubescape, kube-bench и cloud/CNAPP tooling. Для runtime visibility — Falco, Tetragon или коммерческий runtime sensor. Но scanner и runtime detector не заменяют понимание permission model.
Cloud IAM
Предположим, container escape невозможен, зато service account получает AWS role с такими правами:
secretsmanager:GetSecretValue *
s3:GetObject *
kms:Decrypt *
rds:*
iam:PassRole *
В таком случае атакующему cluster escape вообще может не понадобиться. Он уже получил credential, которым разрешено слишком много. Именно поэтому IAM review я начинаю от business capability workload. Payout Service действительно может нуждаться в конкретном secret, публикации события в конкретный topic и вызове ограниченного API. Из этого не следует, что ему нужен wildcard на Secrets Manager или право iam:PassRole.
На EKS long-lived AWS keys обычно можно убрать в пользу workload identity и временных credentials. AWS поддерживает, в частности, EKS Pod Identity; идея та же — связать IAM permissions с Kubernetes service account и не разносить статические ключи по YAML и CI. При этом важно помнить о credential isolation и IMDS: сама workload identity не спасает, если pod всё ещё может получить более привилегированные node credentials.
Secrets: а имнно Kubernetes Secret
Фраза «пароль лежит в Kubernetes Secret» сама по себе мало что говорит о security. Для обычного Kubernetes важно помнить две вещи: base64 в объекте Secret не является encryption, а безопасность сильно зависит от encryption-at-rest, RBAC и от того, кто вообще может создавать workloads в namespace и тем самым получать доступ к Secret.
Но в нашем EKS-примере нужна более точная оговорка. Amazon EKS начиная с Kubernetes 1.28 включает envelope encryption для всех Kubernetes API data по умолчанию, используя AWS KMS provider v2; для старых EKS 1.27 и ниже encryption Secrets на уровне Kubernetes API настраивалась отдельно. Это хороший пример того, почему cloud-specific defaults надо проверять, а не переносить общую фразу из vanilla Kubernetes один в один. Документация AWS EKS.
При этом encryption at rest всё равно не решает весь lifecycle. Для production я смотрю на создание, хранение, delivery, access, rotation, revocation и audit. В зависимости от архитектуры это могут быть AWS Secrets Manager, Vault, External Secrets, KMS и short-lived credentials. Часто лучший secret — тот, который удалось заменить identity и вообще перестать хранить как долгоживущий credential.
Ledger integrity важнее одной только confidentiality
Финансовая система обязана защищать не только секретность данных, но и их целостность. Шифрование database at rest мало поможет, если один чрезмерно привилегированный service account может тихо переписать transaction state.
Для ledger полезно отдельно продумать append-only или tamper-evident audit patterns, строгие state transitions, separation of duties, reconciliation и восстановление истории. Хороший вопрос для architecture review звучит так: какой минимальный набор компонентов или identities нужно скомпрометировать, чтобы незаметно изменить финансовую истину? Если ответ — «один обычный backend service», blast radius слишком большой.
7. Third party и admin plane: режем доверие с обеих сторон
Payment provider присылает webhook:
POST /webhooks/payment-status
{
"payment_id": "ext-5521",
"status": "completed"
}
*IP allowlist *можно использовать как дополнительный слой, но не как единственное доказательство подлинности. Нужны TLS, authentication provider, cryptographic signature или HMAC, timestamp/nonce, replay window, idempotent processing и проверка state machine. Для серьёзных расхождений нужен reconciliation с provider API.
Даже правильно подписанное сообщение не должно иметь полномочие сказать: «сделай любую внутреннюю транзакцию COMPLETED». Оно относится к конкретному external payment ID и может вызвать только допустимый переход конкретного внутреннего объекта. Если provider дважды доставил одно событие — экономический эффект не должен удвоиться. Иначе это бага:)
Здесь же я бы посмотрел на admin plane. Обычный customer API часто получает больше security-внимания, чем внутренняя панель, хотя именно там живут refund, account unlock, KYC override, manual payout и другие очень мощные действия. Для них нужны отдельная authorization model, strong authentication, least privilege, step-up для особо чувствительных операций, maker-checker там, где это оправдано, и аудит, который оператор не может тихо подчистить теми же credentials.
Отдельная организационная граница проходит между Product Security и Fraud. Такие показатели как Credential stuffing, anomalous device, mule account и подозрительная скорость вывода могут быть fraud signals в анти-фрод системах; а вот broken authorization, unsafe state machine и compromised service identity — больше про security concerns. В реальной fintech-команде эти области постоянно пересекаются. Да, да, так. Спорить, «чей это тикет», менее полезно, чем заранее договориться о shared signals, ownership и escalation path. Короче, работать надо командой, а не валить ответственность на смежника:) Безопасность здесь партнер, а не стопер бизнеса или разработки.
8. Проверка: pentest должен атаковать предположения продукта
Перед release payout flow имеет смысл провести targeted security validation. Автоматические инструменты вроде OWASP ZAP, Burp Suite, API fuzzing и custom integration tests хороши и полезны, паплайн робит, но pentester получит намного больше пользы, если кроме URL ему дать architecture context и abuse cases (белый ящик).
Я бы сформулировал задание примерно так:
Can you create a payout from another user's portfolio?
Can you reference another user's bank account object?
Can a customer identity invoke an admin transition?
What happens if you send the same payout concurrently 20 times?
Can a completed provider event be replayed?
What if payout account changes while payment is pending?
Can undocumented or old API versions bypass current controls?
Can a field hidden by UI be mass-assigned through API?
Для pentester это тоже меняет стиль работы. Вместо «нашёл IDOR — severity High» появляется цепочка: finding Х-> attacker action Y-> prerequisite -> business effect Z -> next step. Например, BOLA на read-only history endpoint и BOLA на payout destination — один класс weakness, но совершенно разный продуктовый риск.
И наоборот, отсутствие обычных OWASP bugs ещё не означает, что flow безопасен. Такие слабости как-то Race condition, не критичный replay, неоднозначный state confusion и "легенький" abuse of legitimate functionality могут потребовать custom scripts и понимания domain model\платформы изнутри.
Если preventive control не сработал — что мы увидим?
На design review полезно буквально задать этот вопрос. Для payout flow я бы хотел видеть события вокруг добавления/смены payout account, step-up, создания и изменения payout, административного override, duplicate/replayed webhook, невозможного state transition, необычной payout velocity и reconciliation mismatch.
В platform layer полезны denied IAM calls, secret access, Kubernetes exec, privileged workload creation, admission failure, artifact verification failure и неожиданный outbound traffic. Но логировать просто HTTP 403 мало — нужен контекст: кто действовал, над каким объектом, какое policy decision сработало и с каким request/session identifier.
При этом security logging не должен сам превращаться в утечку. Password, access token, secret, полный bank account number или чувствительный authentication material в log не нужны. Для общей базы здесь полезен OWASP Logging Cheat Sheet.
Ценность появляется, когда detection смотрит на последовательность:
new device
-> credential reset
-> payout account changed
-> multiple step-up failures
-> successful step-up
-> large payout
Каждое событие может быть легитимным. Вместе они уже меняют риск. Если команда использует MITRE ATT&CK (а я про нее писал статью ранее), я бы применял его к наблюдаемому поведению атакующего и detection coverage, но не смешивал с CWE/ASVS. Weakness в authorization и adversary technique — разные уровни модели. И риски разные, но все неприятные.
Incident readiness как часть дизайна продукта
Представим, что парни в SOC действительно увидел подозрительный payout. До инцидента должно быть понятно, кто может временно остановить выплаты, кто блокирует session/account, как отозвать credentials, где взять неизменённые audit events, как сверить внутренний ledger с provider и кто принимает решение о customer communication. Это не означает, что Product Security заменяет Incident Response. Его задача — убедиться, что продукт вообще предоставляет технические рычаги для containment и recovery. Kill switch, account hold, key rotation, feature rollback и reconciliation лучше продумать до первого настоящего инцидента. Итогом SoC, CERT нужны как по факту так и по комплаенсу.
9. Findings, release и risk acceptance
После automated scans, review и pentest легко получить десятки findings. Если просто превратить их в десятки одинаковых tickets, Product Security почти не добавила контекста. Сначала я бы нормализовал: duplicate ли это, false positive, production ли asset, достижим ли vulnerable path, есть ли public exposure, какой business impact, существуют ли compensating controls и связан ли finding с реальным attack path. Затем уже определяется priority.
Severity и priority — разные вещи. Severity описывает техническую опасность проблемы. Priority отвечает на вопрос, что организация должна делать с ней сейчас.
Подтверждённый payout authorization bypass — это очевидный immediate/release-blocking риск. Reachable dependency vulnerability в ограниченном internal worker может иметь высокий severity, но другой remediation window. Hardening gap без практического attack path может уйти в backlog. Это не «смягчение security», а нормальная triage-модель.
Иногда риск нельзя разумно устранить к дате release. Тогда нужен risk acceptance, но не в виде кнопки Ignore. Я хочу видеть понятный сценарий риска, affected assets, prerequisites, impact, compensating controls, detection/recovery, owner, дату истечения и trigger для пересмотра.
Например:
Risk:
Legacy reporting endpoint exposes broader data than target model.
**Exposure:**
Authenticated operations users only; no internet route.
**Compensating controls:**
SSO + MFA, restricted network path, audit logging,
quarterly access review.
**Residual impact:**
Unauthorized reporting-data access after compromise
of an internal operations identity.
**Decision:**
Accepted until service migration.
**Owner:**
VP Operations.
**Expires:**
2026-12-15.
Exception без срока имеет неприятную привычку превращаться в архитектуру.
Где здесь Product Security Manager\Lead
Представим, Security предлагает 24-hour cooling-off после добавления нового банковского счёта. Product Security Manager справедливо отвечает: это ухудшит conversion и создаст поддержку для нормальных клиентов.
Ответ «такова security policy» ничего не решает. Лучше положить на стол варианты: полный cooling-off, instant payout после сильного step-up и хороших risk signals, либо instant payout только до определённого лимита с задержкой выше threshold. Затем Product, Fraud, Engineering и Security сравнивают residual risk, UX, detection и recovery. Так выглядит взрослая роль Product Security: не максимизировать количество запретов, а сделать риск понятным и управляемым, не потеряв сам продукт.
10. Что в этом кейсе делает Senior Product Security Engineer
Если посмотреть на весь путь целиком, senior здесь нужен не потому, что знает на двадцать названий scanners больше. Его ценность в том, что он удерживает связь между бизнес-сценарием, архитектурой, реализацией и production.
До разработки он помогает найти critical assets, trust boundaries, invariants и abuse cases. На design review спорит про authorization model, failure modes, third-party trust и blast radius. Во время implementation превращает повторяемые решения в libraries, tests, CI policies и paved roads. Перед release проверяет не «все ли dashboards зелёные», а остался ли material attack path, который делает запуск неприемлемым. После release смотрит на telemetry, exceptions, новые CVE, drift и incidents и возвращает выводы обратно в design.
DevSecOps-инженер в этом же кейсе, скорее всего, глубже возьмёт pipeline, runner isolation, artifact provenance, policy-as-code и deployment controls. AppSec-инженер — API, code, authorization, threat modeling и security testing. Pentester — проверку abuse cases и реальную эксплуатацию предположений. Platform/Cloud Security — Kubernetes и IAM. Product Manager — UX, delivery и business trade-offs. Senior Product Security должен не заменить всех этих людей, а собрать их решения вокруг одного продуктового риска.
Поэтому и метрики лучше выбирать системные. Количество найденных vulnerabilities само по себе почти ничего не говорит. Мне интереснее доля high-risk features, которые прошли security design review до implementation; покрытие critical flows security tests; возраст risk exceptions; time-to-remediate действительно exploitable issues; процент production artifacts с проверяемым provenance; количество privileged workloads и long-lived credentials; false-positive rate; доля defects, пойманных до production; recurrence одного и того же класса ошибок.
Последняя метрика особенно полезна. Если за год команда пять раз нашла один и тот же broken authorization pattern в разных сервисах, проблема уже не в пяти разработчиках. Скорее всего, не хватает общей authorization capability, reference implementation, architecture rule или обучения. Senior чинит систему, которая воспроизводит дефект, а не только очередной дефект.
А какие тулы юзаем?
Их много, и выбирать стек без контекста бессмысленно. Для небольшого продукта вполне реально начать с комбинации Semgrep/CodeQL для code analysis, Gitleaks или TruffleHog для secrets, Trivy/Grype для dependencies и images, Checkov/Trivy для IaC, Syft/CycloneDX для SBOM, Kyverno/Gatekeeper для admission policy, Kubescape/kube-bench для Kubernetes posture, Falco/Tetragon для runtime visibility и DefectDojo для aggregation/workflow.
Коммерческие платформы — Snyk, Checkmarx, Veracode, GitHub Advanced Security, Wiz, Prisma Cloud, Orca, Mend, JFrog и другие — часто покупают не потому, что «open source плохой», а потому что большой организации нужны centralized inventory, correlation, policy, reporting, integrations, support и единый operating model. Ну, а в бесплатном ПО этого, как понимаешь, друг, нихера нет:)
Иными словами, инструменты появляются после модели риска, а не вместо неё.
Итог
Если убрать названия технологий, весь наш fintech-кейс можно свернуть в несколько вопросов:
- Что нельзя позволить атакующему? Он не должен распоряжаться чужими деньгами, нарушать финансовую истину, обходить critical approval, внедрять код в trusted build или превращать одну локальную компрометацию во всю платформу.
- Где это может сломаться? В authorization, business logic, async workflow, third-party integration, CI/CD, dependency, Kubernetes, IAM или admin process.
- Что мы строим против этого? Не абстрактную «security», а конкретные controls с владельцами и понятными failure modes.
- Как докажем, что они работают? Automation, abuse tests, architecture review, policy-as-code, pentest и ручная проверка там, где automation не понимает бизнес-смысл.
- Что произойдёт, если control всё-таки обойдут? Нужны telemetry, detection, containment и recovery.
- Можно ли выпускать продукт? Это уже risk decision, в котором техническая severity — только одна часть контекста.
В итоге получается вполне приземлённая цепочка:
Business asset / invariant
-> abuse case
-> security requirement
-> architecture / control
-> validation
-> runtime signal
-> risk decision
-> feedback into product
Для меня именно это и есть Product Security в практическом смысле: не отдельный этап SDLC и не набор scanners, а инженерная система, которая держит связь между тем, что важно продукту, тем, как его реально атакуют, и тем, как команда принимает технические решения от первого design review до production incident. Этим я и занимаюсь:)
P.S.
Если хочется продолжить от этого кейса уже по отдельным доменам — threat modeling, API Security, AppSec, DevSecOps, Cloud/Kubernetes, Secure SDLC или leadership operating model — я собираю такие материалы в Product Security Knowledge Base. Но сам принцип я бы оставил тем же: сначала понять продукт и его инварианты, а уже потом выбирать framework, control и инструмент.












Top comments (0)