mirror of
https://github.com/kuhyx/steam-backlog-enforcer.git
synced 2026-11-21 17:12:19 +01:00
Some checks are pending
dependency freshness / dependencies on newest stable (push) Waiting to run
md-naming / markdown naming convention (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (mypy, mypy, ) (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (pylint, pylint, ) (push) Waiting to run
pre-commit / pre-commit (${{ matrix.group }}) (rest, , mypy,pylint) (push) Waiting to run
Tests / test (push) Waiting to run
Tests / web-coverage (push) Waiting to run
repo-contract / repo contract (push) Waiting to run
kuhy 2026-11-11: game-design research needs Librarian (app 4197610) actually played during the 6-day total block. New root command total-block-research --until T opens ONE window per lock: <= 48 h, never past the lock end, a rerun never extends it. The command only validates and records (/var/lib/steam-backlog- enforcer, root 0700; lock id + deadline + two latches). The daemon opens and closes everything: Steam hosts names, the store block, the total-block chain (IP cache kept) and the steam package, reinstalled with only guard-lib's package-block hook masked for that one pacman call (--hookdir, proved in a guest). Lock file, hook and end date are never touched. Browser-game sites stay null-routed. Only Librarian may run: loop-local allowed set, strict mode (no whitelist exceptions, no zero-achievement games), launchers and counted games killed; state.json is never read or written. Expiry latches the record, then the ordinary tick re-applies hosts (now reconciled each tick), chain, uninstall and purge; the normal store block is restored once, unconditionally. Failure modes: missing/corrupt/unparseable record = no window and a corrupt one also refuses a new window (fail closed); a clock set back cannot reopen a latched window. Checked: 3290 tests at 100% coverage; whole-tree pylint 10/10 run in three parts (the hook exceeds the 60 s cap, so SKIP=pylint here); vmbox guest with real guardctl package-block and the real unit, window opened, Librarian-only enforced, clock moved past the deadline and the full block re-applied. Not verified on the host. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01WzxdWWzuCEg1m87jpKyRrw
201 lines
6.9 KiB
Python
201 lines
6.9 KiB
Python
"""Block Steam Store access via /etc/hosts (hosts install script) and iptables.
|
|
|
|
/etc/hosts is protected by guard-lib (~/guard-lib, file-guard instance
|
|
"hosts"): chattr +i, a read-only self-bind-mount, and a systemd path-unit
|
|
watcher. This module checks if the Steam Store domains are already blocked
|
|
in /etc/hosts. If not, it runs the hosts install.sh (which must already
|
|
contain the Steam Store entries in its heredoc), going through guard-lib's
|
|
unlock/relock around any edit. As a belt-and-suspenders fallback, it also
|
|
blocks via iptables.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import subprocess
|
|
|
|
from steam_backlog_enforcer._hosts_protection import (
|
|
_reblock_hosts,
|
|
rewrite_hosts_lines,
|
|
)
|
|
from steam_backlog_enforcer._store_iptables import (
|
|
_block_store_iptables,
|
|
_is_iptables_blocked,
|
|
_unblock_store_iptables,
|
|
flush_dns_cache,
|
|
)
|
|
from steam_backlog_enforcer._store_tools import (
|
|
BASH,
|
|
HOSTS_INSTALL_SCRIPT,
|
|
HOSTS_REDIRECT_IP,
|
|
SUDO,
|
|
)
|
|
from steam_backlog_enforcer.config import (
|
|
BLOCKED_DOMAINS,
|
|
HOSTS_FILE,
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# The install script rewrites /etc/hosts and re-applies its guards.
|
|
_HOSTS_INSTALL_TIMEOUT_SECONDS = 120
|
|
|
|
|
|
def is_store_blocked() -> bool:
|
|
"""Check if Steam Store domains are blocked in /etc/hosts or iptables."""
|
|
return hosts_blocks_store() or _is_iptables_blocked()
|
|
|
|
|
|
def hosts_blocks_store() -> bool:
|
|
"""Check /etc/hosts alone: a file read, no subprocess, safe to poll."""
|
|
try:
|
|
content = HOSTS_FILE.read_text(encoding="utf-8")
|
|
# Check for at least the primary store domain.
|
|
if "store.steampowered.com" in content:
|
|
# Verify it's actually blocked (not commented out).
|
|
for line in content.splitlines():
|
|
stripped = line.strip()
|
|
if (
|
|
not stripped.startswith("#")
|
|
and "store.steampowered.com" in stripped
|
|
and stripped.startswith(HOSTS_REDIRECT_IP)
|
|
):
|
|
return True
|
|
except OSError:
|
|
pass
|
|
return False
|
|
|
|
|
|
def block_store() -> bool:
|
|
"""Block Steam Store: uncomment hosts entries, or run install script.
|
|
|
|
Returns True if at least one blocking method succeeded.
|
|
"""
|
|
if is_store_blocked():
|
|
logger.info("Steam Store already blocked in /etc/hosts.")
|
|
return True
|
|
|
|
# Try quick re-block (uncomment lines) first.
|
|
if _reblock_hosts() and is_store_blocked():
|
|
_block_store_iptables()
|
|
flush_dns_cache()
|
|
return True
|
|
|
|
# Fall back to the full hosts install script.
|
|
hosts_ok = _block_via_hosts_install()
|
|
ipt_ok = _block_store_iptables()
|
|
|
|
if hosts_ok or ipt_ok:
|
|
flush_dns_cache()
|
|
return True
|
|
|
|
logger.error("All store-blocking methods failed.")
|
|
return False
|
|
|
|
|
|
def restore_store_block() -> bool:
|
|
"""Re-enable the normal store block, even if something else also blocks it.
|
|
|
|
:func:`block_store` returns early at "already blocked", and the total
|
|
block's own /etc/hosts section null-routes the same domains: with that
|
|
section back, the normal lines would stay commented out after a research
|
|
window and the store would open the day the lock ends. This always
|
|
uncomments them and rebuilds the store chain.
|
|
|
|
Returns True if at least one layer was restored.
|
|
"""
|
|
hosts_ok = _reblock_hosts()
|
|
ipt_ok = _block_store_iptables()
|
|
flush_dns_cache()
|
|
return hosts_ok or ipt_ok
|
|
|
|
|
|
def _block_via_hosts_install() -> bool:
|
|
"""Run the hosts install.sh to apply /etc/hosts with Steam Store entries.
|
|
|
|
The install script handles: immutable flag removal, bind mount remounting,
|
|
writing the file, re-applying protections, and DoH disabling.
|
|
"""
|
|
if is_store_blocked():
|
|
logger.info("Steam Store already blocked in /etc/hosts.")
|
|
return True
|
|
|
|
if not HOSTS_INSTALL_SCRIPT.exists():
|
|
logger.error("hosts install script not found at %s", HOSTS_INSTALL_SCRIPT)
|
|
return False
|
|
|
|
try:
|
|
logger.info("Running hosts install script to block Steam Store...")
|
|
result = subprocess.run(
|
|
[SUDO, BASH, str(HOSTS_INSTALL_SCRIPT), "--no-flush-dns"],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=_HOSTS_INSTALL_TIMEOUT_SECONDS,
|
|
check=False,
|
|
)
|
|
except OSError, subprocess.SubprocessError:
|
|
logger.exception("Failed to run hosts install script")
|
|
return False
|
|
if result.returncode == 0:
|
|
logger.info("hosts install script succeeded.")
|
|
return True
|
|
logger.error(
|
|
"hosts install script failed (rc=%d): %s",
|
|
result.returncode,
|
|
result.stderr[-500:] if result.stderr else result.stdout[-500:],
|
|
)
|
|
return False
|
|
|
|
|
|
def unblock_store() -> bool:
|
|
"""Remove Steam Store blocks from both iptables and /etc/hosts."""
|
|
ipt_ok = _unblock_store_iptables()
|
|
hosts_ok = _unblock_hosts()
|
|
flush_dns_cache()
|
|
|
|
if not ipt_ok:
|
|
logger.warning("Failed to remove iptables rules.")
|
|
if not hosts_ok:
|
|
logger.warning("Failed to remove /etc/hosts entries.")
|
|
|
|
return ipt_ok or hosts_ok
|
|
|
|
|
|
# ──────────────────────────────────────────────────────────────
|
|
# /etc/hosts protection helpers
|
|
#
|
|
# /etc/hosts is managed by guard-lib (see ~/guard-lib) as file-guard
|
|
# instance "hosts": chattr +i, a read-only self-bind-mount, and a
|
|
# systemd path-unit watcher. "pacman-unlock" stops the watcher and
|
|
# collapses the bind mount (same primitive guard-lib's own pacman hooks
|
|
# use). Relocking uses "sync", NOT "pacman-relock" - pacman-relock calls
|
|
# fg_enforce, which treats any diff from the (stale) canonical as drift
|
|
# and reverts it; that's correct for pacman's own hook flow (undo
|
|
# unwanted tampering) but wrong here, where *we* are the one legitimately
|
|
# changing content - it would silently undo our own edit. "sync" instead
|
|
# adopts the just-written content as the new canonical.
|
|
# ──────────────────────────────────────────────────────────────
|
|
|
|
|
|
def _unblock_hosts() -> bool:
|
|
"""Comment out Steam Store entries in /etc/hosts."""
|
|
if not is_store_blocked():
|
|
logger.info("Steam Store not blocked in /etc/hosts, nothing to do.")
|
|
return True
|
|
|
|
return rewrite_hosts_lines(
|
|
_comment_out_blocked, "Commented out Steam Store entries in /etc/hosts."
|
|
)
|
|
|
|
|
|
def _comment_out_blocked(line: str) -> str | None:
|
|
"""The line commented out, if it is a live redirect of a blocked domain."""
|
|
stripped = line.strip()
|
|
if (
|
|
not stripped.startswith("#")
|
|
and stripped.startswith(HOSTS_REDIRECT_IP)
|
|
and any(d in stripped for d in BLOCKED_DOMAINS)
|
|
):
|
|
return f"# {line}" if line.endswith("\n") else f"# {line}\n"
|
|
return None
|