local-triage 0.0.0-stage → 0.10.0-dev.32
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +90 -2
- package/THIRD-PARTY-NOTICES.md +48 -0
- package/app/__init__.py +3 -0
- package/app/affiliation.py +137 -0
- package/app/ask.py +300 -0
- package/app/build_info.py +98 -0
- package/app/capec.py +168 -0
- package/app/capec_view.py +27 -0
- package/app/codecmp.py +59 -0
- package/app/config.py +411 -0
- package/app/context.py +1451 -0
- package/app/cvss.py +357 -0
- package/app/db.py +6234 -0
- package/app/defect.py +670 -0
- package/app/defect_check.py +323 -0
- package/app/defect_drafts.py +612 -0
- package/app/defect_dto.py +149 -0
- package/app/defect_fields.py +248 -0
- package/app/defect_form.py +124 -0
- package/app/defect_links.py +107 -0
- package/app/defect_local_text.py +103 -0
- package/app/defect_references.py +164 -0
- package/app/defect_where.py +147 -0
- package/app/ecosystem.py +51 -0
- package/app/executors.py +660 -0
- package/app/feeds.py +1231 -0
- package/app/guard.py +164 -0
- package/app/hub_block_builder.py +200 -0
- package/app/hub_block_version.py +220 -0
- package/app/hub_defects.py +4469 -0
- package/app/hub_effects.py +421 -0
- package/app/hub_entity_versions.py +108 -0
- package/app/hub_import.py +2054 -0
- package/app/hub_onboarding.py +114 -0
- package/app/hub_ops.py +330 -0
- package/app/hub_pull.py +1195 -0
- package/app/hub_state.py +255 -0
- package/app/hub_status.py +237 -0
- package/app/hub_sync.py +619 -0
- package/app/hub_sync_api.py +241 -0
- package/app/hub_sync_compare.py +1054 -0
- package/app/hub_sync_contract.py +75 -0
- package/app/hub_template_model.py +74 -0
- package/app/hub_text_scale.py +159 -0
- package/app/journal.py +250 -0
- package/app/llm.py +850 -0
- package/app/llm_chat.py +596 -0
- package/app/llm_http.py +319 -0
- package/app/llm_messages.py +401 -0
- package/app/llm_net.py +764 -0
- package/app/llm_ollama.py +571 -0
- package/app/lockfile.py +505 -0
- package/app/logsafe.py +54 -0
- package/app/main.py +367 -0
- package/app/mask_display.py +132 -0
- package/app/masking.py +814 -0
- package/app/metrics.py +194 -0
- package/app/model_traffic.py +519 -0
- package/app/models.py +483 -0
- package/app/navigation.py +121 -0
- package/app/osv.py +279 -0
- package/app/package_identity.py +189 -0
- package/app/package_transition.py +824 -0
- package/app/profile_gate.py +71 -0
- package/app/prompts.py +1108 -0
- package/app/provider_keys.py +189 -0
- package/app/providers.py +511 -0
- package/app/routes/__init__.py +10 -0
- package/app/routes/api.py +153 -0
- package/app/routes/capec.py +186 -0
- package/app/routes/common.py +407 -0
- package/app/routes/components.py +1499 -0
- package/app/routes/cwe.py +168 -0
- package/app/routes/decision_selected.py +153 -0
- package/app/routes/defect_add.py +223 -0
- package/app/routes/defect_card_routes.py +363 -0
- package/app/routes/defect_selected.py +342 -0
- package/app/routes/feeds.py +155 -0
- package/app/routes/findings.py +2736 -0
- package/app/routes/hub.py +402 -0
- package/app/routes/hub_bulk.py +288 -0
- package/app/routes/hub_defect_routes.py +1945 -0
- package/app/routes/hub_status_routes.py +1132 -0
- package/app/routes/hub_sync_routes.py +463 -0
- package/app/routes/journal.py +132 -0
- package/app/routes/projects.py +1601 -0
- package/app/routes/providers.py +336 -0
- package/app/routes/references.py +26 -0
- package/app/routes/runs.py +219 -0
- package/app/routes/sca.py +2722 -0
- package/app/routes/settings.py +163 -0
- package/app/run_errors.py +151 -0
- package/app/sca.py +1662 -0
- package/app/sca_contract.py +1289 -0
- package/app/sca_research.py +1089 -0
- package/app/sca_research_net.py +1007 -0
- package/app/sca_text.py +965 -0
- package/app/serve.py +70 -0
- package/app/settings_store.py +262 -0
- package/app/static/app.css +2802 -0
- package/app/static/app.js +3772 -0
- package/app/static/capec-license.txt +9 -0
- package/app/static/favicon.svg +1 -0
- package/app/static/fonts/Golos-Text_DemiBold.woff2 +0 -0
- package/app/static/fonts/Golos-Text_Regular.woff2 +0 -0
- package/app/static/fonts/OFL.txt +90 -0
- package/app/static/navigation.js +234 -0
- package/app/static/observability.js +121 -0
- package/app/static/theme.js +49 -0
- package/app/storage/__init__.py +16 -0
- package/app/storage/local_state.py +246 -0
- package/app/storage/migrate.py +110 -0
- package/app/storage/migrations/postgresql/0001_baseline.sql +896 -0
- package/app/storage/migrations/postgresql/0002_feeds_and_secrets.sql +55 -0
- package/app/storage/migrations/postgresql/0003_project_mask_display.sql +5 -0
- package/app/storage/migrations/postgresql/0004_package_identity.sql +36 -0
- package/app/storage/postgresql.py +573 -0
- package/app/storage/schema.py +619 -0
- package/app/storage/sql.py +57 -0
- package/app/storage/tools.py +254 -0
- package/app/telemetry.py +307 -0
- package/app/templates/base.html +91 -0
- package/app/templates/capec/context.html +3 -0
- package/app/templates/capec/detail.html +27 -0
- package/app/templates/capec/index.html +128 -0
- package/app/templates/components/_archive.html +11 -0
- package/app/templates/components/archived.html +19 -0
- package/app/templates/components/batch.html +35 -0
- package/app/templates/components/detail.html +332 -0
- package/app/templates/components/index.html +338 -0
- package/app/templates/components/research_preview.html +80 -0
- package/app/templates/components/research_run.html +54 -0
- package/app/templates/cwe/bdu.html +56 -0
- package/app/templates/cwe/detail.html +233 -0
- package/app/templates/cwe/index.html +97 -0
- package/app/templates/error.html +8 -0
- package/app/templates/feeds/index.html +65 -0
- package/app/templates/findings/card.html +639 -0
- package/app/templates/findings/decision_selected.html +41 -0
- package/app/templates/findings/defect_add.html +46 -0
- package/app/templates/findings/defect_selected.html +47 -0
- package/app/templates/findings/list.html +153 -0
- package/app/templates/findings/send_selected.html +53 -0
- package/app/templates/findings/trace.html +72 -0
- package/app/templates/journal/detail.html +19 -0
- package/app/templates/journal/index.html +19 -0
- package/app/templates/macros.html +440 -0
- package/app/templates/navigation-fields.html +1 -0
- package/app/templates/navigation.html +11 -0
- package/app/templates/projects/_identity_summary.html +42 -0
- package/app/templates/projects/defect_card.html +153 -0
- package/app/templates/projects/defect_create_preview.html +17 -0
- package/app/templates/projects/defect_fields_diff.html +6 -0
- package/app/templates/projects/defect_fields_form.html +40 -0
- package/app/templates/projects/defect_references.html +17 -0
- package/app/templates/projects/defect_sync_preview.html +28 -0
- package/app/templates/projects/defect_update_actions.html +6 -0
- package/app/templates/projects/defect_update_preview.html +24 -0
- package/app/templates/projects/defects.html +126 -0
- package/app/templates/projects/delete.html +31 -0
- package/app/templates/projects/external.html +61 -0
- package/app/templates/projects/folders.html +64 -0
- package/app/templates/projects/hub_accepted.html +10 -0
- package/app/templates/projects/hub_assignment.html +50 -0
- package/app/templates/projects/hub_pending.html +20 -0
- package/app/templates/projects/hub_pending_list.html +17 -0
- package/app/templates/projects/hub_state_note.html +23 -0
- package/app/templates/projects/hub_step_note.html +5 -0
- package/app/templates/projects/hub_sync.html +105 -0
- package/app/templates/projects/hub_sync_confirm.html +32 -0
- package/app/templates/projects/hub_sync_worker.html +5 -0
- package/app/templates/projects/hub_text_rules.html +64 -0
- package/app/templates/projects/identity_report.html +74 -0
- package/app/templates/projects/list.html +90 -0
- package/app/templates/projects/project.html +433 -0
- package/app/templates/reference-missing.html +14 -0
- package/app/templates/runs/run.html +166 -0
- package/app/templates/sca/card.html +476 -0
- package/app/templates/sca/index.html +321 -0
- package/app/templates/settings/hub_url.html +31 -0
- package/app/templates/settings/index.html +216 -0
- package/app/templates/settings/provider.html +229 -0
- package/app/templates/settings/providers.html +37 -0
- package/app/templates/worklists.html +52 -0
- package/app/textsafe.py +117 -0
- package/app/timing.py +245 -0
- package/app/triage.py +1743 -0
- package/app/view.py +430 -0
- package/app/worklists.py +204 -0
- package/examples/demo/demo-hub-report-v2.xlsx +0 -0
- package/examples/demo/demo-hub-report.xlsx +0 -0
- package/examples/demo/repos/billing-core/pom.xml +30 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/Invoice.java +9 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/InvoiceRepository.java +51 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/InvoiceStatus.java +11 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/config/DatabaseSettings.java +18 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/payment/PaymentTokenService.java +35 -0
- package/examples/demo/repos/billing-core/src/main/java/org/example/billing/web/InvoiceExportController.java +57 -0
- package/examples/demo/repos/catalog-api/catalog_api/__init__.py +1 -0
- package/examples/demo/repos/catalog-api/catalog_api/products.py +24 -0
- package/examples/demo/repos/catalog-api/catalog_api/tasks.py +24 -0
- package/examples/demo/repos/catalog-api/catalog_api/views.py +17 -0
- package/examples/demo/repos/catalog-api/requirements.txt +3 -0
- package/npm/build.json +5 -0
- package/npm/cli.js +346 -0
- package/npm/files.manifest +224 -0
- package/npm/lib/binding.js +64 -0
- package/npm/lib/cluster.js +330 -0
- package/npm/lib/env.js +88 -0
- package/npm/lib/fsx.js +125 -0
- package/npm/lib/http.js +53 -0
- package/npm/lib/metrics.js +73 -0
- package/npm/lib/paths.js +150 -0
- package/npm/lib/pg.js +351 -0
- package/npm/lib/proc.js +101 -0
- package/npm/lib/python.js +133 -0
- package/npm/lib/stand.js +46 -0
- package/npm/lib/supervisor.js +1141 -0
- package/npm/lib/version.js +21 -0
- package/npm/requirements.txt +476 -0
- package/npm-shrinkwrap.json +111 -0
- package/package.json +37 -4
package/app/masking.py
ADDED
|
@@ -0,0 +1,814 @@
|
|
|
1
|
+
"""Маскирование секретов и персональных данных до того, как код попадёт в промпт модели.
|
|
2
|
+
|
|
3
|
+
Главное – mask_text(text, key) -> (текст, счётчики). Найденные значения заменяются плейсхолдерами
|
|
4
|
+
<SECRET_n>, <INN_n>, <SNILS_n>, <PHONE_n>, <EMAIL_n>, <PASSPORT_n>, где n – первые 6 hex HMAC-SHA256(ключ, значение):
|
|
5
|
+
одинаковые значения получают один номер, а исходное значение без ключа не восстановить. Замена идёт внутри строки,
|
|
6
|
+
поэтому число строк и их нумерация не меняются (у приватного ключа PEM и у блока YAML тело заменяется одним номером,
|
|
7
|
+
переводы строк остаются на месте). Счётчики – плоский словарь по типам плейсхолдеров, только ненулевые:
|
|
8
|
+
{"SECRET": 2, "EMAIL": 1}.
|
|
9
|
+
|
|
10
|
+
Что ищется (простые регулярные выражения, без внешних библиотек):
|
|
11
|
+
секреты – приватные ключи PEM (и обрезанные, без строки END); ключи AWS; токены GitHub, GitLab, Slack, JWT, Google,
|
|
12
|
+
Stripe, npm, Яндекса; заголовки Bearer и Basic; имя и пароль в адресе (scheme://user:pass@host);
|
|
13
|
+
значения ключей со словами password, passwd, passphrase, pass, pwd, pw, secret, token, credentials,
|
|
14
|
+
пароль, api_key, private_key, secret_key, access_key, signing_key, encryption_key, master_key, client_key –
|
|
15
|
+
в коде (ключ = "…", setPassword("…"), password.equals("…"), третий аргумент getConnection), в YAML
|
|
16
|
+
(в том числе блоки «|» и «>» и списки под ключом), .properties, .env, XML, Dockerfile (ENV) и в строках
|
|
17
|
+
подключения; строки base64 и hex от 32 знаков с высокой энтропией внутри строковых литералов и после
|
|
18
|
+
«:» или «=»;
|
|
19
|
+
ПДн – ИНН (10 и 12 цифр) и СНИЛС с проверкой контрольной суммы, телефоны +7 и 8, e-mail, паспорт РФ рядом
|
|
20
|
+
со словом «паспорт».
|
|
21
|
+
Маскирование работает с запасом: лишний плейсхолдер на безобидной строке допустим, пропуск секрета – нет.
|
|
22
|
+
|
|
23
|
+
Для находок о жёстко заданных секретах (CWE-798, 259, 321 и родственные – is_credential_finding) этого мало:
|
|
24
|
+
срез такой находки строится с заменой всех строковых литералов (строка срабатывания целиком не скрывается –
|
|
25
|
+
ADR-0117: код приходит уже проверенным на секреты, а имена переменных и настроек нужны модели и человеку)
|
|
26
|
+
(mask_all_literals) – видно устройство кода, но не значения.
|
|
27
|
+
|
|
28
|
+
Ключ HMAC – 32 случайных байта: у приложения в базе (Database.mask_key, ADR-0133), файл (load_or_create_key) – только у инструментов вне приложения: замеры, демо-база, создаётся один раз и никуда не передаётся.
|
|
29
|
+
"""
|
|
30
|
+
|
|
31
|
+
from __future__ import annotations
|
|
32
|
+
|
|
33
|
+
import contextlib
|
|
34
|
+
import contextvars
|
|
35
|
+
import hashlib
|
|
36
|
+
import hmac
|
|
37
|
+
import math
|
|
38
|
+
import os
|
|
39
|
+
import re
|
|
40
|
+
import time
|
|
41
|
+
from collections import Counter
|
|
42
|
+
from pathlib import Path
|
|
43
|
+
|
|
44
|
+
KEY_SIZE = 32
|
|
45
|
+
SECRET_TYPES = ("SECRET",)
|
|
46
|
+
PII_TYPES = ("INN", "SNILS", "PHONE", "EMAIL", "PASSPORT")
|
|
47
|
+
|
|
48
|
+
# Плейсхолдер, уже стоящий в тексте: так считаются замаскированные места в готовом срезе (count_placeholders).
|
|
49
|
+
PLACEHOLDER_RE = re.compile(r"<(SECRET|INN|SNILS|PHONE|EMAIL|PASSPORT)_([0-9a-f]{6})>")
|
|
50
|
+
|
|
51
|
+
|
|
52
|
+
# ============================================================================ ключ HMAC
|
|
53
|
+
|
|
54
|
+
def load_or_create_key(path: Path) -> bytes:
|
|
55
|
+
"""Ключ HMAC для номеров плейсхолдеров. Нет файла – создаёт его один раз (32 случайных байта, права 0600).
|
|
56
|
+
|
|
57
|
+
Файл другой длины – ValueError: молча создавать новый ключ нельзя, иначе у тех же значений сменятся номера.
|
|
58
|
+
"""
|
|
59
|
+
path = Path(path)
|
|
60
|
+
path.parent.mkdir(parents=True, exist_ok=True)
|
|
61
|
+
try:
|
|
62
|
+
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_BINARY", 0), 0o600)
|
|
63
|
+
except FileExistsError:
|
|
64
|
+
pass
|
|
65
|
+
else:
|
|
66
|
+
try:
|
|
67
|
+
os.write(fd, os.urandom(KEY_SIZE))
|
|
68
|
+
finally:
|
|
69
|
+
os.close(fd)
|
|
70
|
+
key = b""
|
|
71
|
+
for _ in range(50): # файл мог только что создать соседний поток: ждём, пока он допишет ключ
|
|
72
|
+
key = path.read_bytes()
|
|
73
|
+
if len(key) >= KEY_SIZE:
|
|
74
|
+
break
|
|
75
|
+
time.sleep(0.02)
|
|
76
|
+
if len(key) != KEY_SIZE:
|
|
77
|
+
raise ValueError(f"Файл ключа маскирования {path.name} повреждён: ожидалось {KEY_SIZE} байта. Удалите его – "
|
|
78
|
+
"будет создан новый ключ, номера плейсхолдеров в новых срезах сменятся.")
|
|
79
|
+
return key
|
|
80
|
+
|
|
81
|
+
|
|
82
|
+
# ============================================================================ плейсхолдеры и счётчики
|
|
83
|
+
|
|
84
|
+
def _number(key: bytes, value: str) -> str:
|
|
85
|
+
"""Номер плейсхолдера: первые 6 hex HMAC-SHA256(key, значение в UTF-8)."""
|
|
86
|
+
return hmac.new(key, value.encode("utf-8"), hashlib.sha256).hexdigest()[:6]
|
|
87
|
+
|
|
88
|
+
|
|
89
|
+
class _Masker:
|
|
90
|
+
"""Выдаёт плейсхолдеры и считает замены по типам. Номер значения считается один раз: у блока YAML или ключа
|
|
91
|
+
PEM одно и то же большое значение заменяется в каждой его строке."""
|
|
92
|
+
|
|
93
|
+
def __init__(self, key: bytes):
|
|
94
|
+
self.key = key
|
|
95
|
+
self.by_type: Counter = Counter()
|
|
96
|
+
self._numbers: dict[str, str] = {}
|
|
97
|
+
|
|
98
|
+
def placeholder(self, kind: str, value: str) -> str:
|
|
99
|
+
self.by_type[kind] += 1
|
|
100
|
+
number = self._numbers.get(value)
|
|
101
|
+
if number is None:
|
|
102
|
+
number = self._numbers[value] = _number(self.key, value)
|
|
103
|
+
label = f"<{kind}_{number}>"
|
|
104
|
+
book = _RECORD.get()
|
|
105
|
+
if book is not None: # две разные строки с одной меткой – значение по метке не восстановить
|
|
106
|
+
book[label] = value if book.get(label, value) == value else None
|
|
107
|
+
return label
|
|
108
|
+
|
|
109
|
+
|
|
110
|
+
# Показ без масок (бэклог 111): значения выданных меток запоминаются только внутри recording() и только в словаре,
|
|
111
|
+
# который получает вызвавший; в базу, журнал, промпт и тексты для Hub они отсюда не попадают.
|
|
112
|
+
_RECORD: contextvars.ContextVar[dict[str, str | None] | None] = contextvars.ContextVar("mask_record", default=None)
|
|
113
|
+
|
|
114
|
+
|
|
115
|
+
@contextlib.contextmanager
|
|
116
|
+
def recording():
|
|
117
|
+
"""Пока открыт, каждая выданная метка записывается со своим значением: {метка: значение}. У двух разных значений
|
|
118
|
+
с одной меткой (совпали первые 6 hex) значение – None."""
|
|
119
|
+
book: dict[str, str | None] = {}
|
|
120
|
+
token = _RECORD.set(book)
|
|
121
|
+
try:
|
|
122
|
+
yield book
|
|
123
|
+
finally:
|
|
124
|
+
_RECORD.reset(token)
|
|
125
|
+
|
|
126
|
+
|
|
127
|
+
def recording_active() -> bool:
|
|
128
|
+
"""Идёт запись значений меток: готовый маскированный текст из памяти брать нельзя – метки должны быть выданы."""
|
|
129
|
+
return _RECORD.get() is not None
|
|
130
|
+
|
|
131
|
+
|
|
132
|
+
def _new_masker(key) -> _Masker:
|
|
133
|
+
if not isinstance(key, (bytes, bytearray)) or len(key) < 16:
|
|
134
|
+
raise ValueError("ключ маскирования – не меньше 16 байт (load_or_create_key)")
|
|
135
|
+
return _Masker(bytes(key))
|
|
136
|
+
|
|
137
|
+
|
|
138
|
+
def _counts(by_type: Counter) -> dict[str, int]:
|
|
139
|
+
return {k: v for k, v in sorted(by_type.items()) if v}
|
|
140
|
+
|
|
141
|
+
|
|
142
|
+
def count_placeholders(text: str) -> dict[str, int]:
|
|
143
|
+
"""Сколько плейсхолдеров в тексте, по типам: {"SECRET": 2, "INN": 1}."""
|
|
144
|
+
return _counts(Counter(m.group(1) for m in PLACEHOLDER_RE.finditer(text or "")))
|
|
145
|
+
|
|
146
|
+
|
|
147
|
+
def _splice(m, group, replacement):
|
|
148
|
+
"""Текст совпадения, где группа group заменена на replacement (остальное – как было, переводы строк целы)."""
|
|
149
|
+
whole = m.group(0)
|
|
150
|
+
a, b = m.start(group) - m.start(0), m.end(group) - m.start(0)
|
|
151
|
+
return whole[:a] + replacement + whole[b:]
|
|
152
|
+
|
|
153
|
+
|
|
154
|
+
def _first_group(m, groups):
|
|
155
|
+
"""Номер первой совпавшей группы из groups (у значения в кавычках три варианта: "…", '…', `…`)."""
|
|
156
|
+
return next(g for g in groups if m.group(g) is not None)
|
|
157
|
+
|
|
158
|
+
|
|
159
|
+
# Значение – не секрет, а ссылка на него или шаблон: ${DB_PASS}, {{ token }}, %(pwd)s, %s, {0}, <password>,
|
|
160
|
+
# параметры запроса SQL (?, :pwd, $1, @pwd), звёздочки. Такие значения не маскируются (как и уже стоящие плейсхолдеры).
|
|
161
|
+
_REFERENCE = re.compile(r"\s*(?:\$\{.*\}|\$\(.*\)|\{\{.*\}\}|#\{.*\}|%\(?\w*\)?[sdr]|\{\w*\}|<[^<>]*>|\?|:\w+"
|
|
162
|
+
r"|\$\d+|@\w+|[*xX•]+)\s*")
|
|
163
|
+
# Пустые и служебные значения в конфигурации и коде: password = null, token: str.
|
|
164
|
+
_NOT_SECRET_WORDS = {"null", "none", "nil", "true", "false", "undefined", "empty", "str", "string", "int", "bool",
|
|
165
|
+
"boolean", "number", "bytes", "any", "object", "unknown", "char", "byte", "long"}
|
|
166
|
+
|
|
167
|
+
|
|
168
|
+
def _is_reference(value: str) -> bool:
|
|
169
|
+
return bool(_REFERENCE.fullmatch(value)) or not value.strip()
|
|
170
|
+
|
|
171
|
+
|
|
172
|
+
# ============================================================================ детекторы секретов
|
|
173
|
+
|
|
174
|
+
# Приватный ключ PEM: маркеры BEGIN и END остаются, в теле каждая строка ключевого материала (base64 от 16 знаков)
|
|
175
|
+
# заменяется одним и тем же плейсхолдером; кавычки, «\n» и «+» кода вокруг остаются на своих строках.
|
|
176
|
+
_PEM = re.compile(r"(-----BEGIN[ A-Z0-9]*PRIVATE KEY(?: BLOCK)?-----)([\s\S]{1,20000}?)"
|
|
177
|
+
r"(-----END[ A-Z0-9]*PRIVATE KEY(?: BLOCK)?-----)")
|
|
178
|
+
_PEM_BEGIN = re.compile(r"-----BEGIN[ A-Z0-9]*PRIVATE KEY(?: BLOCK)?-----")
|
|
179
|
+
_KEY_MATERIAL = re.compile(r"[A-Za-z0-9+/=]{40,}")
|
|
180
|
+
_KEY_LINE = re.compile(r"(?<!\\)[A-Za-z0-9+/=]{16,}") # не с «n» после «\»: экранирование «\n» остаётся целым
|
|
181
|
+
# Строка тела ключа без END (обрезанный ключ): base64 от 16 знаков, вокруг – кавычки, «\n», «+» кода.
|
|
182
|
+
_PEM_BODY_LINE = re.compile(r"[ \t\"'`+]*(?:[A-Za-z0-9+/=]{16,})(?:\\n)?[ \t\"'`+;,]*\r?")
|
|
183
|
+
|
|
184
|
+
# Имя и пароль в адресе: scheme://user:pass@host -> scheme://<SECRET_n>@host. Пароль – до последнего «@», за
|
|
185
|
+
# которым идёт хост: в пароле бывают «/», «#», «?» и «@».
|
|
186
|
+
_URL_CREDENTIALS = re.compile(r"\b([a-z][a-z0-9+.-]{0,30}://)([^\s/?#@:'\"`<>]{1,200}:[^\s'\"`<>]{0,500})@"
|
|
187
|
+
r"(?=[A-Za-z0-9.\-\[\]:]+(?:[/?#'\"`<>\s,;)]|$))", re.I)
|
|
188
|
+
|
|
189
|
+
# Токены с узнаваемым началом.
|
|
190
|
+
_TOKENS = re.compile(
|
|
191
|
+
r"(?<![A-Za-z0-9_])(?:"
|
|
192
|
+
r"(?:AKIA|ASIA)[0-9A-Z]{16}" # AWS access key ID
|
|
193
|
+
r"|gh[pousr]_[A-Za-z0-9]{36,255}|github_pat_[A-Za-z0-9_]{22,255}" # GitHub
|
|
194
|
+
r"|gl(?:pat|dt|rt|cbt|ptt)-[A-Za-z0-9_-]{20,}" # GitLab
|
|
195
|
+
r"|xox[abprs]-[A-Za-z0-9-]{10,}" # Slack
|
|
196
|
+
r"|eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]*" # JWT
|
|
197
|
+
r"|AIza[0-9A-Za-z_-]{35}" # Google API key
|
|
198
|
+
r"|(?:sk|rk)_live_[0-9A-Za-z]{20,}" # Stripe
|
|
199
|
+
r"|npm_[A-Za-z0-9]{36}" # npm
|
|
200
|
+
r"|y0_[A-Za-z0-9_-]{40,}|AQVN[A-Za-z0-9_-]{35,}" # Яндекс OAuth, ключ Yandex Cloud API
|
|
201
|
+
r")(?![A-Za-z0-9_])")
|
|
202
|
+
|
|
203
|
+
# Заголовок авторизации: Bearer <токен>, Basic <base64> (в токене должна быть цифра – иначе это просто слово).
|
|
204
|
+
_AUTH_HEADER = re.compile(r"\b(?:bearer|basic)[ \t]+([A-Za-z0-9._~+/-]{16,}=*)", re.I)
|
|
205
|
+
|
|
206
|
+
# Имя ключа со словом-секретом (apiKey, X-Api-Key, db.password, DB_PASS, JWT_SIGNING_KEY, …). Длина вокруг слова
|
|
207
|
+
# ограничена: иначе на длинных строках из точек и слов перебор становится квадратичным.
|
|
208
|
+
_KEY_WORDS = (r"(?:pass(?:word|wd|phrase)?|pwd|pw|secret|token|credentials?|пароль"
|
|
209
|
+
r"|(?:api|private|secret|access|signing|encryption|master|client)[_-]?key)")
|
|
210
|
+
_KEY_NAME = r"[A-Za-z0-9_.-]{0,64}" + _KEY_WORDS + r"[A-Za-z0-9_.-]{0,64}"
|
|
211
|
+
_KEY_NAME_XML = r"[A-Za-z0-9_.:-]{0,64}" + _KEY_WORDS + r"[A-Za-z0-9_.:-]{0,64}"
|
|
212
|
+
_KEY_START = r"(?<![A-Za-z0-9_.-])"
|
|
213
|
+
|
|
214
|
+
# Значение в кавычках (группы: "…", '…', `…`). Экранированная кавычка внутри допускается. В '…' не бывает «"»,
|
|
215
|
+
# в `…` – никаких кавычек: так строка SQL вида "... password = '" + pwd + "'" не маскируется, и путь данных
|
|
216
|
+
# в ней остаётся виден.
|
|
217
|
+
_QUOTED = (r"(?:\"((?:\\.|[^\"\\`\r\n]){1,4000})\""
|
|
218
|
+
r"|'((?:\\.|[^'\"\\`\r\n]){1,4000})'"
|
|
219
|
+
r"|`((?:\\.|[^`'\"\\\r\n]){1,4000})`)")
|
|
220
|
+
# Необязательный тип перед присваиванием: val password: String = "…", password: str = "…",
|
|
221
|
+
# let token: &'static str = "…", secret: Option<&str> = ….
|
|
222
|
+
_TYPE_HINT = r"(?::[ \t]*[&*'(\[A-Za-z_][^=\r\n;{}]{0,60}?[ \t]*(?==))?"
|
|
223
|
+
_ASSIGN = r"[\"']?\]?[ \t]*" + _TYPE_HINT + r"(?::=|=>|=|:)[ \t]*"
|
|
224
|
+
# Префикс строки перед кавычкой: r"…", b'…', f"…", rb"…" (Python), $"…", @"…" (C#).
|
|
225
|
+
_PREFIX = r"(?:[rRbBuUfF$@]{1,3}(?=[\"'`]))?"
|
|
226
|
+
|
|
227
|
+
# ключ = "значение" (а также : := => и ключ в кавычках, как в JSON, или в скобках: $cfg['db_password'] => '…').
|
|
228
|
+
_KV_QUOTED = re.compile(_KEY_START + r"[\"']?(" + _KEY_NAME + r")" + _ASSIGN + _PREFIX + _QUOTED, re.I)
|
|
229
|
+
# Значение после ключа-секрета длиннее предела _QUOTED: скрывается всё от кавычки до конца строки – предел разбора
|
|
230
|
+
# не должен оставлять открытым ни значение, ни его хвост за экранированной кавычкой.
|
|
231
|
+
_KV_HUGE = re.compile(_KEY_START + r"[\"']?(" + _KEY_NAME + r")" + _ASSIGN + _PREFIX
|
|
232
|
+
+ r"(?:\"((?:\\.|[^\"\\\r\n]){4000}[^\r\n]*)|'((?:\\.|[^'\\\r\n]){4000}[^\r\n]*)"
|
|
233
|
+
r"|`((?:\\.|[^`\\\r\n]){4000}[^\r\n]*))", re.I)
|
|
234
|
+
# ключ = 'значение' с двойной кавычкой внутри ('demo"secret'): _QUOTED такие не берёт ради строк SQL вида
|
|
235
|
+
# "… password = '" + pwd + "'", поэтому здесь значение-склейка ("…" + x + "…") пропускается отдельно.
|
|
236
|
+
_KV_SINGLE = re.compile(_KEY_START + r"[\"']?(" + _KEY_NAME + r")" + _ASSIGN + _PREFIX
|
|
237
|
+
+ r"'((?:\\.|[^'\\\r\n]){1,4000})'", re.I)
|
|
238
|
+
_CONCAT = re.compile(r"\"[ \t]*\+|\+[ \t]*\"")
|
|
239
|
+
# Незакрытое значение после ключа-секрета: password = "значение до конца строки (одно слово, без пробелов).
|
|
240
|
+
_KV_OPEN = re.compile(_KEY_START + r"[\"']?(" + _KEY_NAME + r")" + _ASSIGN + _PREFIX
|
|
241
|
+
+ r"[\"'`]([^\s\"'`]{4,})[ \t]*\r?$", re.I | re.M)
|
|
242
|
+
# ключ = """…""" (Python, текстовый блок Java) или `…` (шаблонная строка JS): значение бывает на нескольких строках;
|
|
243
|
+
# экранированная кавычка внутри значения его не заканчивает.
|
|
244
|
+
_KV_BLOCK = re.compile(_KEY_START + r"[\"']?(" + _KEY_NAME + r")" + _ASSIGN
|
|
245
|
+
+ r"[rRbBuUfF]{0,2}(\"\"\"|'''|`)((?:\\[\s\S]|(?!\2)[^\\])*\\?)(?:\2|\Z)", re.I)
|
|
246
|
+
# ключ = "значение" – кавычки записаны HTML-сущностями (шаблоны, строка кода из выгрузки); ключ тоже бывает
|
|
247
|
+
# в таких кавычках, а внутри значения – другие сущности (&).
|
|
248
|
+
_ENTITY_QUOTE = r"&(?:quot|apos|#34|#39|#x22|#x27);"
|
|
249
|
+
_KV_ENTITY = re.compile(_KEY_START + r"(" + _KEY_NAME + r")(?:" + _ENTITY_QUOTE + r")?[ \t]*(?::=|=>|=|:)[ \t]*"
|
|
250
|
+
+ _ENTITY_QUOTE + r"(.{1,4000}?)" + _ENTITY_QUOTE, re.I)
|
|
251
|
+
# Заголовок Authorization: значение в кавычках или после «Authorization:» маскируется всегда, даже без цифр и
|
|
252
|
+
# короткое (Basic с base64 из одних букв, токен из букв); у Digest – всё до конца строки. Переменная после запятой
|
|
253
|
+
# без кавычек – не значение.
|
|
254
|
+
_AUTH_VALUE_START = r"\bauthorization(?:[\"']?[ \t]*[:=,][ \t]*[\"']|[ \t]*:[ \t]*)"
|
|
255
|
+
_AUTH_SCHEMES = r"(?:bearer|basic|token|digest|negotiate)"
|
|
256
|
+
_AUTH_EXPLICIT = re.compile(_AUTH_VALUE_START + r"(?:(?:bearer|basic|token|negotiate)[ \t]+)?(?!" + _AUTH_SCHEMES
|
|
257
|
+
+ r"\b)([A-Za-z0-9._~+/-]{4,}=*)", re.I)
|
|
258
|
+
_AUTH_DIGEST = re.compile(_AUTH_VALUE_START + r"digest[ \t]+([^\r\n]+)", re.I)
|
|
259
|
+
# "ключ", "значение" – put("password", "…"), setProperty("db.password", "…"), os.environ.get("DB_PWD", "…").
|
|
260
|
+
_KV_PAIR = re.compile(r"([\"'])(" + _KEY_NAME + r")\1[ \t]*,[ \t]*" + _PREFIX + _QUOTED, re.I)
|
|
261
|
+
# Вызов-сеттер или билдер со словом-секретом в имени: setPassword("…"), .password("…"), withApiKey("…") – первый
|
|
262
|
+
# строковый аргумент. Чтение и проверка (getPassword("ключ"), checkPassword) – нет.
|
|
263
|
+
_SETTER = re.compile(r"(?<![\w$])(?!(?:get|read|load|find|lookup|fetch|resolve|has|is|check|validate|verify|encode"
|
|
264
|
+
r"|hash|decode|decrypt|encrypt|compare|match|remove|delete|clear|reset|generate|create|parse"
|
|
265
|
+
r"|print|log|require|expect|assert|contains|mask|hide|prompt|ask|input|show|render)[A-Z_])"
|
|
266
|
+
r"(?:[A-Za-z]{0,24}?)" + _KEY_WORDS + r"[ \t]*\([ \t]*" + _PREFIX + _QUOTED, re.I)
|
|
267
|
+
# Сравнение со строкой: password.equals("…"), pwd == "…", apiToken !== '…', user.getPassword().equals("…").
|
|
268
|
+
# Слово-секрет – в конце имени (token_type == 'dot' в разборщике – не секрет), значение – от 4 знаков.
|
|
269
|
+
_KEY_NAME_END = r"[A-Za-z0-9_.-]{0,64}" + _KEY_WORDS
|
|
270
|
+
_COMPARE = re.compile(_KEY_START + _KEY_NAME_END + r"(?:\(\))?[ \t]*(?:\.[ \t]*equals(?:IgnoreCase)?[ \t]*\("
|
|
271
|
+
r"[ \t]*|[!=]==?[ \t]*)" + _PREFIX + _QUOTED, re.I)
|
|
272
|
+
# "…".equals(password)
|
|
273
|
+
_COMPARE_BACK = re.compile(_QUOTED + r"[ \t]*\.[ \t]*equals(?:IgnoreCase)?[ \t]*\([ \t]*" + _KEY_NAME_END
|
|
274
|
+
+ r"(?:\(\))?[ \t]*\)", re.I)
|
|
275
|
+
# DriverManager.getConnection(url, "user", "пароль") – третий аргумент.
|
|
276
|
+
_GET_CONNECTION = re.compile(r"\bgetConnection[ \t]*\([ \t]*(?:\"[^\"\r\n]*\"|[^,()\"\r\n]{1,300})[ \t]*,[ \t]*"
|
|
277
|
+
r"(?:\"[^\"\r\n]*\"|[^,()\"\r\n]{1,200})[ \t]*,[ \t]*" + _QUOTED)
|
|
278
|
+
# XML: <password>…</password> и <add key="DbPassword" value="…"/>.
|
|
279
|
+
_XML_ELEMENT = re.compile(r"<(" + _KEY_NAME_XML + r")(?:[ \t][^<>\r\n]*)?>([^<\r\n]{1,4000})</\1>", re.I)
|
|
280
|
+
_XML_KEY_VALUE = re.compile(r"\b(?:key|name)[ \t]*=[ \t]*([\"'])" + _KEY_NAME + r"\1[ \t]+value[ \t]*=[ \t]*"
|
|
281
|
+
r"([\"'])([^\"'\r\n]{1,4000})\2", re.I)
|
|
282
|
+
# XML (Hadoop, Spring): <name>db.password</name> <value>…</value> – на одной строке или на соседних.
|
|
283
|
+
_XML_NAME_VALUE = re.compile(r"<name>[ \t]*" + _KEY_NAME_XML + r"[ \t]*</name>[ \t]*(?:\r?\n[ \t]*)?<value>"
|
|
284
|
+
r"([^<\r\n]{1,4000})</value>", re.I)
|
|
285
|
+
# .env и переменные окружения: КЛЮЧ=значение без пробелов вокруг «=» – значение маскируется целиком, даже если оно
|
|
286
|
+
# похоже на имя через точку (DB_PASSWORD=demo.password.value): в .env это не ссылка, а само значение.
|
|
287
|
+
_ENV_ASSIGN = re.compile(r"^([ \t]*(?:export[ \t]+)?([A-Z][A-Z0-9_]{0,100})=)([^\s'\"`#$][^\s'\"`]{0,3999})"
|
|
288
|
+
r"(?:[ \t]+#[^\r\n]*)?[ \t]*\r?$", re.M)
|
|
289
|
+
# Без кавычек до конца строки – .properties, YAML, .env, .npmrc: db.password=…, token: …, export API_KEY=…
|
|
290
|
+
# («|» и «>» в начале значения – указатель блока YAML, он обрабатывается отдельно: _mask_yaml_blocks).
|
|
291
|
+
_KV_LINE = re.compile(_KEY_START + r"(" + _KEY_NAME + r")[ \t]*[:=][ \t]*"
|
|
292
|
+
r"([^\s\"'`#;,(){}<>$%=|][^\s\"'`;,(){}<>]{0,3999})[ \t]*(?:#[^\r\n]*)?\r?$", re.I | re.M)
|
|
293
|
+
# Без кавычек, а за значением – «;», «,», «)», «&» или «|» (.env, shell, строка подключения):
|
|
294
|
+
# PASSWORD=Qw3rty!2024; и export DB_PASSWORD=… && ./run.sh. Слово из одних букв (this.password = password;) –
|
|
295
|
+
# имя переменной, а не секрет: такое значение не маскируется.
|
|
296
|
+
_KV_INLINE = re.compile(_KEY_START + r"(" + _KEY_NAME + r")[ \t]*[:=][ \t]*"
|
|
297
|
+
r"([^\s\"'`#;,(){}<>$%=|&][^\s\"'`;,(){}<>|&]{0,999})(?=[ \t]*[;,)&|])", re.I)
|
|
298
|
+
_PLAIN_WORD = re.compile(r"[A-Za-z_$][A-Za-z_$]*")
|
|
299
|
+
# Dockerfile: ENV POSTGRES_PASSWORD значение
|
|
300
|
+
_DOCKER_ENV = re.compile(r"^([ \t]*ENV[ \t]+" + _KEY_NAME + r"[ \t]+)([^\s=][^\r\n]{0,3999}?)[ \t]*\r?$", re.I | re.M)
|
|
301
|
+
# Командная строка: curl -u user:пароль, mysql -pпароль (пароль сразу за -p).
|
|
302
|
+
_CLI_USER = re.compile(r"(?<!\S)(?:-u|--user)[ \t]+[^\s:'\"]+:([^\s'\"]+)")
|
|
303
|
+
_CLI_MYSQL = re.compile(r"\bmysql(?:dump|admin|import|sh)?\b[^\r\n]*?[ \t]-p([^\s'\"-][^\s'\"]*)")
|
|
304
|
+
# Манифест Kubernetes «kind: Secret»: значения под data: и stringData: – секреты (base64 или открытым текстом).
|
|
305
|
+
_K8S_SECRET = re.compile(r"(?m)^[ \t]*kind[ \t]*:[ \t]*[\"']?Secret[\"']?[ \t]*\r?$")
|
|
306
|
+
_K8S_DATA = re.compile(r"[ \t]*(?:data|stringData)[ \t]*:[ \t]*\r?")
|
|
307
|
+
_DOTTED_NAME = re.compile(r"[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)+") # settings.API_KEY – ссылка, не значение
|
|
308
|
+
# YAML: ключ-секрет без значения (вложенный блок или список ниже) или со значением-блоком «|», «>», «|-», «>-».
|
|
309
|
+
_YAML_KEY = re.compile(r"([ \t]*)(?:-[ \t]+)?[\"']?" + _KEY_NAME + r"[\"']?[ \t]*:[ \t]*(?:([|>][0-9+-]*)[ \t]*)?"
|
|
310
|
+
r"(?:#.*)?\r?", re.I)
|
|
311
|
+
_YAML_ITEM = re.compile(r"([ \t]*-[ \t]+)(?![\[{])(\S.*?)[ \t]*\r?$") # - значение
|
|
312
|
+
_YAML_PAIR = re.compile(r"([ \t]*[\w.-]{1,64}[ \t]*:[ \t]+)(?![|>][0-9+-]*\s*$)(\S.*?)[ \t]*\r?$") # ключ: значение
|
|
313
|
+
# Переменная окружения в манифесте Kubernetes и Compose: «- name: DB_PASSWORD», строкой ниже «value: …».
|
|
314
|
+
_YAML_ENV_NAME = re.compile(r"[ \t]*(?:-[ \t]+)?name[ \t]*:[ \t]*[\"']?" + _KEY_NAME + r"[\"']?[ \t]*\r?", re.I)
|
|
315
|
+
_YAML_ENV_VALUE = re.compile(r"([ \t]*value[ \t]*:[ \t]*)(?![|>][0-9+-]*\s*$)(\S.*?)[ \t]*\r?$")
|
|
316
|
+
|
|
317
|
+
# Строковый литерал на одной строке: "…", '…', `…`. Незакрытый литерал продолжается до конца строки – так разбор
|
|
318
|
+
# линейный даже на строке из одних кавычек. Группы 1–3 – закрывающая кавычка (у незакрытого литерала её нет).
|
|
319
|
+
_LITERAL = re.compile(r"\"(?:\\.|[^\"\\\r\n])*(?:(\")|\\?(?=[\r\n])|\\?\Z)"
|
|
320
|
+
r"|'(?:\\.|[^'\\\r\n])*(?:(')|\\?(?=[\r\n])|\\?\Z)"
|
|
321
|
+
r"|`(?:\\.|[^`\\\r\n])*(?:(`)|\\?(?=[\r\n])|\\?\Z)")
|
|
322
|
+
# Внутри литерала: параметр строки подключения или адреса – Password=…; ?token=…& (без пробелов вокруг «=»:
|
|
323
|
+
# с пробелами это скорее текст SQL вида «PASSWORD = password_», его не трогаем).
|
|
324
|
+
_CONN_PARAM = re.compile(r"(?<![A-Za-z0-9_.-])" + _KEY_NAME + r"=([^;&\"'`\s<>]{1,1000})", re.I)
|
|
325
|
+
# Вне литерала – то же после разделителя строки подключения: jdbc.url=jdbc:sqlserver://db;user=sa;password=…
|
|
326
|
+
_CONN_PARAM_BARE = re.compile(r"(?<=[;?&])[ \t]*" + _KEY_NAME + r"=([^;&\"'`\s<>]{1,1000})", re.I)
|
|
327
|
+
# Внутри литерала: длинная строка из алфавита base64 или hex.
|
|
328
|
+
_RUN = re.compile(r"[A-Za-z0-9+/_=-]{32,}")
|
|
329
|
+
# Вне литерала – та же строка сразу после «:» или «=» (data: в Secret Kubernetes, ключ в .env, хеш в комментарии).
|
|
330
|
+
_RUN_AFTER = re.compile(r"(?<=[:=])([ \t]*)([A-Za-z0-9+/_=-]{32,})")
|
|
331
|
+
_HEX = re.compile(r"[0-9a-fA-F]+")
|
|
332
|
+
# Строка преобразования шифра Java «алгоритм/режим/дополнение» (RSA/ECB/OAEPWithSHA-256AndMGF1Padding) – не ключ,
|
|
333
|
+
# а важная для разбора криптографии подробность; по энтропии её от ключа не отличить.
|
|
334
|
+
_CIPHER_TRANSFORM = re.compile(r"[A-Za-z0-9]+/(?:ECB|CBC|CTR|GCM|CCM|CFB\d*|OFB\d*|PCBC|CTS|OCB|SIV|XTS|NONE)/"
|
|
335
|
+
r"[A-Za-z0-9-]+", re.I)
|
|
336
|
+
|
|
337
|
+
|
|
338
|
+
def _entropy(s: str) -> float:
|
|
339
|
+
"""Энтропия Шеннона в битах на символ."""
|
|
340
|
+
n = len(s)
|
|
341
|
+
return -sum(c / n * math.log2(c / n) for c in Counter(s).values())
|
|
342
|
+
|
|
343
|
+
|
|
344
|
+
def _entropy_threshold(n: int, symbols: int) -> float:
|
|
345
|
+
"""Порог энтропии для строки длины n: ожидаемая энтропия случайной строки из алфавита в symbols знаков
|
|
346
|
+
(с поправкой Миллера – Мэдоу на короткую выборку) минус запас 0,45 бита. Слова, имена классов и пути обычно
|
|
347
|
+
ниже порога, случайные ключи длиной 32–88 – выше."""
|
|
348
|
+
return math.log2(symbols) - (symbols - 1) / (2 * n * math.log(2)) - 0.45
|
|
349
|
+
|
|
350
|
+
|
|
351
|
+
def looks_random(run: str) -> bool:
|
|
352
|
+
"""Строка base64/hex от 32 знаков похожа на ключ: смесь классов символов и энтропия не ниже порога для её длины.
|
|
353
|
+
|
|
354
|
+
Не ключи: маршруты и пути (с «/» в начале и ещё хотя бы одним «/», или с «//») и строки преобразования шифра.
|
|
355
|
+
"""
|
|
356
|
+
path_like = (run.startswith("/") and run.count("/") >= 2) or "//" in run
|
|
357
|
+
if len(run) < 32 or path_like or _CIPHER_TRANSFORM.fullmatch(run):
|
|
358
|
+
return False
|
|
359
|
+
has_digit = any(c.isdigit() for c in run)
|
|
360
|
+
if _HEX.fullmatch(run):
|
|
361
|
+
return has_digit and any(c.isalpha() for c in run) and _entropy(run) >= _entropy_threshold(len(run), 16)
|
|
362
|
+
return (has_digit and any(c.islower() for c in run) and any(c.isupper() for c in run)
|
|
363
|
+
and _entropy(run) >= _entropy_threshold(len(run), 64))
|
|
364
|
+
|
|
365
|
+
|
|
366
|
+
def _mask_pem(text: str, masker: _Masker) -> str:
|
|
367
|
+
def repl(m):
|
|
368
|
+
body = m.group(2).replace("\\n", "\n") # «\n» внутри строкового литерала – тоже граница строки ключа
|
|
369
|
+
if not _KEY_MATERIAL.search(body):
|
|
370
|
+
return m.group(0) # между маркерами нет ключа – это код, который ищет маркеры
|
|
371
|
+
value = "".join(_KEY_LINE.findall(body)) # весь ключ – одно значение, один номер
|
|
372
|
+
masked_body = _KEY_LINE.sub(lambda _: masker.placeholder("SECRET", value), m.group(2))
|
|
373
|
+
return m.group(1) + masked_body + m.group(3)
|
|
374
|
+
|
|
375
|
+
text = _PEM.sub(repl, text)
|
|
376
|
+
if not _PEM_BEGIN.search(text):
|
|
377
|
+
return text
|
|
378
|
+
# Ключ без строки END (обрезан при копировании): тело – непрерывный блок строк base64 сразу после BEGIN.
|
|
379
|
+
lines = text.split("\n")
|
|
380
|
+
for i, line in enumerate(lines):
|
|
381
|
+
if not _PEM_BEGIN.search(line):
|
|
382
|
+
continue
|
|
383
|
+
body = []
|
|
384
|
+
for j in range(i + 1, len(lines)):
|
|
385
|
+
if not _PEM_BODY_LINE.fullmatch(lines[j]):
|
|
386
|
+
break
|
|
387
|
+
body.append(j)
|
|
388
|
+
value = "".join("".join(_KEY_LINE.findall(lines[j].replace("\\n", " "))) for j in body)
|
|
389
|
+
for j in body:
|
|
390
|
+
lines[j] = _KEY_LINE.sub(lambda _, v=value: masker.placeholder("SECRET", v), lines[j])
|
|
391
|
+
return "\n".join(lines)
|
|
392
|
+
|
|
393
|
+
|
|
394
|
+
def _value_repl(masker: _Masker, groups, min_len: int = 1):
|
|
395
|
+
"""Замена значения в совпадении (группа значения – первая совпавшая из groups), если это не ссылка вида ${...}
|
|
396
|
+
и не короче min_len знаков."""
|
|
397
|
+
def repl(m):
|
|
398
|
+
group = _first_group(m, groups)
|
|
399
|
+
value = m.group(group)
|
|
400
|
+
if _is_reference(value) or len(value.strip()) < min_len:
|
|
401
|
+
return m.group(0)
|
|
402
|
+
return _splice(m, group, masker.placeholder("SECRET", value))
|
|
403
|
+
return repl
|
|
404
|
+
|
|
405
|
+
|
|
406
|
+
def _quoted_groups(pattern):
|
|
407
|
+
"""Номера групп значения в кавычках (_QUOTED) – это три последние группы шаблона."""
|
|
408
|
+
n = pattern.groups
|
|
409
|
+
return (n - 2, n - 1, n)
|
|
410
|
+
|
|
411
|
+
|
|
412
|
+
def _block_repl(masker: _Masker):
|
|
413
|
+
"""ключ = \"\"\"…\"\"\": каждая непустая строка значения – один и тот же плейсхолдер, переводы строк на месте."""
|
|
414
|
+
def repl(m):
|
|
415
|
+
value = m.group(3)
|
|
416
|
+
if _is_reference(value) or PLACEHOLDER_RE.fullmatch(value.strip()):
|
|
417
|
+
return m.group(0)
|
|
418
|
+
parts = []
|
|
419
|
+
for k, part in enumerate(value.split("\n")):
|
|
420
|
+
if not part.strip():
|
|
421
|
+
parts.append(part)
|
|
422
|
+
continue
|
|
423
|
+
cr = "\r" if part.endswith("\r") else ""
|
|
424
|
+
indent = "" if k == 0 else part[:_indent_width(part)]
|
|
425
|
+
parts.append(indent + masker.placeholder("SECRET", value) + cr)
|
|
426
|
+
return _splice(m, 3, "\n".join(parts))
|
|
427
|
+
return repl
|
|
428
|
+
|
|
429
|
+
|
|
430
|
+
def _sub_lines_with(text: str, needle: str, pattern, repl) -> str:
|
|
431
|
+
"""pattern.sub только на строках, где есть needle (без учёта регистра): шаблон, который начинается с кавычки,
|
|
432
|
+
не перебирает каждую кавычку длинного файла."""
|
|
433
|
+
if needle not in text.lower():
|
|
434
|
+
return text
|
|
435
|
+
lines = text.split("\n")
|
|
436
|
+
for i, line in enumerate(lines):
|
|
437
|
+
if needle in line.lower():
|
|
438
|
+
lines[i] = pattern.sub(repl, line)
|
|
439
|
+
return "\n".join(lines)
|
|
440
|
+
|
|
441
|
+
|
|
442
|
+
def _mask_quoted_values(text: str, masker: _Masker) -> str:
|
|
443
|
+
"""ключ = "значение", многострочное значение, "ключ", "значение", сеттеры, сравнения, getConnection, XML –
|
|
444
|
+
значение, если это не ссылка."""
|
|
445
|
+
text = _KV_BLOCK.sub(_block_repl(masker), text)
|
|
446
|
+
for pattern in (_KV_QUOTED, _KV_PAIR, _SETTER, _GET_CONNECTION):
|
|
447
|
+
text = pattern.sub(_value_repl(masker, _quoted_groups(pattern)), text)
|
|
448
|
+
text = _KV_HUGE.sub(_value_repl(masker, (2, 3, 4)), text) # длиннее предела: до конца строки
|
|
449
|
+
for pattern in (_KV_OPEN, _KV_ENTITY): # незакрытое, в кавычках-сущностях
|
|
450
|
+
text = pattern.sub(_value_repl(masker, (2,)), text)
|
|
451
|
+
|
|
452
|
+
def single_repl(m): # 'значение' с двойной кавычкой внутри, но не склейка строк SQL
|
|
453
|
+
value = m.group(2)
|
|
454
|
+
if _CONCAT.search(value) or _is_reference(value) or PLACEHOLDER_RE.fullmatch(value.strip()):
|
|
455
|
+
return m.group(0)
|
|
456
|
+
return _splice(m, 2, masker.placeholder("SECRET", value))
|
|
457
|
+
|
|
458
|
+
text = _KV_SINGLE.sub(single_repl, text)
|
|
459
|
+
# сравнение с «.» или «EOF» – не пароль
|
|
460
|
+
text = _COMPARE.sub(_value_repl(masker, _quoted_groups(_COMPARE), min_len=4), text)
|
|
461
|
+
text = _sub_lines_with(text, "equals", _COMPARE_BACK,
|
|
462
|
+
_value_repl(masker, _quoted_groups(_COMPARE_BACK), min_len=4))
|
|
463
|
+
text = _XML_ELEMENT.sub(_value_repl(masker, (2,)), text)
|
|
464
|
+
text = _XML_KEY_VALUE.sub(_value_repl(masker, (3,)), text)
|
|
465
|
+
return _XML_NAME_VALUE.sub(_value_repl(masker, (1,)), text)
|
|
466
|
+
|
|
467
|
+
|
|
468
|
+
def _bare_value_ok(value: str) -> bool:
|
|
469
|
+
"""Значение без кавычек – не секрет: ссылка, служебное слово, имя через точку, тип."""
|
|
470
|
+
return (_is_reference(value) or value.lower() in _NOT_SECRET_WORDS or bool(_DOTTED_NAME.fullmatch(value))
|
|
471
|
+
or bool(re.fullmatch(r"(?:Optional|List|Dict|Union)\[.*\]", value)))
|
|
472
|
+
|
|
473
|
+
|
|
474
|
+
def _mask_line_values(text: str, masker: _Masker, env_style: bool = True) -> str:
|
|
475
|
+
def line_repl(m):
|
|
476
|
+
value = m.group(2)
|
|
477
|
+
if _bare_value_ok(value):
|
|
478
|
+
return m.group(0)
|
|
479
|
+
return _splice(m, 2, masker.placeholder("SECRET", value))
|
|
480
|
+
|
|
481
|
+
def inline_repl(m):
|
|
482
|
+
value = m.group(2)
|
|
483
|
+
if _bare_value_ok(value) or _PLAIN_WORD.fullmatch(value) or re.fullmatch(r"\d{1,3}", value):
|
|
484
|
+
return m.group(0) # имя переменной (this.password = password;) или маленькое число – не секрет
|
|
485
|
+
return _splice(m, 2, masker.placeholder("SECRET", value))
|
|
486
|
+
|
|
487
|
+
def docker_repl(m):
|
|
488
|
+
value = m.group(2)
|
|
489
|
+
return m.group(0) if _bare_value_ok(value) else _splice(m, 2, masker.placeholder("SECRET", value))
|
|
490
|
+
|
|
491
|
+
def env_repl(m):
|
|
492
|
+
value = m.group(3)
|
|
493
|
+
if (not re.search(_KEY_WORDS, m.group(2), re.I) or _is_reference(value)
|
|
494
|
+
or value.lower() in _NOT_SECRET_WORDS):
|
|
495
|
+
return m.group(0)
|
|
496
|
+
return _splice(m, 3, masker.placeholder("SECRET", value))
|
|
497
|
+
|
|
498
|
+
if env_style:
|
|
499
|
+
text = _ENV_ASSIGN.sub(env_repl, text)
|
|
500
|
+
text = _KV_LINE.sub(line_repl, text)
|
|
501
|
+
text = _KV_INLINE.sub(inline_repl, text)
|
|
502
|
+
text = _DOCKER_ENV.sub(docker_repl, text)
|
|
503
|
+
for pattern in (_CONN_PARAM_BARE, _CLI_USER, _CLI_MYSQL):
|
|
504
|
+
text = pattern.sub(_value_repl(masker, (1,)), text)
|
|
505
|
+
return text
|
|
506
|
+
|
|
507
|
+
|
|
508
|
+
def _indent_width(line: str) -> int:
|
|
509
|
+
return len(line) - len(line.lstrip(" \t"))
|
|
510
|
+
|
|
511
|
+
|
|
512
|
+
def _mask_yaml_blocks(text: str, masker: _Masker) -> str:
|
|
513
|
+
"""YAML: значение-блок после ключа-секрета (password: | и >-) и вложенный блок под ключом-секретом без значения
|
|
514
|
+
(secrets:\\n - …, password:\\n value: …). Строки блока маскируются на месте, число строк не меняется."""
|
|
515
|
+
lines = text.split("\n")
|
|
516
|
+
k8s_secret = bool(_K8S_SECRET.search(text))
|
|
517
|
+
i = 0
|
|
518
|
+
while i < len(lines):
|
|
519
|
+
if _YAML_ENV_NAME.fullmatch(lines[i]): # - name: DB_PASSWORD / value: … (первая непустая строка ниже)
|
|
520
|
+
k = next((k for k in range(i + 1, min(i + 4, len(lines))) if lines[k].strip()), None)
|
|
521
|
+
value = _YAML_ENV_VALUE.fullmatch(lines[k]) if k is not None else None
|
|
522
|
+
if value and not _is_reference(value.group(2)) and not PLACEHOLDER_RE.fullmatch(value.group(2)):
|
|
523
|
+
lines[k] = _splice(value, 2, masker.placeholder("SECRET", value.group(2)))
|
|
524
|
+
i += 1
|
|
525
|
+
continue
|
|
526
|
+
m = _YAML_KEY.fullmatch(lines[i])
|
|
527
|
+
if m:
|
|
528
|
+
indent, block = len(m.group(1).expandtabs()), m.group(2)
|
|
529
|
+
elif k8s_secret and _K8S_DATA.fullmatch(lines[i]):
|
|
530
|
+
indent, block = _indent_width(lines[i].expandtabs()), None
|
|
531
|
+
else:
|
|
532
|
+
i += 1
|
|
533
|
+
continue
|
|
534
|
+
body = []
|
|
535
|
+
j = i + 1
|
|
536
|
+
while j < len(lines):
|
|
537
|
+
line = lines[j].rstrip("\r")
|
|
538
|
+
if line.strip() and _indent_width(line.expandtabs()) <= indent:
|
|
539
|
+
break
|
|
540
|
+
if line.strip():
|
|
541
|
+
body.append(j)
|
|
542
|
+
j += 1
|
|
543
|
+
if block: # значение-блок: все строки – одно значение, один номер
|
|
544
|
+
value = "\n".join(lines[k].strip() for k in body)
|
|
545
|
+
for k in body:
|
|
546
|
+
line = lines[k]
|
|
547
|
+
cr = "\r" if line.endswith("\r") else ""
|
|
548
|
+
if not PLACEHOLDER_RE.fullmatch(line.strip()):
|
|
549
|
+
lines[k] = line[:_indent_width(line)] + masker.placeholder("SECRET", value) + cr
|
|
550
|
+
else: # вложенный блок: элементы списка и значения «ключ: значение»
|
|
551
|
+
for k in body:
|
|
552
|
+
item = _YAML_ITEM.fullmatch(lines[k]) or _YAML_PAIR.fullmatch(lines[k])
|
|
553
|
+
if item and not _is_reference(item.group(2)) and not PLACEHOLDER_RE.fullmatch(item.group(2)):
|
|
554
|
+
lines[k] = _splice(item, 2, masker.placeholder("SECRET", item.group(2)))
|
|
555
|
+
i = j if body else i + 1
|
|
556
|
+
return "\n".join(lines)
|
|
557
|
+
|
|
558
|
+
|
|
559
|
+
def _literal_parts(m) -> tuple[str, str, str]:
|
|
560
|
+
"""Совпадение _LITERAL -> (открывающая кавычка, содержимое, закрывающая кавычка или "" у незакрытого)."""
|
|
561
|
+
literal = m.group(0)
|
|
562
|
+
closed = any(m.group(g) is not None for g in (1, 2, 3))
|
|
563
|
+
return literal[0], (literal[1:-1] if closed else literal[1:]), (literal[-1] if closed else "")
|
|
564
|
+
|
|
565
|
+
|
|
566
|
+
def _mask_literals(text: str, masker: _Masker) -> str:
|
|
567
|
+
"""Внутри строковых литералов: параметры строк подключения и длинные случайные строки base64/hex; вне
|
|
568
|
+
литералов – такие же строки сразу после «:» или «=»."""
|
|
569
|
+
def run_repl(m):
|
|
570
|
+
run = m.group(0)
|
|
571
|
+
return masker.placeholder("SECRET", run) if looks_random(run) else run
|
|
572
|
+
|
|
573
|
+
def param_repl(m):
|
|
574
|
+
value = m.group(1)
|
|
575
|
+
if _is_reference(value):
|
|
576
|
+
return m.group(0)
|
|
577
|
+
return _splice(m, 1, masker.placeholder("SECRET", value))
|
|
578
|
+
|
|
579
|
+
def literal_repl(m):
|
|
580
|
+
opening, inner, closing = _literal_parts(m)
|
|
581
|
+
inner = _CONN_PARAM.sub(param_repl, inner)
|
|
582
|
+
inner = _RUN.sub(run_repl, inner)
|
|
583
|
+
return opening + inner + closing
|
|
584
|
+
|
|
585
|
+
def after_repl(m):
|
|
586
|
+
run = m.group(2)
|
|
587
|
+
return m.group(1) + masker.placeholder("SECRET", run) if looks_random(run) else m.group(0)
|
|
588
|
+
|
|
589
|
+
text = _LITERAL.sub(literal_repl, text)
|
|
590
|
+
return _RUN_AFTER.sub(after_repl, text)
|
|
591
|
+
|
|
592
|
+
|
|
593
|
+
def _mask_secrets(text: str, masker: _Masker, env_style: bool = True) -> str:
|
|
594
|
+
text = _mask_pem(text, masker)
|
|
595
|
+
text = _URL_CREDENTIALS.sub(lambda m: _splice(m, 2, masker.placeholder("SECRET", m.group(2))), text)
|
|
596
|
+
text = _TOKENS.sub(lambda m: masker.placeholder("SECRET", m.group(0)), text)
|
|
597
|
+
|
|
598
|
+
def auth_repl(m):
|
|
599
|
+
if not any(c.isdigit() for c in m.group(1)):
|
|
600
|
+
return m.group(0)
|
|
601
|
+
return _splice(m, 1, masker.placeholder("SECRET", m.group(1)))
|
|
602
|
+
|
|
603
|
+
for pattern in (_AUTH_DIGEST, _AUTH_EXPLICIT):
|
|
604
|
+
text = pattern.sub(lambda m: _splice(m, 1, masker.placeholder("SECRET", m.group(1))), text)
|
|
605
|
+
text = _AUTH_HEADER.sub(auth_repl, text)
|
|
606
|
+
text = _mask_quoted_values(text, masker)
|
|
607
|
+
text = _mask_literals(text, masker)
|
|
608
|
+
text = _mask_yaml_blocks(text, masker)
|
|
609
|
+
return _mask_line_values(text, masker, env_style)
|
|
610
|
+
|
|
611
|
+
|
|
612
|
+
# ============================================================================ детекторы ПДн
|
|
613
|
+
|
|
614
|
+
# E-mail (до цифровых правил: иначе цифры из адреса ушли бы в ИНН и адрес остался бы виден наполовину).
|
|
615
|
+
_EMAIL = re.compile(r"(?<![\w.%+-])[\w.%+-]+@[\w-]+(?:\.[\w-]+)*\.[^\W\d_]{2,}(?![\w-])")
|
|
616
|
+
# Паспорт РФ: слово «паспорт» (или passport), затем в пределах 40 знаков серия (4 цифры) и номер (6 цифр).
|
|
617
|
+
_PASSPORT = re.compile(r"(?:паспорт|passport)[^\d\r\n]{0,40}?(\d{2}[ \t]?\d{2}[ \t]*(?:№|N|No\.?|#|-)?[ \t]*\d{6})"
|
|
618
|
+
r"(?!\d)", re.I)
|
|
619
|
+
# СНИЛС: 123-456-789 01, 123 456 789 01 или 11 цифр подряд.
|
|
620
|
+
_SNILS = re.compile(r"(?<![\d.])(\d{3})([- ]?)(\d{3})\2(\d{3})[- ]?(\d{2})(?![\d.]?\d)")
|
|
621
|
+
# Телефон +7 или 8 и ещё 10 цифр: +7 (916) 123-45-67, 8 916 123 45 67, 89161234567.
|
|
622
|
+
_PHONE = re.compile(r"(?<![\d+])(?:\+7|8)[ \t\-(]{0,3}\d{3}[ \t\-)]{0,3}\d{3}[ \t\-]{0,2}\d{2}[ \t\-]{0,2}\d{2}(?!\d)")
|
|
623
|
+
# ИНН: ровно 10 или 12 цифр (не часть числа, не дробная часть, не 0x…).
|
|
624
|
+
_INN = re.compile(r"(?<![\d.])(?<!0[xX])(\d{12}|\d{10})(?![\d.]?\d)")
|
|
625
|
+
|
|
626
|
+
|
|
627
|
+
def _digits(s: str) -> str:
|
|
628
|
+
return "".join(c for c in s if c.isdigit())
|
|
629
|
+
|
|
630
|
+
|
|
631
|
+
def inn_ok(digits: str) -> bool:
|
|
632
|
+
"""ИНН: 10 цифр (организация) или 12 (физическое лицо) с верными контрольными цифрами."""
|
|
633
|
+
if not digits.isdigit() or len(digits) not in (10, 12):
|
|
634
|
+
return False
|
|
635
|
+
d = [int(c) for c in digits]
|
|
636
|
+
|
|
637
|
+
def check(weights):
|
|
638
|
+
return sum(w * x for w, x in zip(weights, d, strict=False)) % 11 % 10 # весов меньше, чем цифр
|
|
639
|
+
|
|
640
|
+
if len(d) == 10:
|
|
641
|
+
return digits[:2] != "00" and check((2, 4, 10, 3, 5, 9, 4, 6, 8)) == d[9]
|
|
642
|
+
return (check((7, 2, 4, 10, 3, 5, 9, 4, 6, 8)) == d[10]
|
|
643
|
+
and check((3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8)) == d[11])
|
|
644
|
+
|
|
645
|
+
|
|
646
|
+
def snils_ok(digits: str) -> bool:
|
|
647
|
+
"""СНИЛС: 11 цифр, контрольное число – по весам 9…1 (определено для номеров больше 001-001-998)."""
|
|
648
|
+
if not digits.isdigit() or len(digits) != 11 or int(digits[:9]) <= 1001998:
|
|
649
|
+
return False
|
|
650
|
+
total = sum(int(c) * w for c, w in zip(digits[:9], range(9, 0, -1), strict=True))
|
|
651
|
+
if total > 101:
|
|
652
|
+
total %= 101
|
|
653
|
+
return (0 if total in (100, 101) else total) == int(digits[9:])
|
|
654
|
+
|
|
655
|
+
|
|
656
|
+
def _phone_value(s: str) -> str:
|
|
657
|
+
d = _digits(s)
|
|
658
|
+
return "7" + d[1:] if d.startswith("8") else d # 8 916 … и +7 916 … – один номер
|
|
659
|
+
|
|
660
|
+
|
|
661
|
+
def _mask_pii(text: str, masker: _Masker) -> str:
|
|
662
|
+
text = _EMAIL.sub(lambda m: masker.placeholder("EMAIL", m.group(0).lower()), text)
|
|
663
|
+
text = _PASSPORT.sub(lambda m: _splice(m, 1, masker.placeholder("PASSPORT", _digits(m.group(1)))), text)
|
|
664
|
+
|
|
665
|
+
def snils_repl(m):
|
|
666
|
+
value = _digits(m.group(0))
|
|
667
|
+
return masker.placeholder("SNILS", value) if snils_ok(value) else m.group(0)
|
|
668
|
+
|
|
669
|
+
text = _SNILS.sub(snils_repl, text)
|
|
670
|
+
text = _PHONE.sub(lambda m: masker.placeholder("PHONE", _phone_value(m.group(0))), text)
|
|
671
|
+
|
|
672
|
+
def inn_repl(m):
|
|
673
|
+
return masker.placeholder("INN", m.group(1)) if inn_ok(m.group(1)) else m.group(0)
|
|
674
|
+
|
|
675
|
+
return _INN.sub(inn_repl, text)
|
|
676
|
+
|
|
677
|
+
|
|
678
|
+
# ============================================================================ главная функция
|
|
679
|
+
|
|
680
|
+
def mask_text(text: str, key: bytes, *, env_style: bool = True) -> tuple[str, dict[str, int]]:
|
|
681
|
+
"""Маскирует секреты и ПДн в тексте; возвращает (текст, счётчики по типам: {"SECRET": 2, "EMAIL": 1}).
|
|
682
|
+
|
|
683
|
+
key – ключ HMAC (bytes, не меньше 16 байт); номер плейсхолдера – первые 6 hex HMAC-SHA256 значения.
|
|
684
|
+
env_style – строки вида КЛЮЧ=значение читаются как .env: значение скрывается целиком, даже если похоже на имя
|
|
685
|
+
через точку. Для исходного кода (там DB_PASSWORD=settings.DB_PASSWORD – ссылка) передавать False.
|
|
686
|
+
Число строк не меняется: каждая замена – внутри своей строки. Маскировать лучше весь файл, а уже потом вырезать
|
|
687
|
+
срез: ключ PEM на границе среза или обрезанный длинный токен иначе не узнаются.
|
|
688
|
+
"""
|
|
689
|
+
masker = _new_masker(key)
|
|
690
|
+
text = str(text or "")
|
|
691
|
+
text = _mask_secrets(text, masker, env_style)
|
|
692
|
+
text = _mask_pii(text, masker)
|
|
693
|
+
return text, _counts(masker.by_type)
|
|
694
|
+
|
|
695
|
+
|
|
696
|
+
# ============================================================================ находки о жёстко заданных секретах
|
|
697
|
+
|
|
698
|
+
# CWE жёстко заданных и открыто хранимых учётных данных и ключей.
|
|
699
|
+
CREDENTIAL_CWES = frozenset({"CWE-798", "CWE-259", "CWE-321", "CWE-522", "CWE-547", "CWE-256", "CWE-257",
|
|
700
|
+
"CWE-260", "CWE-312", "CWE-313", "CWE-314", "CWE-315", "CWE-316", "CWE-526", "CWE-555",
|
|
701
|
+
"CWE-615"})
|
|
702
|
+
_CREDENTIAL_RULE = re.compile(r"password|passwd|парол|secret|секрет|credential|учётн|учетн"
|
|
703
|
+
r"|private[\s_-]*key|закрыт\w*[\s_-]+ключ|api[\s_-]*key", re.I)
|
|
704
|
+
# «Жёстко заданный» сам по себе – не секрет: у правил вида hardcoded_sql_expressions (CWE-89),
|
|
705
|
+
# hardcoded_bind_all_interfaces, hardcoded_tmp_directory строка находки – SQL, адрес или путь, а не секрет.
|
|
706
|
+
# Секретом такую находку делает слово о ключе, токене или учётных данных рядом.
|
|
707
|
+
_HARDCODED_RULE = re.compile(r"hard[\s_-]*cod|жёстко|жестко", re.I)
|
|
708
|
+
_HARDCODED_SECRET_WORD = re.compile(r"key|ключ|token|токен|cred|pass|парол|secret|секрет", re.I)
|
|
709
|
+
|
|
710
|
+
|
|
711
|
+
def is_credential_finding(rule: str, cwe) -> bool:
|
|
712
|
+
"""Находка о секрете в коде: CWE из CREDENTIAL_CWES (cwe – строка или список); в названии правила password,
|
|
713
|
+
пароль, secret, credential, private key, api key; или hardcoded / «жёстко заданный» вместе со словом о ключе,
|
|
714
|
+
токене, пароле или учётных данных. У таких находок сама строка – секрет, и общего маскирования мало."""
|
|
715
|
+
cwes = cwe if isinstance(cwe, (list, tuple, set)) else [cwe]
|
|
716
|
+
if any(str(c or "").strip().upper() in CREDENTIAL_CWES for c in cwes):
|
|
717
|
+
return True
|
|
718
|
+
text = str(rule or "")
|
|
719
|
+
if _CREDENTIAL_RULE.search(text):
|
|
720
|
+
return True
|
|
721
|
+
return bool(_HARDCODED_RULE.search(text) and _HARDCODED_SECRET_WORD.search(text))
|
|
722
|
+
|
|
723
|
+
|
|
724
|
+
def mask_line(line: str, key: bytes) -> tuple[str, int]:
|
|
725
|
+
"""Строка целиком -> отступ + <SECRET_n> (n – HMAC строки без отступа). -> (строка, замен 0 или 1).
|
|
726
|
+
|
|
727
|
+
Уже стоящий плейсхолдер и пустая строка не трогаются."""
|
|
728
|
+
masker = _new_masker(key)
|
|
729
|
+
stripped = line.strip()
|
|
730
|
+
if not stripped or PLACEHOLDER_RE.fullmatch(stripped):
|
|
731
|
+
return line, 0
|
|
732
|
+
cr = "\r" if line.endswith("\r") else ""
|
|
733
|
+
return line[:_indent_width(line)] + masker.placeholder("SECRET", stripped) + cr, 1
|
|
734
|
+
|
|
735
|
+
|
|
736
|
+
def mask_all_literals(text: str, key: bytes) -> tuple[str, int]:
|
|
737
|
+
"""Все непустые строковые литералы "…", '…', `…` на одной строке -> "<SECRET_n>" (кроме уже стоящих
|
|
738
|
+
плейсхолдеров); незакрытый литерал – до конца строки. -> (текст, замен). Для срезов находок о секретах:
|
|
739
|
+
значения скрыты, устройство кода видно."""
|
|
740
|
+
masker = _new_masker(key)
|
|
741
|
+
|
|
742
|
+
def repl(m):
|
|
743
|
+
opening, inner, closing = _literal_parts(m)
|
|
744
|
+
if not inner.strip() or PLACEHOLDER_RE.fullmatch(inner):
|
|
745
|
+
return m.group(0)
|
|
746
|
+
return opening + masker.placeholder("SECRET", inner) + closing
|
|
747
|
+
|
|
748
|
+
text = _LITERAL.sub(repl, str(text or ""))
|
|
749
|
+
return text, masker.by_type["SECRET"]
|
|
750
|
+
|
|
751
|
+
|
|
752
|
+
# Конец текста перед литералом – присваивание ключу-секрету: password = , "api_key": , token := , secret =>;
|
|
753
|
+
# литерал бывает и на следующей строке после «=».
|
|
754
|
+
_ASSIGN_TAIL = re.compile(_KEY_START + r"[\"']?" + _KEY_NAME + r"[\"']?\]?[ \t]*" + _TYPE_HINT
|
|
755
|
+
+ r"(?::=|=>|=|:)\s*"
|
|
756
|
+
# значение по умолчанию: password = process.env.DB_PASS || "…", os.getenv("X") or "…";
|
|
757
|
+
# в скобках – и на следующих строках: password = (\n os.getenv("X")\n or "…"\n)
|
|
758
|
+
# (внутри скобок допускаются вложенные вызовы вроде getenv("X"), но не закрывающая скобка
|
|
759
|
+
# самого присваивания: за ней уже другое выражение)
|
|
760
|
+
+ r"(?:\(\s*(?:(?:[^;=()]|\([^;=()]{0,80}\)){0,160}?(?:\|\||\?\?|\?:|\bor\b)\s*)?"
|
|
761
|
+
+ r"|[^;\r\n=]{0,80}?(?:\|\||\?\?|\?:|\bor\b)[ \t]*)?"
|
|
762
|
+
# обёртка значения: Some("…"), Optional.of("…"), String::from("…"), SecretStr("…")
|
|
763
|
+
+ r"(?:(?:Some|Ok|Optional\.of|String::from|String\.valueOf|SecretStr|SecretString|Secret"
|
|
764
|
+
+ r"|new[ \t]+String)\(\s*)?"
|
|
765
|
+
+ r"[rRbBuUfF$@]{0,3}$", re.I)
|
|
766
|
+
|
|
767
|
+
|
|
768
|
+
_KEY_HINTS = ("pass", "pw", "secret", "token", "credential", "key", "пароль") # быстрый отсев до регулярного выражения
|
|
769
|
+
|
|
770
|
+
|
|
771
|
+
def secret_assignment_before(prefix: str) -> bool:
|
|
772
|
+
"""Текст перед строковым литералом кончается присваиванием ключу со словом-секретом (между «=» и литералом –
|
|
773
|
+
пробелы, переводы строк, скобка или значение по умолчанию через ||, ??, ?:, or). Смотрятся последние 200 знаков:
|
|
774
|
+
на длинной минифицированной строке проверка не становится квадратичной."""
|
|
775
|
+
prefix = prefix[-200:]
|
|
776
|
+
low = prefix.lower()
|
|
777
|
+
return any(hint in low for hint in _KEY_HINTS) and bool(_ASSIGN_TAIL.search(prefix))
|
|
778
|
+
|
|
779
|
+
|
|
780
|
+
# Начало литерала: префиксы строк Python, C++ (u8, L, R) и Rust (b, r, #), строки C# (@, $), затем кавычки.
|
|
781
|
+
_TOKEN_OPEN = re.compile(r"(?:u8|[uUL])?[rRbBuUfF]{0,2}(#*)(?:@\$?|\$@)?(\"\"\"|'''|[\"'`])")
|
|
782
|
+
_CPP_RAW_OPEN = re.compile(r"(?:u8|[uUL])?R\"([^()\\\s]{0,16})\(")
|
|
783
|
+
|
|
784
|
+
|
|
785
|
+
def mask_literal_token(token: str, key: bytes) -> str:
|
|
786
|
+
"""Строковый литерал целиком – с кавычками, возможно многострочный или незакрытый – -> кавычки на месте,
|
|
787
|
+
каждая непустая строка содержимого – один и тот же плейсхолдер (номер – HMAC всего содержимого), переводы строк
|
|
788
|
+
целы. Разделители сырых строк сохраняются: R"метка(…)метка" в C++, r#"…"# в Rust – иначе разбор кода дальше
|
|
789
|
+
литерала сбился бы. Начало литерала не распознано – скрывается всё. Пустой литерал и уже стоящий плейсхолдер
|
|
790
|
+
не трогаются. Для находок о секретах в коде."""
|
|
791
|
+
masker = _new_masker(key)
|
|
792
|
+
raw = _CPP_RAW_OPEN.match(token)
|
|
793
|
+
m = _TOKEN_OPEN.match(token)
|
|
794
|
+
if raw:
|
|
795
|
+
opening, closing_mark = raw.group(0), ")" + raw.group(1) + '"'
|
|
796
|
+
elif m:
|
|
797
|
+
opening, closing_mark = m.group(0), m.group(2) + m.group(1) # у Rust r#"…"# за кавычкой столько же «#»
|
|
798
|
+
else:
|
|
799
|
+
opening, closing_mark = "", ""
|
|
800
|
+
body = token[len(opening):]
|
|
801
|
+
closing = closing_mark if closing_mark and len(body) >= len(closing_mark) and body.endswith(closing_mark) else ""
|
|
802
|
+
if closing:
|
|
803
|
+
body = body[:-len(closing)]
|
|
804
|
+
if not body.strip() or PLACEHOLDER_RE.fullmatch(body.strip()):
|
|
805
|
+
return token
|
|
806
|
+
parts = []
|
|
807
|
+
for k, part in enumerate(body.split("\n")):
|
|
808
|
+
if not part.strip():
|
|
809
|
+
parts.append(part)
|
|
810
|
+
continue
|
|
811
|
+
cr = "\r" if part.endswith("\r") else ""
|
|
812
|
+
indent = "" if k == 0 else part[:_indent_width(part)]
|
|
813
|
+
parts.append(indent + masker.placeholder("SECRET", body) + cr)
|
|
814
|
+
return opening + "\n".join(parts) + closing
|