opsec-tool 0.1.0__tar.gz

opsec_tool-0.1.0/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+
+Copyright (c) 2026 opsec contributors
+
+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.

opsec_tool-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: opsec-tool
+Version: 0.1.0
+Summary: Practical privacy and operational-security helpers for Python.
+Author: opsec contributors
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests<3,>=2.31
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Dynamic: license-file
+
+# opsec
+
+join discord.gg/vrmodding you opsec god
+we cant make u anonymous at all ts was mostly for fun. dm me "skireofficial" on discord
+
+## install
+
+```bash
+python -m pip install opsec
+```
+
+## proxy loader
+
+```python
+from opsec.proxy import ProxyPool
+
+pool = ProxyPool.from_file("proxies.txt", check=True)
+
+proxy = pool.get()
+print(proxy.url)
+```
+
+proxies.txt accepts one url per line
+
+```text
+http://127.0.0.1:8080
+socks5h://user:password@example.net:1080
+```
+
+round robin, random, and http are all allowed
+
+## http session 
+
+```python
+from opsec.http import PrivacySession
+
+session = PrivacySession(proxy_pool=pool)
+
+response = session.get(
+    "https://example.com/?utm_source=newsletter&id=42",
+    timeout=10,
+)
+```
+
+session removes basic tracking things and retrieves it safely
+
+## scan
+
+```python
+from opsec.secrets import scan_text
+
+for finding in scan_text("token=ghp_example123"):
+    print(finding.kind, finding.start, finding.end)
+```
+it reports matches
+
+## auditing
+
+```bash
+opsec audit
+```
+
+checks flaws and config mistakes that can affect ur privac y ## yo thingy u put a typo here fix this later when u build it im lazy and remove this
+
+## developemnt
+
+```bash
+python -m pip install -e ".[dev]"
+pytest
+```

opsec_tool-0.1.0/README.md

@@ -0,0 +1,70 @@
+# opsec
+
+join discord.gg/vrmodding you opsec god
+we cant make u anonymous at all ts was mostly for fun. dm me "skireofficial" on discord
+
+## install
+
+```bash
+python -m pip install opsec
+```
+
+## proxy loader
+
+```python
+from opsec.proxy import ProxyPool
+
+pool = ProxyPool.from_file("proxies.txt", check=True)
+
+proxy = pool.get()
+print(proxy.url)
+```
+
+proxies.txt accepts one url per line
+
+```text
+http://127.0.0.1:8080
+socks5h://user:password@example.net:1080
+```
+
+round robin, random, and http are all allowed
+
+## http session 
+
+```python
+from opsec.http import PrivacySession
+
+session = PrivacySession(proxy_pool=pool)
+
+response = session.get(
+    "https://example.com/?utm_source=newsletter&id=42",
+    timeout=10,
+)
+```
+
+session removes basic tracking things and retrieves it safely
+
+## scan
+
+```python
+from opsec.secrets import scan_text
+
+for finding in scan_text("token=ghp_example123"):
+    print(finding.kind, finding.start, finding.end)
+```
+it reports matches
+
+## auditing
+
+```bash
+opsec audit
+```
+
+checks flaws and config mistakes that can affect ur privac y ## yo thingy u put a typo here fix this later when u build it im lazy and remove this
+
+## developemnt
+
+```bash
+python -m pip install -e ".[dev]"
+pytest
+```

opsec_tool-0.1.0/opsec/__init__.py

@@ -0,0 +1,12 @@
+from .core import rid, rd, su, ae
+from .proxy import Proxy, ProxyPool, ProxyStatus
+from .http import PrivacySession
+from .audit import AuditResult, audit
+
+randomid = rid
+redact = rd
+sanitize_url = su
+audit_environment = ae
+run_audit = audit
+
+__version__ = "0.1.0"

opsec_tool-0.1.0/opsec/audit/__init__.py

@@ -0,0 +1,5 @@
+from .system import AuditResult, Finding, audit
+
+run_audit = audit
+
+__all__ = ["AuditResult", "Finding", "audit", "run_audit"]

opsec_tool-0.1.0/opsec/audit/system.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import os
+import stat
+
+from ..core import ae
+
+
+@dataclass(frozen=True, slots=True)
+class Finding:
+    severity: str
+    category: str
+    message: str
+
+
+@dataclass(frozen=True, slots=True)
+class AuditResult:
+    score: int
+    findings: list[Finding]
+
+    def as_dict(self) -> dict:
+        return {
+            "score": self.score,
+            "findings": [
+                {
+                    "severity": item.severity,
+                    "category": item.category,
+                    "message": item.message,
+                }
+                for item in self.findings
+            ],
+        }
+
+
+def audit() -> AuditResult:
+    findings: list[Finding] = []
+
+    names = ae()
+    if names:
+        findings.append(
+            Finding(
+                "high",
+                "environment",
+                f"{len(names)} environment variables look credential-related",
+            )
+        )
+
+    home = Path.home()
+    for path in (home / ".ssh", home / ".aws", home / ".gnupg"):
+        if path.exists():
+            mode = stat.S_IMODE(path.stat().st_mode)
+            if mode & 0o077:
+                findings.append(
+                    Finding(
+                        "medium",
+                        "filesystem",
+                        f"{path} is readable by group or other users",
+                    )
+                )
+
+    if os.name == "posix":
+        mask = os.umask(0)
+        os.umask(mask)
+        if mask == 0:
+            findings.append(
+                Finding(
+                    "low",
+                    "process",
+                    "process umask is 000; newly created files may be more permissive than intended",
+                )
+            )
+
+    weight = {"high": 30, "medium": 15, "low": 5}
+    score = max(0, 100 - sum(weight[item.severity] for item in findings))
+    return AuditResult(score, findings)

opsec_tool-0.1.0/opsec/cli.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import argparse
+import json
+
+from .audit import audit
+from .core import rd, su
+from .proxy import ProxyPool
+from .secrets import scan_file
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="opsec")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    sub.add_parser("audit", help="check common local privacy mistakes")
+
+    rd_parser = sub.add_parser("rd", help="rd common credentials from text")
+    rd_parser.add_argument("text")
+
+    url_parser = sub.add_parser("url", help="clean a URL")
+    url_parser.add_argument("url")
+
+    secret_parser = sub.add_parser("secrets", help="scan one file for likely secrets")
+    secret_parser.add_argument("path")
+
+    proxy_parser = sub.add_parser("proxy", help="work with a proxy list")
+    proxy_sub = proxy_parser.add_subparsers(dest="proxy_command", required=True)
+    test_parser = proxy_sub.add_parser("test", help="health-check proxies")
+    test_parser.add_argument("path")
+    test_parser.add_argument("--n", type=int, default=8)
+
+    args = parser.parse_args(argv)
+
+    if args.command == "audit":
+        print(json.dumps(audit().as_dict(), indent=2))
+        return 0
+
+    if args.command == "rd":
+        print(rd(args.text))
+        return 0
+
+    if args.command == "url":
+        print(su(args.url))
+        return 0
+
+    if args.command == "secrets":
+        findings = scan_file(args.path)
+        print(json.dumps([finding.__dict__ if hasattr(finding, "__dict__") else {
+            "kind": finding.kind,
+            "start": finding.start,
+            "end": finding.end,
+        } for finding in findings], indent=2))
+        return 0
+
+    if args.command == "proxy" and args.proxy_command == "test":
+        pool = ProxyPool.from_file(args.path)
+        print(json.dumps(
+            [status.__dict__ if hasattr(status, "__dict__") else {
+                "url": status.url,
+                "healthy": status.healthy,
+                "lat": status.lat,
+                "fails": status.fails,
+                "oks": status.oks,
+                "at": status.at,
+            } for status in pool.check_all(n=args.n)],
+            indent=2,
+        ))
+        return 0
+
+    parser.error("unknown command")
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

opsec_tool-0.1.0/opsec/core.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import os
+import re
+import secrets
+from typing import Iterable, Mapping
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+sn = re.compile(
+    r"(?:api[_-]?key|access[_-]?token|auth(?:orization)?|client[_-]?secret|"
+    r"password|passwd|private[_-]?key|secret|token)",
+    re.I,
+)
+
+rdors = (
+    re.compile(r"(?i)(authorization\s*:\s*bearer\s+)[^\s,;]+"),
+    re.compile(r"(?i)(authorization\s*:\s*basic\s+)[^\s,;]+"),
+    re.compile(r"(?i)(\b(?:password|passwd|pwd|secret|token|api[_-]?key)\s*[:=]\s*)[^\s,;]+"),
+)
+
+tk = frozenset({
+    "fbclid", "gclid", "dclid", "msclkid", "mc_cid", "mc_eid",
+    "ref", "referrer", "affiliate", "affiliate_id",
+})
+
+def rid(nbytes: int = 16) -> str:
+    if nbytes < 1:
+        raise ValueError("nbytes must be at least 1")
+    return secrets.token_urlsafe(nbytes)
+
+def rd(value: str, replacement: str = "[REDACTED]") -> str:
+    text = str(value)
+    for pattern in rdors:
+        text = pattern.sub(lambda m: m.group(1) + replacement, text)
+    return text
+
+def su(
+    url: str,
+    *,
+    remove_tracking: bool = True,
+    remove_keys: Iterable[str] = (),
+) -> str:
+    parts = urlsplit(url)
+    host = parts.hostname or ""
+    if ":" in host and not host.startswith("["):
+        host = f"[{host}]"
+    netloc = host
+    if parts.port is not None:
+        netloc = f"{netloc}:{parts.port}"
+
+    blocked = {key.lower() for key in remove_keys}
+    query = []
+    for key, value in parse_qsl(parts.query, keep_blank_values=True):
+        lower = key.lower()
+        if lower in blocked:
+            continue
+        if remove_tracking and (lower in tk or lower.startswith("utm_")):
+            continue
+        query.append((key, value))
+
+    return urlunsplit(
+        (parts.scheme, netloc, parts.path, urlencode(query, doseq=True), parts.fragment)
+    )
+
+def ae(environ: Mapping[str, str] | None = None) -> list[str]:
+    env = os.environ if environ is None else environ
+    return sorted(name for name in env if sn.search(name))

opsec_tool-0.1.0/opsec/http/__init__.py

@@ -0,0 +1,3 @@
+from .session import PrivacySession
+
+__all__ = ["PrivacySession"]

opsec_tool-0.1.0/opsec/http/session.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+
+from ..core import su
+from ..proxy import ProxyPool
+
+
+class PrivacySession(requests.Session):
+    """Requests session with conservative privacy defaults."""
+
+    def __init__(
+        self,
+        *,
+        proxy_pool: ProxyPool | None = None,
+        strip_tracking: bool = True,
+    ) -> None:
+        super().__init__()
+        self.proxy_pool = proxy_pool
+        self.strip_tracking = strip_tracking
+        self.headers.update(
+            {
+                "User-Agent": "opsec/0.1",
+                "DNT": "1",
+                "Accept": "*/*",
+            }
+        )
+
+    def req(self, method: str, url: str, **kwargs: Any) -> requests.Response:
+        if self.strip_tracking:
+            url = su(url)
+
+        proxy = self.proxy_pool.get() if self.proxy_pool else None
+        if proxy is not None:
+            kwargs.setdefault("proxies", proxy.requests_mapping())
+
+        try:
+            r = super().request(method, url, **kwargs)
+        except requests.RequestException:
+            if proxy is not None:
+                self.proxy_pool.bad(proxy)
+            raise
+
+        if proxy is not None:
+            if 200 <= r.status_code < 500:
+                self.proxy_pool.ok(proxy)
+            else:
+                self.proxy_pool.bad(proxy)
+
+        return r

opsec_tool-0.1.0/opsec/proxy/__init__.py

@@ -0,0 +1,3 @@
+from .pool import Proxy, ProxyPool, ProxyStatus
+
+__all__ = ["Proxy", "ProxyPool", "ProxyStatus"]

opsec_tool-0.1.0/opsec/proxy/pool.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+import random
+from pathlib import Path
+import threading
+import time
+from typing import Iterable
+from urllib.parse import urlparse
+
+import requests
+
+
+@dataclass(slots=True)
+class ProxyStatus:
+    url: str
+    healthy: bool | None
+    lat: float | None
+    fails: int
+    oks: int
+    at: float | None
+
+
+@dataclass(slots=True)
+class Proxy:
+    url: str
+    healthy: bool | None = None
+    lat: float | None = None
+    fails: int = 0
+    oks: int = 0
+    at: float | None = None
+
+    def __post_init__(self) -> None:
+        parsed = urlparse(self.url)
+        if parsed.scheme not in {"http", "https", "socks5", "socks5h"}:
+            raise ValueError(f"unsupported proxy scheme: {parsed.scheme}")
+        if not parsed.hostname or parsed.port is None:
+            raise ValueError("proxy URL must include a host and port")
+
+    def requests_mapping(self) -> dict[str, str]:
+        return {"http": self.url, "https": self.url}
+
+    def status(self) -> ProxyStatus:
+        return ProxyStatus(
+            self.url,
+            self.healthy,
+            self.lat,
+            self.fails,
+            self.oks,
+            self.at,
+        )
+
+
+class ProxyPool:
+    def __init__(
+        self,
+        proxies: Iterable[str | Proxy],
+        *,
+        strategy: str = "round_robin",
+        max_fails: int = 3,
+    ) -> None:
+        if strategy not in {"round_robin", "random", "healthy"}:
+            raise ValueError("strategy must be round_robin, random, or healthy")
+        if max_fails < 1:
+            raise ValueError("max_fails must be at least 1")
+
+        self.items = [p if isinstance(p, Proxy) else Proxy(p) for p in proxies]
+        self.strategy = strategy
+        self.max_fails = max_fails
+        self.cursor = 0
+        self.lock = threading.Lock()
+
+    @classmethod
+    def from_file(cls, path: str | Path, *, check: bool = False, **kwargs) -> "ProxyPool":
+        lines = Path(path).read_text(encoding="utf-8").splitlines()
+        urls = [
+            line.strip()
+            for line in lines
+            if line.strip() and not line.lstrip().startswith("#")
+        ]
+        pool = cls(urls, **kwargs)
+        if check:
+            pool.checkall()
+        return pool
+
+    def __len__(self) -> int:
+        return len(self.items)
+
+    def avail(self) -> list[Proxy]:
+        avail = [p for p in self.items if p.fails < self.max_fails]
+        return avail or list(self.items)
+
+    def get(self) -> Proxy:
+        with self.lock:
+            candidates = self.avail()
+            if not candidates:
+                raise RuntimeError("proxy pool is empty")
+
+            if self.strategy == "random":
+                return random.choice(candidates)
+
+            if self.strategy == "healthy":
+                healthy = [p for p in candidates if p.healthy is True]
+                return random.choice(healthy or candidates)
+
+            proxy = candidates[self.cursor % len(candidates)]
+            self.cursor += 1
+            return proxy
+
+    def check(
+        self,
+        proxy: PX,
+        *,
+        url: str = "https://www.gstatic.com/generate_204",
+        timeout: float = 8,
+    ) -> ProxyStatus:
+        started = time.monotonic()
+        try:
+            r = requests.get(
+                url,
+                proxies=proxy.requests_mapping(),
+                timeout=timeout,
+                allow_redirects=False,
+                headers={"User-Agent": "opsec/0.1"},
+            )
+            ok = 200 <= r.status_code < 400
+            proxy.healthy = ok
+            if ok:
+                proxy.oks += 1
+            else:
+                proxy.fails += 1
+        except requests.RequestException:
+            proxy.healthy = False
+            proxy.fails += 1
+
+        proxy.lat = round((time.monotonic() - started) * 1000, 1)
+        proxy.at = time.time()
+        return proxy.status()
+
+    def check_all(
+        self,
+        *,
+        url: str = "https://www.gstatic.com/generate_204",
+        timeout: float = 8,
+        n: int = 8,
+    ) -> list[ProxyStatus]:
+        n = max(1, min(n, len(self.items) or 1))
+        with ThreadPoolExecutor(max_workers=n) as executor:
+            futures = [
+                executor.submit(self.check, proxy, url=url, timeout=timeout)
+                for proxy in self.items
+            ]
+            return [future.result() for future in as_completed(futures)]
+
+    def record_success(self, proxy: PX) -> None:
+        proxy.oks += 1
+        proxy.fails = max(0, proxy.fails - 1)
+        proxy.healthy = True
+
+    def record_failure(self, proxy: PX) -> None:
+        proxy.fails += 1
+        if proxy.fails >= self.max_fails:
+            proxy.healthy = False
+
+    def statuses(self) -> list[ProxyStatus]:
+        return [proxy.status() for proxy in self.items]

opsec_tool-0.1.0/opsec/secrets/__init__.py

@@ -0,0 +1,3 @@
+from .scanner import Finding, scan_file, scan_text
+
+__all__ = ["Finding", "scan_file", "scan_text"]

opsec_tool-0.1.0/opsec/secrets/scanner.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import re
+
+
+@dataclass(frozen=True, slots=True)
+class Finding:
+    kind: str
+    start: int
+    end: int
+
+
+pt: tuple[tuple[str, re.Pattern[str]], ...] = (
+    ("github_token", re.compile(r"\bgh[pousr]_[A-Za-z0-9_]{20,}\b")),
+    ("aws_access_key", re.compile(r"\bAKIA[0-9A-Z]{16}\b")),
+    ("private_key", re.compile(r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----")),
+    ("generic_assignment", re.compile(
+        r"(?i)\b(?:api[_-]?key|secret|token|password)\b\s*[:=]\s*['\"]?[A-Za-z0-9_\-/.+=]{8,}"
+    )),
+)
+
+
+def scan_text(text: str) -> list[Finding]:
+    findings: list[Finding] = []
+    for kind, pattern in pt:
+        for match in pattern.finditer(text):
+            findings.append(Finding(kind, match.start(), match.end()))
+    findings.sort(key=lambda finding: (finding.start, finding.end))
+    return findings
+
+
+def scan_file(path: str | Path, *, max_bytes: int = 2_000_000) -> list[Finding]:
+    file_path = Path(path)
+    size = file_path.stat().st_size
+    if size > max_bytes:
+        raise ValueError(f"refusing to scan {file_path}: file is larger than {max_bytes} bytes")
+    return scan_text(file_path.read_text(encoding="utf-8", errors="replace"))

opsec_tool-0.1.0/opsec_tool.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: opsec-tool
+Version: 0.1.0
+Summary: Practical privacy and operational-security helpers for Python.
+Author: opsec contributors
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests<3,>=2.31
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Dynamic: license-file
+
+# opsec
+
+join discord.gg/vrmodding you opsec god
+we cant make u anonymous at all ts was mostly for fun. dm me "skireofficial" on discord
+
+## install
+
+```bash
+python -m pip install opsec
+```
+
+## proxy loader
+
+```python
+from opsec.proxy import ProxyPool
+
+pool = ProxyPool.from_file("proxies.txt", check=True)
+
+proxy = pool.get()
+print(proxy.url)
+```
+
+proxies.txt accepts one url per line
+
+```text
+http://127.0.0.1:8080
+socks5h://user:password@example.net:1080
+```
+
+round robin, random, and http are all allowed
+
+## http session 
+
+```python
+from opsec.http import PrivacySession
+
+session = PrivacySession(proxy_pool=pool)
+
+response = session.get(
+    "https://example.com/?utm_source=newsletter&id=42",
+    timeout=10,
+)
+```
+
+session removes basic tracking things and retrieves it safely
+
+## scan
+
+```python
+from opsec.secrets import scan_text
+
+for finding in scan_text("token=ghp_example123"):
+    print(finding.kind, finding.start, finding.end)
+```
+it reports matches
+
+## auditing
+
+```bash
+opsec audit
+```
+
+checks flaws and config mistakes that can affect ur privac y ## yo thingy u put a typo here fix this later when u build it im lazy and remove this
+
+## developemnt
+
+```bash
+python -m pip install -e ".[dev]"
+pytest
+```

opsec_tool-0.1.0/opsec_tool.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+LICENSE
+README.md
+pyproject.toml
+opsec/__init__.py
+opsec/cli.py
+opsec/core.py
+opsec/audit/__init__.py
+opsec/audit/system.py
+opsec/http/__init__.py
+opsec/http/session.py
+opsec/proxy/__init__.py
+opsec/proxy/pool.py
+opsec/secrets/__init__.py
+opsec/secrets/scanner.py
+opsec_tool.egg-info/PKG-INFO
+opsec_tool.egg-info/SOURCES.txt
+opsec_tool.egg-info/dependency_links.txt
+opsec_tool.egg-info/entry_points.txt
+opsec_tool.egg-info/requires.txt
+opsec_tool.egg-info/top_level.txt
+tests/test_audit.py
+tests/test_core.py
+tests/test_proxy.py
+tests/test_public.py
+tests/test_secrets.py

opsec_tool-0.1.0/opsec_tool.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

opsec_tool-0.1.0/opsec_tool.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+opsec = opsec.cli:main

opsec_tool-0.1.0/opsec_tool.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests<3,>=2.31
+
+[dev]
+pytest>=8
+ruff>=0.6

opsec_tool-0.1.0/opsec_tool.egg-info/top_level.txt

@@ -0,0 +1 @@
+opsec

opsec_tool-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "opsec-tool"
+version = "0.1.0"
+description = "Practical privacy and operational-security helpers for Python."
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [{name = "opsec contributors"}]
+dependencies = ["requests>=2.31,<3"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "ruff>=0.6"]
+
+[project.scripts]
+opsec = "opsec.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["opsec*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

opsec_tool-0.1.0/setup.cfg

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

opsec_tool-0.1.0/tests/test_audit.py

@@ -0,0 +1,6 @@
+from opsec.audit import audit
+
+def test_audit_result():
+    result = audit()
+    assert 0 <= result.score <= 100
+    assert isinstance(result.findings, list)

opsec_tool-0.1.0/tests/test_core.py

@@ -0,0 +1,13 @@
+from opsec.core import ae, rd, su
+
+def test_sanitize_url_removes_userinfo_and_tracking():
+    result = su("https://user:password@example.com/a?utm_source=x&fbclid=y&keep=1")
+    assert result == "https://example.com/a?keep=1"
+
+def test_redact():
+    result = rd("Authorization: Bearer abc123 password=hunter2")
+    assert "abc123" not in result
+    assert "hunter2" not in result
+
+def test_environment_audit():
+    assert ae({"PATH": "/bin", "MY_API_KEY": "x", "HELLO": "world"}) == ["MY_API_KEY"]

opsec_tool-0.1.0/tests/test_proxy.py

@@ -0,0 +1,10 @@
+from opsec.proxy import ProxyPool
+
+def test_round_robin():
+    pool = ProxyPool(["http://127.0.0.1:8080", "http://127.0.0.2:8080"])
+    assert pool.get().url == "http://127.0.0.1:8080"
+    assert pool.get().url == "http://127.0.0.2:8080"
+
+def test_requests_mapping():
+    pool = ProxyPool(["socks5h://127.0.0.1:1080"])
+    assert pool.get().requests_mapping()["https"].startswith("socks5h://")

opsec_tool-0.1.0/tests/test_public.py

@@ -0,0 +1,8 @@
+import opsec
+from opsec import ProxyPool, PrivacySession, sanitize_url
+
+def test_public_api():
+    assert opsec.__version__ == "0.1.0"
+    assert ProxyPool(["http://127.0.0.1:8080"]).get().url == "http://127.0.0.1:8080"
+    assert sanitize_url("https://u:p@example.com/?utm_source=x&ok=1") == "https://example.com/?ok=1"
+    assert PrivacySession is not None

opsec_tool-0.1.0/tests/test_secrets.py

@@ -0,0 +1,5 @@
+from opsec.secrets import scan_text
+
+def test_secret_scanner():
+    findings = scan_text("token=ghp_abcdefghijklmnopqrstuvwxyz123456")
+    assert findings