"""Private release transport checks using fake HTTP only, never user credentials.""" from contextlib import contextmanager from email.message import Message import io import json import os from pathlib import Path import tempfile import traceback import unittest from unittest.mock import patch from urllib.error import HTTPError, URLError from urllib.request import HTTPSHandler, build_opener from urllib.response import addinfourl from ranch_web import updates TOKEN = "github_pat_offline_test_secret" RELEASES = [{"tag_name": "v2.0.1", "draft": False, "prerelease": False}] class PrivateReleaseTests(unittest.TestCase): def setUp(self): temporary = tempfile.TemporaryDirectory(prefix="private-release-test-") self.addCleanup(temporary.cleanup) self.root = Path(temporary.name) self.token_path = self.root / updates.TOKEN_FILE_NAME environment = patch.dict(os.environ, {"RANCH_WEB_UPDATER_DIR": ""}) environment.start() self.addCleanup(environment.stop) os.environ.pop(updates.TOKEN_FILE_ENV, None) network = patch("socket.socket.connect", side_effect=AssertionError("Live network forbidden")) network.start() self.addCleanup(network.stop) def token(self, payload=None): self.token_path.write_bytes(payload if payload is not None else (TOKEN + "\n").encode("ascii")) self.token_path.chmod(0o600) @contextmanager def transport(self, body=None): payload = body if body is not None else json.dumps(RELEASES).encode("ascii") with patch.object(updates, "build_opener") as build: build.return_value.open.side_effect = lambda *args, **kwargs: io.BytesIO(payload) yield build def test_missing_default_retains_public_and_no_argument_api(self): with self.transport() as build: self.assertEqual(updates.github_releases(), RELEASES) self.assertEqual(updates.github_releases(self.root), RELEASES) for call in build.return_value.open.call_args_list: self.assertIsNone(call.args[0].get_header("Authorization")) def test_shared_file_adds_auth_only_to_fixed_github_endpoint(self): self.token() with self.transport() as build: self.assertEqual(updates.github_releases(self.root), RELEASES) request = build.return_value.open.call_args.args[0] self.assertEqual(request.full_url, updates.RELEASES_API + "?per_page=100&page=1") self.assertEqual(request.get_header("Authorization"), "Bearer " + TOKEN) self.assertIsInstance(build.call_args.args[0], updates._NoRedirect) def test_absolute_override_is_a_file_and_takes_precedence(self): self.token(b"ignored_default\n") alternate = self.root / "alternate-token" alternate.write_text(TOKEN, encoding="ascii") alternate.chmod(0o600) os.environ[updates.TOKEN_FILE_ENV] = str(alternate) with self.transport() as build: updates.github_releases(self.root) self.assertEqual(build.return_value.open.call_args.args[0].get_header("Authorization"), "Bearer " + TOKEN) def test_invalid_explicit_file_never_falls_back_or_exposes_path(self): for value in ("", TOKEN, str(self.root / "missing-private-token")): with self.subTest(value=value), self.transport() as build: os.environ[updates.TOKEN_FILE_ENV] = value with self.assertRaises(updates.GitHubReleaseError) as caught: updates.github_releases(self.root) self.assertEqual(caught.exception.code, "token_file_invalid") self.assertNotIn(TOKEN, str(caught.exception)) self.assertNotIn(str(self.root), str(caught.exception)) build.assert_not_called() def test_malformed_empty_large_and_header_injection_tokens_rejected(self): for payload in (b"", b"bad token", b"token\r\nInjected: secret", b"\xff", b"a" * 4097): with self.subTest(payload=payload[:20]), self.transport() as build: self.token(payload) with self.assertRaises(updates.GitHubReleaseError): updates.github_releases(self.root) build.assert_not_called() def test_hard_link_token_rejected(self): self.token() os.link(self.token_path, self.root / "token-hardlink") with self.transport() as build, self.assertRaises(updates.GitHubReleaseError): updates.github_releases(self.root) build.assert_not_called() def test_symlink_even_to_missing_file_rejected(self): try: self.token_path.symlink_to(self.root / "missing-target") except OSError: self.skipTest("Symlinks unavailable for this test user") with self.transport() as build, self.assertRaises(updates.GitHubReleaseError): updates.github_releases(self.root) build.assert_not_called() @unittest.skipUnless(os.name == "posix", "POSIX permission check") def test_readable_by_group_or_others_is_not_accepted(self): self.token() for mode in (0o644, 0o640, 0o400, 0o660): self.token_path.chmod(mode) with self.subTest(mode=mode), self.transport() as build, self.assertRaises(updates.GitHubReleaseError): updates.github_releases(self.root) build.assert_not_called() def test_file_permission_errors_are_fixed_and_secret_free(self): with patch.object(updates.os, "open", side_effect=PermissionError(TOKEN)), self.transport() as build: with self.assertRaises(updates.GitHubReleaseError) as caught: updates.github_releases(self.root) self.assertNotIn(TOKEN, str(caught.exception)) build.assert_not_called() def test_http_access_errors_with_and_without_token_are_not_no_release(self): service = updates.UpdateService(self.root, "2.0.0") for authenticated in (False, True): if authenticated: self.token() for status in (401, 403, 404): with self.subTest(authenticated=authenticated, status=status), self.transport() as build: build.return_value.open.side_effect = HTTPError(updates.RELEASES_API, status, TOKEN, {}, io.BytesIO(TOKEN.encode())) state = service.check() self.assertEqual(state["status"], "check_failed") self.assertIn("权限", state["message"]) self.assertFalse(state["available"]) self.assertFalse(state["can_apply"]) self.assertIsNone(state["latest_version"]) self.assertNotIn(TOKEN, json.dumps(state)) self.assertNotIn(TOKEN, (self.root / "update-check.json").read_text(encoding="utf-8")) def test_untrusted_response_and_network_exception_are_sanitized(self): self.token() for body in (TOKEN.encode(), json.dumps({"error": TOKEN}).encode()): with self.subTest(body=body), self.transport(body): with self.assertRaises(updates.GitHubReleaseError) as caught: updates.github_releases(self.root) self.assertNotIn(TOKEN, "".join(traceback.format_exception(caught.exception))) with self.transport() as build: build.return_value.open.side_effect = URLError(TOKEN) with self.assertRaises(updates.GitHubReleaseError) as caught: updates.github_releases(self.root) self.assertNotIn(TOKEN, "".join(traceback.format_exception(caught.exception))) def test_redirect_responses_never_issue_a_second_request(self): self.token() requests = [] class RedirectTransport(HTTPSHandler): def https_open(self, request): requests.append(request) headers = Message() headers["Location"] = destination response = addinfourl(io.BytesIO(b""), headers, request.full_url, status) response.msg = "redirect" return response for destination in ("https://evil.invalid/" + TOKEN, updates.RELEASES_API + "/redirect"): for status in (301, 302, 303, 307, 308): requests.clear() opener = build_opener(updates._NoRedirect(), RedirectTransport()) with self.subTest(destination=destination, status=status), patch.object(updates, "build_opener", return_value=opener): with self.assertRaises(updates.GitHubReleaseError) as caught: updates.github_releases(self.root) self.assertEqual(len(requests), 1) self.assertNotIn(TOKEN, str(caught.exception)) def test_untrusted_endpoint_is_rejected_before_loading_credentials(self): for endpoint in ("https://evil.invalid/releases", "http://api.github.com/repos/attilanet/myrzx_bot/releases", updates.RELEASES_API + "?redirect=bad", "https://api.github.com@evil.invalid/releases"): with self.subTest(endpoint=endpoint), patch.object(updates, "RELEASES_API", endpoint), patch.object(updates, "_github_token") as read: with self.assertRaises(updates.GitHubReleaseError): updates.github_releases(self.root) read.assert_not_called() def test_cache_cannot_inject_freeform_failure_message(self): for failure in (TOKEN, [TOKEN], {TOKEN: TOKEN}): updates.atomic_json(self.root / "update-check.json", {"status": "check_failed", "failure": failure}) state = updates.UpdateService(self.root, "2.0.0").status() self.assertEqual(state["status"], "check_failed") self.assertNotIn(TOKEN, json.dumps(state)) if __name__ == "__main__": unittest.main()