196 lines
9.7 KiB
Python
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()
|