maskinfly 0.1.1__tar.gz

maskinfly-0.1.1/LICENSE

@@ -0,0 +1,7 @@
+Copyright <2026> <MordantAcid>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

maskinfly-0.1.1/MANIFEST.in

@@ -0,0 +1,5 @@
+include LICENSE
+include README.md
+include pyproject.toml
+include requirements.txt
+recursive-include maskify *.py

maskinfly-0.1.1/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: maskinfly
+Version: 0.1.1
+Summary: Библиотека для маскировки чувствительных данных (пароли, токены, и т.д.) в строках, словарях и списках
+Author-email: MordantAcid <cagej7517@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/MordantAcid/maskifly
+Project-URL: Repository, https://github.com/MordantAcid/maskifly.git
+Keywords: masking,data-masking,privacy,security,pii,secrets
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: pydantic
+Requires-Dist: pydantic>=2.0.0; extra == "pydantic"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pydantic>=2.0.0; extra == "dev"
+Dynamic: license-file
+
+# maskinfly
+
+**maskinfly** — это легковесная библиотека для рекурсивной маскировки чувствительных данных (паролей, токенов, email, номеров карт, SSN, IP-адресов и т.д.) в Python-структурах. Она автоматически обнаруживает и заменяет конфиденциальную информацию в строках, словарях и списках, а также поддерживает аудит всех произведённых замен.
+
+## Возможности
+
+- **Рекурсивная маскировка** — работает с вложенными словарями, списками и другими коллекциями.
+- **Встроенные паттерны** — пароли, JWT, email, номера кредитных карт (регулярное выражение ошибочно, но оставлено для совместимости), SSN, IP-адреса, токены.
+- **Маскировка по имени переменной** — если в коде переменная называется `password`, `api_key` и т.п., её значение будет замаскировано даже без явного паттерна.
+- **Аудит** — логирование причины замены (`pattern`, `varname`, `type`) и пути к значению.
+- **Поддержка `pydantic.SecretStr`** — если установлен Pydantic, объекты `SecretStr` маскируются автоматически.
+- **Простой интерфейс** — функция `mask()` для быстрой маскировки или класс `Masker` для тонкой настройки.
+
+## Установка
+
+```bash
+pip install maskify
+
+git clone https://github.com/MordantAcid/maskifly.git
+
+Для поддержки pydantic.SecretStr установите дополнительную зависимость:
+
+pip install .[pydantic]
+
+Быстрый старт
+
+from maskify import mask
+
+# Маскировка в словаре
+data = {
+    "user": "john",
+    "password": "secret123",
+    "email": "john@example.com"
+}
+masked = mask(data)
+print(masked)
+# {'user': 'john', 'password': '***', 'email': 'john@example.com'}
+
+# Маскировка в строке
+text = "My token is abc123xyz"
+print(mask(text))
+# 'My token is ***'
+
+# Включение аудита (лог будет выведен в stderr)
+mask(data, audit_enabled=True)
+# Вывод в лог: 2025-01-01 12:00:00 - MASKIFY_AUDIT - Значение маски 'password' | reason=pattern | type=str
+
+Использование
+Функция mask()
+Самый простой способ — импортировать mask и передать данные:
+
+result = mask(data, audit_enabled=False, audit_logger=None)
+
+- data — любые данные (str, dict, list и т.д.).
+- audit_enabled — если True, включает логирование аудита.
+- audit_logger — собственный экземпляр AuditLogger (опционально).
+
+Класс Masker
+Для более гибкого управления создайте экземпляр Masker:
+
+from maskify import Masker
+
+masker = Masker(audit_enabled=True)
+masked_data = masker.mask(data)
+
+Параметры конструктора:
+
+- audit_enabled: bool = False
+- audit_logger: Optional[AuditLogger] = None
+
+Метод mask(data, path="") принимает произвольные данные и опциональный строковый путь (используется для аудита).
+
+Аудит: AuditLogger
+По умолчанию аудит пишет в logging.getLogger("maskify.audit") с уровнем INFO и форматированием '%(asctime)s - MASKIFY_AUDIT - %(message)s'. Вы можете передать свой логгер:
+
+import logging
+from maskify import AuditLogger
+
+custom_logger = logging.getLogger("my_audit")
+audit = AuditLogger(logger=custom_logger)
+masker = Masker(audit_enabled=True, audit_logger=audit)
+masker.mask({"secret": "value"})
+
+Маскировка по имени переменной
+Если значение не подошло ни под один паттерн, библиотека пытается определить имя переменной, в которой оно хранится (с помощью inspect). Если имя входит в набор SENSITIVE_VAR_NAMES, значение заменяется на ***.
+
+Чувствительные имена по умолчанию:
+
+password, passwd, pwd, secret, token, api_key, apikey,
+credit_card, creditcard, card_number, ssn, social_security,
+pin, auth, bearer, private_key
+
+Пример:
+
+secret_token = "abc123xyz"
+mask(secret_token)  # -> "***" (переменная называется secret_token)
+
+Работа с pydantic.SecretStr
+Если установлен Pydantic, объекты SecretStr маскируются вне зависимости от содержимого:
+
+from pydantic import SecretStr
+from maskify import mask
+
+secret = SecretStr("real_password")
+masked = mask(secret)  # -> "***"
+
+Требования
+Python ≥ 3.7
+
+Для опциональной поддержки SecretStr: pydantic >= 2.0.0

maskinfly-0.1.1/README.md

@@ -0,0 +1,110 @@
+# maskinfly
+
+**maskinfly** — это легковесная библиотека для рекурсивной маскировки чувствительных данных (паролей, токенов, email, номеров карт, SSN, IP-адресов и т.д.) в Python-структурах. Она автоматически обнаруживает и заменяет конфиденциальную информацию в строках, словарях и списках, а также поддерживает аудит всех произведённых замен.
+
+## Возможности
+
+- **Рекурсивная маскировка** — работает с вложенными словарями, списками и другими коллекциями.
+- **Встроенные паттерны** — пароли, JWT, email, номера кредитных карт (регулярное выражение ошибочно, но оставлено для совместимости), SSN, IP-адреса, токены.
+- **Маскировка по имени переменной** — если в коде переменная называется `password`, `api_key` и т.п., её значение будет замаскировано даже без явного паттерна.
+- **Аудит** — логирование причины замены (`pattern`, `varname`, `type`) и пути к значению.
+- **Поддержка `pydantic.SecretStr`** — если установлен Pydantic, объекты `SecretStr` маскируются автоматически.
+- **Простой интерфейс** — функция `mask()` для быстрой маскировки или класс `Masker` для тонкой настройки.
+
+## Установка
+
+```bash
+pip install maskify
+
+git clone https://github.com/MordantAcid/maskifly.git
+
+Для поддержки pydantic.SecretStr установите дополнительную зависимость:
+
+pip install .[pydantic]
+
+Быстрый старт
+
+from maskify import mask
+
+# Маскировка в словаре
+data = {
+    "user": "john",
+    "password": "secret123",
+    "email": "john@example.com"
+}
+masked = mask(data)
+print(masked)
+# {'user': 'john', 'password': '***', 'email': 'john@example.com'}
+
+# Маскировка в строке
+text = "My token is abc123xyz"
+print(mask(text))
+# 'My token is ***'
+
+# Включение аудита (лог будет выведен в stderr)
+mask(data, audit_enabled=True)
+# Вывод в лог: 2025-01-01 12:00:00 - MASKIFY_AUDIT - Значение маски 'password' | reason=pattern | type=str
+
+Использование
+Функция mask()
+Самый простой способ — импортировать mask и передать данные:
+
+result = mask(data, audit_enabled=False, audit_logger=None)
+
+- data — любые данные (str, dict, list и т.д.).
+- audit_enabled — если True, включает логирование аудита.
+- audit_logger — собственный экземпляр AuditLogger (опционально).
+
+Класс Masker
+Для более гибкого управления создайте экземпляр Masker:
+
+from maskify import Masker
+
+masker = Masker(audit_enabled=True)
+masked_data = masker.mask(data)
+
+Параметры конструктора:
+
+- audit_enabled: bool = False
+- audit_logger: Optional[AuditLogger] = None
+
+Метод mask(data, path="") принимает произвольные данные и опциональный строковый путь (используется для аудита).
+
+Аудит: AuditLogger
+По умолчанию аудит пишет в logging.getLogger("maskify.audit") с уровнем INFO и форматированием '%(asctime)s - MASKIFY_AUDIT - %(message)s'. Вы можете передать свой логгер:
+
+import logging
+from maskify import AuditLogger
+
+custom_logger = logging.getLogger("my_audit")
+audit = AuditLogger(logger=custom_logger)
+masker = Masker(audit_enabled=True, audit_logger=audit)
+masker.mask({"secret": "value"})
+
+Маскировка по имени переменной
+Если значение не подошло ни под один паттерн, библиотека пытается определить имя переменной, в которой оно хранится (с помощью inspect). Если имя входит в набор SENSITIVE_VAR_NAMES, значение заменяется на ***.
+
+Чувствительные имена по умолчанию:
+
+password, passwd, pwd, secret, token, api_key, apikey,
+credit_card, creditcard, card_number, ssn, social_security,
+pin, auth, bearer, private_key
+
+Пример:
+
+secret_token = "abc123xyz"
+mask(secret_token)  # -> "***" (переменная называется secret_token)
+
+Работа с pydantic.SecretStr
+Если установлен Pydantic, объекты SecretStr маскируются вне зависимости от содержимого:
+
+from pydantic import SecretStr
+from maskify import mask
+
+secret = SecretStr("real_password")
+masked = mask(secret)  # -> "***"
+
+Требования
+Python ≥ 3.7
+
+Для опциональной поддержки SecretStr: pydantic >= 2.0.0

maskinfly-0.1.1/maskinfly/__init__.py

@@ -0,0 +1,30 @@
+from maskinfly.masker import Masker
+from maskinfly.audit import AuditLogger
+from typing import Optional
+
+__all__ = [
+    "mask", "AuditLogger", "Masker"
+]
+
+__version__ = "0.1.1"
+
+def mask(data, audit_enabled: bool = False, audit_logger: Optional[AuditLogger] = None):
+    """Основной удобный интерфейс для маскировки данных.
+    
+    Примеры:
+        >>> mask({"user": "john", "password", "secret123"})
+        {'user': 'john', 'password': '***'}
+
+        >>> mask("My token is abc123xyz", audit_enabled=True)
+        'My token is ***'
+
+    Args:
+        data: любые данные (строка, dict, список и т.д.)
+        audit_enabled: включить логирование аудита
+        audit_logger: свой экземпляр AuditLogger (опционально)
+
+    Returns:
+        замаскированная копия данных
+    """
+    masker = Masker(audit_enabled=audit_enabled, audit_logger=audit_logger)
+    return masker.mask(data)

maskinfly-0.1.1/maskinfly/audit.py

@@ -0,0 +1,18 @@
+import logging
+from typing import Optional
+
+class AuditLogger:
+    def __init__(self, logger: Optional[logging.Logger] = None):
+        if logger is None:
+            self.logger = logging.getLogger("maskify.audit")
+            if not self.logger.handlers:
+                handler = logging.StreamHandler()
+                formatter = logging.Formatter('%(asctime)s - MASKIFY_AUDIT - %(message)s')
+                handler.setFormatter(formatter)
+                self.logger.addHandler(handler)
+            self.logger.setLevel(logging.INFO)
+        else:
+            self.logger = logger
+
+    def log(self, path: str, reason: str, value_type: str) -> None:
+        self.logger.info(f"Значение маски '{path}' | reason={reason} | type={value_type}")

maskinfly-0.1.1/maskinfly/masker.py

@@ -0,0 +1,97 @@
+import re
+from typing import Any, Dict, List, Tuple, Optional, Union
+from collections.abc import Mapping, Sequence
+from maskinfly.patterns import PATTERNS, DEFAULT_MASK
+from maskinfly.audit import AuditLogger
+from maskinfly.utils import find_variable_name, SENSITIVE_VAR_NAMES
+
+try:
+    from pydantic import SecretStr
+    HAS_PYDANTIC = True
+except ImportError:
+    HAS_PYDANTIC = False
+    SecretStr = None
+
+class Masker:
+    def __init__(self, audit_enabled: bool = False, audit_logger: Optional[AuditLogger] = None):
+        self.audit_enabled = audit_enabled
+        self.audit = audit_logger or AuditLogger() if audit_enabled else None
+        self.patterns = PATTERNS.copy()
+        self.mask_str = DEFAULT_MASK
+
+    def mask(self, data: Any, path: str = "") -> Any:
+        if data is None:
+            return None
+
+        # Маскировка по типу SecretStr
+        if HAS_PYDANTIC and SecretStr is not None and isinstance(data, SecretStr):
+            if self.audit_enabled and self.audit:
+                self.audit.log(path or "root", "type", "SecretStr")
+            return self.mask_str
+
+        # Маскировка строк
+        if isinstance(data, str):
+            return self.mask_string(data, path)
+
+        # Маскировка словарей
+        if isinstance(data, Mapping):
+            new_dict = {}
+            for key, val in data.items():
+                new_path = f"{path}.{key}" if path else key
+                # Если ключ чувствительный, маскируем значение независимо от его типа
+                if key.lower() in SENSITIVE_VAR_NAMES:
+                    # Маскируем только если это строка или SecretStr
+                    if isinstance(val, str):
+                        masked_val = self.mask_str
+                        if self.audit_enabled and self.audit:
+                            self.audit.log(new_path, "varname", "str")
+                    elif HAS_PYDANTIC and SecretStr is not None and isinstance(val, SecretStr):
+                        masked_val = self.mask_str
+                        if self.audit_enabled and self.audit:
+                            self.audit.log(new_path, "varname", "SecretStr")
+                    else:
+                        # Для нестроковых значений просто рекурсивно маскируем
+                        masked_val = self.mask(val, new_path)
+                    new_dict[key] = masked_val
+                else:
+                    new_dict[key] = self.mask(val, new_path)
+            return new_dict
+
+        # Маскировка последовательностей (кроме строк)
+        if isinstance(data, Sequence) and not isinstance(data, (str, bytes)):
+            return [self.mask(item, f"{path}[i]") for i, item in enumerate(data)]
+
+        # Остальные типы не маскируем
+        return data
+
+    def mask_string(self, value: str, path: str) -> str:
+        masked = value
+        reason = None
+
+        # 1. Паттерны
+        for pattern_name, regex in self.patterns.items():
+            if regex.search(masked):
+                masked = regex.sub(self._replacer, masked)
+                reason = "pattern"
+                break
+
+        # 2. По имени переменной (если еще не замаскировано)
+        if reason is None:
+            var_name = find_variable_name(value, frame_depth=3)
+            if var_name and var_name.lower() in SENSITIVE_VAR_NAMES:
+                masked = self.mask_str
+                reason = "varname"
+
+        # Аудит
+        if self.audit_enabled and reason and masked != value and self.audit:
+            self.audit.log(path, reason, "str")
+
+        return masked
+
+    @staticmethod
+    def _replacer(match: re.Match) -> str:
+        groups = match.groups()
+        if groups:
+            last_group = groups[-1]
+            return match.string[:match.start(len(groups))] + DEFAULT_MASK + match.string[match.end():]
+        return DEFAULT_MASK

maskinfly-0.1.1/maskinfly/patterns.py

@@ -0,0 +1,13 @@
+import re
+
+PATTERNS = {
+    "password": re.compile(r'(?i)(password|passwd|pwd)(\s*[:=]\s*)(\S+)'),
+    "token": re.compile(r'(?i)(token|api_key|apikey)(\s*[:=]\s*)(\S+)'),
+    "credit_card": re.compile(r'\b[\w\.-]+@[\w\.-]+\.\w+\b'),
+    "email": re.compile(r'\b[\w\.-]+@[\w\.-]+\.\w+\b'),
+    "jwt": re.compile(r'eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+'),
+    "ip": re.compile(r'\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b'),
+    "ssn": re.compile(r'\b\d{3}-\d{2}-\d{4}\b'),
+}
+
+DEFAULT_MASK = "***"

maskinfly-0.1.1/maskinfly/utils.py

@@ -0,0 +1,31 @@
+import inspect
+from typing import Any, Optional
+
+def find_variable_name(value: Any, frame_depth: int = 2) -> Optional[str]:
+    frame = inspect.currentframe()
+    try:
+        for _ in range(frame_depth):
+            if frame is None:
+                return None
+            frame = frame.f_back
+        if frame is None:
+            return None
+
+        value_id = id(value)
+        # Сначала ищем в locals
+        for name, val in frame.f_locals.items():
+            if id(val) == value_id:
+                return name
+        # Потом в globals
+        for name, val in frame.f_globals.items():
+            if id(val) == value_id:
+                return name
+    finally:
+        del frame
+    return None
+
+SENSITIVE_VAR_NAMES = {
+    'password', 'passwd', 'pwd', 'secret', 'token', 'api_key', 'apikey',
+    'credit_card', 'creditcard', 'card_number', 'ssn', 'social_security',
+    'pin', 'auth', 'bearer', 'private_key'
+}

maskinfly-0.1.1/maskinfly.egg-info/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: maskinfly
+Version: 0.1.1
+Summary: Библиотека для маскировки чувствительных данных (пароли, токены, и т.д.) в строках, словарях и списках
+Author-email: MordantAcid <cagej7517@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/MordantAcid/maskifly
+Project-URL: Repository, https://github.com/MordantAcid/maskifly.git
+Keywords: masking,data-masking,privacy,security,pii,secrets
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: pydantic
+Requires-Dist: pydantic>=2.0.0; extra == "pydantic"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pydantic>=2.0.0; extra == "dev"
+Dynamic: license-file
+
+# maskinfly
+
+**maskinfly** — это легковесная библиотека для рекурсивной маскировки чувствительных данных (паролей, токенов, email, номеров карт, SSN, IP-адресов и т.д.) в Python-структурах. Она автоматически обнаруживает и заменяет конфиденциальную информацию в строках, словарях и списках, а также поддерживает аудит всех произведённых замен.
+
+## Возможности
+
+- **Рекурсивная маскировка** — работает с вложенными словарями, списками и другими коллекциями.
+- **Встроенные паттерны** — пароли, JWT, email, номера кредитных карт (регулярное выражение ошибочно, но оставлено для совместимости), SSN, IP-адреса, токены.
+- **Маскировка по имени переменной** — если в коде переменная называется `password`, `api_key` и т.п., её значение будет замаскировано даже без явного паттерна.
+- **Аудит** — логирование причины замены (`pattern`, `varname`, `type`) и пути к значению.
+- **Поддержка `pydantic.SecretStr`** — если установлен Pydantic, объекты `SecretStr` маскируются автоматически.
+- **Простой интерфейс** — функция `mask()` для быстрой маскировки или класс `Masker` для тонкой настройки.
+
+## Установка
+
+```bash
+pip install maskify
+
+git clone https://github.com/MordantAcid/maskifly.git
+
+Для поддержки pydantic.SecretStr установите дополнительную зависимость:
+
+pip install .[pydantic]
+
+Быстрый старт
+
+from maskify import mask
+
+# Маскировка в словаре
+data = {
+    "user": "john",
+    "password": "secret123",
+    "email": "john@example.com"
+}
+masked = mask(data)
+print(masked)
+# {'user': 'john', 'password': '***', 'email': 'john@example.com'}
+
+# Маскировка в строке
+text = "My token is abc123xyz"
+print(mask(text))
+# 'My token is ***'
+
+# Включение аудита (лог будет выведен в stderr)
+mask(data, audit_enabled=True)
+# Вывод в лог: 2025-01-01 12:00:00 - MASKIFY_AUDIT - Значение маски 'password' | reason=pattern | type=str
+
+Использование
+Функция mask()
+Самый простой способ — импортировать mask и передать данные:
+
+result = mask(data, audit_enabled=False, audit_logger=None)
+
+- data — любые данные (str, dict, list и т.д.).
+- audit_enabled — если True, включает логирование аудита.
+- audit_logger — собственный экземпляр AuditLogger (опционально).
+
+Класс Masker
+Для более гибкого управления создайте экземпляр Masker:
+
+from maskify import Masker
+
+masker = Masker(audit_enabled=True)
+masked_data = masker.mask(data)
+
+Параметры конструктора:
+
+- audit_enabled: bool = False
+- audit_logger: Optional[AuditLogger] = None
+
+Метод mask(data, path="") принимает произвольные данные и опциональный строковый путь (используется для аудита).
+
+Аудит: AuditLogger
+По умолчанию аудит пишет в logging.getLogger("maskify.audit") с уровнем INFO и форматированием '%(asctime)s - MASKIFY_AUDIT - %(message)s'. Вы можете передать свой логгер:
+
+import logging
+from maskify import AuditLogger
+
+custom_logger = logging.getLogger("my_audit")
+audit = AuditLogger(logger=custom_logger)
+masker = Masker(audit_enabled=True, audit_logger=audit)
+masker.mask({"secret": "value"})
+
+Маскировка по имени переменной
+Если значение не подошло ни под один паттерн, библиотека пытается определить имя переменной, в которой оно хранится (с помощью inspect). Если имя входит в набор SENSITIVE_VAR_NAMES, значение заменяется на ***.
+
+Чувствительные имена по умолчанию:
+
+password, passwd, pwd, secret, token, api_key, apikey,
+credit_card, creditcard, card_number, ssn, social_security,
+pin, auth, bearer, private_key
+
+Пример:
+
+secret_token = "abc123xyz"
+mask(secret_token)  # -> "***" (переменная называется secret_token)
+
+Работа с pydantic.SecretStr
+Если установлен Pydantic, объекты SecretStr маскируются вне зависимости от содержимого:
+
+from pydantic import SecretStr
+from maskify import mask
+
+secret = SecretStr("real_password")
+masked = mask(secret)  # -> "***"
+
+Требования
+Python ≥ 3.7
+
+Для опциональной поддержки SecretStr: pydantic >= 2.0.0

maskinfly-0.1.1/maskinfly.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+maskinfly/__init__.py
+maskinfly/audit.py
+maskinfly/masker.py
+maskinfly/patterns.py
+maskinfly/utils.py
+maskinfly.egg-info/PKG-INFO
+maskinfly.egg-info/SOURCES.txt
+maskinfly.egg-info/dependency_links.txt
+maskinfly.egg-info/requires.txt
+maskinfly.egg-info/top_level.txt
+tests/test_audit.py
+tests/test_init.py
+tests/test_masker.py
+tests/test_patterns.py
+tests/test_utils.py

maskinfly-0.1.1/maskinfly.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

maskinfly-0.1.1/maskinfly.egg-info/requires.txt

@@ -0,0 +1,10 @@
+
+[dev]
+pytest>=7.0.0
+pydantic>=2.0.0
+
+[pydantic]
+pydantic>=2.0.0
+
+[test]
+pytest>=7.0.0

maskinfly-0.1.1/maskinfly.egg-info/top_level.txt

@@ -0,0 +1 @@
+maskinfly

maskinfly-0.1.1/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "maskinfly"
+version = "0.1.1"
+description = "Библиотека для маскировки чувствительных данных (пароли, токены, и т.д.) в строках, словарях и списках"
+readme = "README.md"
+requires-python = ">=3.7"
+license = {text = "MIT"}
+authors = [
+    {name = "MordantAcid", email = "cagej7517@gmail.com"},
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Security",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+keywords = ["masking", "data-masking", "privacy", "security", "pii", "secrets"]
+
+[project.optional-dependencies]
+pydantic = ["pydantic>=2.0.0"]
+test = ["pytest>=7.0.0"]
+dev = ["pytest>=7.0.0", "pydantic>=2.0.0"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["maskinfly*"]
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+testpaths = ["tests"]
+python_files = "test_*.py"
+python_classes = "Test*"
+python_functions = "test_*"
+
+[project.urls]
+
+Homepage = "https://github.com/MordantAcid/maskifly"
+Repository = "https://github.com/MordantAcid/maskifly.git"

maskinfly-0.1.1/requirements.txt

@@ -0,0 +1,5 @@
+# Для дополнительной поддержки SecretStr установите:
+pydantic>=2.0.0
+
+# Для Тестирования
+pytest>=7.0.0

maskinfly-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

maskinfly-0.1.1/tests/test_audit.py

@@ -0,0 +1,26 @@
+import logging
+import pytest
+from maskinfly.audit import AuditLogger
+
+def test_audit_logger_creates_handler():
+    logger = AuditLogger()
+    assert len(logger.logger.handlers) == 1
+    assert isinstance(logger.logger.handlers[0], logging.StreamHandler)
+
+def test_audit_logger_respects_provided_logger():
+    custom_logger = logging.getLogger("custom")
+    custom_logger.handlers.clear()
+    logger = AuditLogger(logger=custom_logger)
+    assert logger.logger is custom_logger
+    assert len(logger.logger.handlers) == 0
+
+def test_audit_logger_log(caplog):
+    caplog.set_level(logging.INFO, logger="maskify.audit")
+    logger = AuditLogger()
+    logger.log("user.password", "pattern", "str")
+
+    assert len(caplog.records) == 1
+    record = caplog.records[0]
+    assert "Значение маски 'user.password'" in record.message
+    assert "reason=pattern" in record.message
+    assert "type=str" in record.message

maskinfly-0.1.1/tests/test_init.py

@@ -0,0 +1,28 @@
+import pytest
+from unittest.mock import patch
+from maskinfly import mask, Masker, AuditLogger, __version__
+
+def test_mask_function_with_dict():
+    result = mask({"user": "alice", "password": "pass123"})
+    assert result["password"] == "***"
+    assert result["user"] == "alice"
+
+def test_mask_function_with_string():
+    jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U"
+    result = mask(f"My token is {jwt}")
+    assert result == "My token is ***"
+
+def test_mask_function_with_audit(caplog):
+    caplog.set_level("INFO", logger="maskify.audit")
+    mask({"secret": "abc"}, audit_enabled=True)
+    assert len(caplog.records) > 0
+    record = caplog.records[0]
+    assert "Значение маски 'secret'" in record.message
+    assert "reason=varname" in record.message
+    assert "type=str" in record.message
+
+def test_mask_function_custom_audit_logger():
+    custom_logger = AuditLogger()
+    with patch.object(custom_logger, "log") as mock_log:
+        mask("token=xyz", audit_enabled=True, audit_logger=custom_logger)
+        mock_log.assert_called()

maskinfly-0.1.1/tests/test_masker.py

@@ -0,0 +1,65 @@
+import pytest
+from unittest.mock import patch
+from maskinfly.masker import Masker, HAS_PYDANTIC
+
+pytestmark = pytest.mark.skipif(not HAS_PYDANTIC, reason="pydantic not installed")
+
+def test_mask_string_by_pattern(masker_no_audit):
+    result = masker_no_audit.mask_string("password=12345", "test")
+    assert result == "password=***"
+
+def test_mask_string_by_varname(masker_no_audit):
+    with patch("maskinfly.masker.find_variable_name", return_value="password"):
+        result = masker_no_audit.mask_string("my_secret", "some.path")
+        assert result == "***"
+
+def test_mask_string_no_match(masker_no_audit):
+    with patch("maskinfly.masker.find_variable_name", return_value=None):
+        result = masker_no_audit.mask_string("hello world!", "path")
+        assert result == "hello world!"
+
+def test_mask_string_audit(masker_with_audit, audit_logger):
+    with patch("maskinfly.masker.find_variable_name", return_value="password"):
+        # Подменим audit логгер для проверки вызова
+        masker_with_audit.audit = audit_logger
+        result = masker_with_audit.mask_string("secret_value", "user.pwd")
+        assert result == "***"
+        # Проверим, что audit.log был вызван
+        with patch.object(audit_logger, "log") as mock_log:
+            masker_with_audit.mask_string("secret", "path")
+            mock_log.assert_called_once_with("path", "varname", "str")
+
+def test_mask_dict(masker_no_audit):
+    data = {
+        "user": "john",
+        "password": "secret123",
+        "nested": {"api_key": "abc123"}
+    }
+    masked = masker_no_audit.mask(data)
+    assert masked["password"] == "***"
+    assert masked["nested"]["api_key"] == "***"
+    assert masked["user"] == "john"
+
+def test_mask_list(masker_no_audit):
+    data = ["token=xyz", "safe", {"pwd": "pass"}]
+    masked = masker_no_audit.mask(data)
+    assert masked[0] == "token=***"
+    assert masked[1] == "safe"
+    assert masked[2]["pwd"] == "***"
+
+def test_mask_secret_str(masker_no_audit):
+    from pydantic import SecretStr
+    secret = SecretStr("real_secret")
+    masked = masker_no_audit.mask(secret, path="secret_field")
+    assert masked == "***"
+
+def test_mask_other_type(masker_no_audit):
+    assert masker_no_audit.mask(42) == 42
+    assert masker_no_audit.mask(True) is True
+    assert masker_no_audit.mask(None) is None
+
+def test_mask_replacer(masker_with_audit):
+    pattern = masker_with_audit.patterns["password"]
+    match = pattern.search("password=12345")
+    replaced = masker_with_audit._replacer(match)
+    assert replaced == "password=***"

maskinfly-0.1.1/tests/test_patterns.py

@@ -0,0 +1,37 @@
+import re
+from maskinfly.patterns import PATTERNS, DEFAULT_MASK
+
+def test_patterns_are_compile():
+    for name, pattern in PATTERNS.items():
+        assert isinstance(pattern, re.Pattern), f"Паттерн {name} не скомпилирован"
+
+def test_password_pattern():
+    pattern = PATTERNS["password"]
+    match = pattern.search("password=12345")
+    assert match is not None
+    groups = match.groups()
+    assert len(groups) == 3
+    assert groups[2] == "12345"
+
+def test_token_pattern():
+    pattern = PATTERNS["token"]
+    match = pattern.search("token=abc123")
+    assert match is not None
+    groups = match.groups()
+    assert groups[2] == "abc123"
+
+def test_email_pattern():
+    pattern = PATTERNS["email"]
+    assert pattern.search("user@example.com") is not None
+    assert pattern.search("Недействительный") is None
+
+def test_jwt_pattern():
+    pattern = PATTERNS["jwt"]
+    jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U"
+    assert pattern.search(jwt) is not None
+
+def test_ip_pattern():
+    pattern = PATTERNS["ip"]
+    assert pattern.search("192.168.1.1") is not None
+    assert pattern.search("999.999.999.999") is None
+    assert pattern.search("256.0.0.1") is None

maskinfly-0.1.1/tests/test_utils.py

@@ -0,0 +1,20 @@
+import inspect
+import pytest
+from maskinfly.utils import find_variable_name, SENSITIVE_VAR_NAMES
+
+def test_sensitive_var_names():
+    assert "password" in SENSITIVE_VAR_NAMES
+    assert "token" in SENSITIVE_VAR_NAMES
+    assert "api_key" in SENSITIVE_VAR_NAMES
+
+def test_find_variable_name_from_local():
+    test_value = "secret123"
+    def inner():
+        return find_variable_name(test_value, frame_depth=2)
+    name = inner()
+    assert name == "test_value"
+
+def test_find_variable_name_not_found():
+    # Временный объект без имени
+    result = find_variable_name(object(), frame_depth=1)
+    assert result is None