Files
myrzx_bot/ranch_web/tests/test_private_updates.py

196 lines
9.7 KiB
Python

"""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()