from datetime import datetime, time, timedelta, timezone as tz from unittest import TestCase from unittest.mock import patch from types import SimpleNamespace from django.db import transaction from django.test import RequestFactory from rest_framework.exceptions import ValidationError from common.exception.app_exception import AppUnauthorizedFailed, AppApiException from system_manage import access_control as ac from system_manage.models import AccessControlPolicy, AccessControlPolicyApplicationRecord, Log from system_manage.serializers.access_control_policy import AccessControlPolicySerializer from users.models import User class AccessTests(TestCase): def setUp(self): self.atomic = transaction.atomic() self.atomic.__enter__() self.user = User.objects.create(username='CODEX_ACCESS_TEST', nick_name='测试管理员', role='ADMIN') self.policy = AccessControlPolicy.objects.create(name='CODEX_ACCESS_TEST') self.now = datetime(2026, 10, 26, 2, 0, tzinfo=tz.utc) def tearDown(self): transaction.set_rollback(True) self.atomic.__exit__(None, None, None) def request(self, ip='10.1.2.3', agent='Mozilla/5.0 (Windows NT 10.0)', **meta): return RequestFactory().get('/chat/api/open', REMOTE_ADDR=ip, HTTP_USER_AGENT=agent, **meta) def bind(self, target='application:sample'): with patch.object(ac, 'targets', return_value=[{'id': target, 'label': '测试服务'}]): return ac.bind(self.policy.id, self.user, {'target_type': 'SERVICE', 'target_identifier': target}) def test_no_binding_does_not_restrict_or_audit(self): ac.enforce(self.request(), 'application', 'sample') self.assertEqual(Log.objects.count(), 0) def test_existing_history_does_not_activate(self): AccessControlPolicyApplicationRecord.objects.create(policy=self.policy, policy_name=self.policy.name, target_type='SERVICE', target_identifier='application:sample', target_name='历史记录') self.policy.allowed_device_types = ['移动终端']; self.policy.save() ac.enforce(self.request(), 'application', 'sample') self.assertEqual(Log.objects.count(), 0) def test_service_binding_and_deduplicated_audit(self): self.bind(); request = self.request() ac.enforce(request, 'application', 'sample'); ac.enforce(request, 'application', 'sample') self.assertEqual(Log.objects.count(), 1) self.assertEqual(Log.objects.first().status, 200) def test_device_denied(self): self.bind(); self.policy.allowed_device_types = ['移动终端']; self.policy.save() with self.assertRaises(AppUnauthorizedFailed): ac.enforce(self.request(), 'application', 'sample') self.assertEqual(Log.objects.first().status, 403) self.assertNotIn('body', Log.objects.first().details) def test_update_applies_to_next_request(self): self.bind(); ac.enforce(self.request(), 'application', 'sample') self.policy.allowed_device_types = ['移动终端']; self.policy.save() with self.assertRaises(AppUnauthorizedFailed): ac.enforce(self.request(), 'application', 'sample') def test_disabled_policy(self): self.bind(); self.policy.allowed_device_types = ['移动终端']; self.policy.enabled = False; self.policy.save() ac.enforce(self.request(), 'application', 'sample') def test_unbind_keeps_history(self): item = self.bind(); ac.unbind(self.policy.id, self.user, item) self.assertEqual(ac.configuration()[1]['bindings'], []) self.assertEqual(AccessControlPolicyApplicationRecord.objects.count(), 2) def test_duplicate_binding(self): self.bind() with self.assertRaises(ValidationError): self.bind() def test_nonexistent_service(self): with patch.object(ac, 'targets', return_value=[]), self.assertRaises(ValidationError): ac.bind(self.policy.id, self.user, {'target_type': 'SERVICE', 'target_identifier': 'application:missing'}) def test_device_cidr(self): ac.bind(self.policy.id, self.user, {'target_type': 'DEVICE', 'target_identifier': '10.1.2.3/24'}) self.policy.allowed_device_types = ['移动终端']; self.policy.save() with self.assertRaises(AppUnauthorizedFailed): ac.enforce(self.request(), 'mindmap', 'sample') ac.enforce(self.request(ip='10.2.2.3'), 'mindmap', 'sample') def test_ipv6(self): self.assertTrue(ac.contains('2001:db8::1', '2001:db8::/32')) self.assertFalse(ac.contains('10.1.1.1', '2001:db8::/32')) def test_invalid_network(self): for value in ['invalid', None, '10.500.0.1']: with self.subTest(value=value), self.assertRaises(ValidationError): ac.network(value) def test_all_policies_must_allow(self): self.bind() other = AccessControlPolicy.objects.create(name='另一策略', allowed_device_types=['移动终端']) row, config = ac.configuration() config['bindings'].append({**config['bindings'][0], 'policy_id': str(other.id)}) row.meta = config; row.save() with self.assertRaises(AppUnauthorizedFailed): ac.enforce(self.request(), 'application', 'sample') def test_unknown_region(self): self.bind(); self.policy.allowed_regions = ['北京']; self.policy.save() with self.assertRaises(AppUnauthorizedFailed): ac.enforce(self.request(), 'application', 'sample') def test_region_mapping_and_change(self): self.bind(); self.policy.allowed_regions = ['北京']; self.policy.save() ac.save_regions([{'name': '北京', 'network': '10.1.0.0/16'}]) ac.enforce(self.request(), 'application', 'sample') ac.save_regions([]) with self.assertRaises(AppUnauthorizedFailed): ac.enforce(self.request(), 'application', 'sample') def test_overlapping_regions(self): with self.assertRaises(ValidationError): ac.save_regions([{'name': '北京', 'network': '10.0.0.0/8'}, {'name': '上海', 'network': '10.1.0.0/16'}]) def test_spoofed_forwarded_ignored(self): with patch.dict('os.environ', {'MAXKB_ACCESS_TRUSTED_PROXIES': ''}): self.assertEqual(ac.client_ip(self.request(HTTP_X_FORWARDED_FOR='8.8.8.8')), '10.1.2.3') def test_trusted_proxy_chain(self): with patch.dict('os.environ', {'MAXKB_ACCESS_TRUSTED_PROXIES': '127.0.0.1/32,10.0.0.0/8'}): self.assertEqual(ac.client_ip(self.request(ip='127.0.0.1', HTTP_X_FORWARDED_FOR='1.1.1.1, 8.8.8.8, 10.2.2.2')), '8.8.8.8') def test_invalid_forwarded_fails_closed(self): with patch.dict('os.environ', {'MAXKB_ACCESS_TRUSTED_PROXIES': '127.0.0.1/32'}): with self.assertRaises(AppUnauthorizedFailed): ac.client_ip(self.request(ip='127.0.0.1', HTTP_X_FORWARDED_FOR='invalid')) def test_invalid_proxy_address_cannot_bypass_device_policy(self): ac.bind(self.policy.id, self.user, {'target_type': 'DEVICE', 'target_identifier': '10.1.0.0/16'}) with patch.dict('os.environ', {'MAXKB_ACCESS_TRUSTED_PROXIES': '127.0.0.1/32'}): with self.assertRaises(AppUnauthorizedFailed): ac.enforce(self.request(ip='127.0.0.1', HTTP_X_FORWARDED_FOR='invalid'), 'mindmap', 'sample') self.assertEqual(Log.objects.first().details['reason'], '来源 IP 无效') def test_device_classification(self): for agent, expected in [('Mozilla Windows', '桌面端'), ('iPhone Mobile', '移动终端'), ('iPad', '平板'), ('Android Tablet', '平板'), ('curl/8', '服务器'), ('', '未知')]: with self.subTest(agent=agent): self.assertEqual(ac.device_type(self.request(agent=agent)), expected) def test_time_boundaries(self): self.policy.access_time_enabled = True; self.policy.access_start_time = time(10); self.policy.access_end_time = time(11) self.assertEqual(ac.policy_reason(self.policy, self.now, '桌面端', set()), '') self.assertTrue(ac.policy_reason(self.policy, self.now + timedelta(hours=1), '桌面端', set())) def test_weekday(self): self.policy.access_time_enabled = True; self.policy.access_start_time = time(9); self.policy.access_end_time = time(18) self.policy.allowed_weekdays = [2] self.assertTrue(ac.policy_reason(self.policy, self.now, '桌面端', set())) def test_overnight_start_day(self): self.policy.access_time_enabled = True; self.policy.access_start_time = time(22); self.policy.access_end_time = time(6) self.policy.allowed_weekdays = [1] for utc_hour in [15, 19]: self.assertEqual(ac.policy_reason(self.policy, self.now.replace(hour=utc_hour), '桌面端', set()), '') self.assertTrue(ac.policy_reason(self.policy, self.now.replace(hour=22), '桌面端', set())) def test_effective_boundaries(self): self.policy.allowed_device_types = ['移动终端'] self.policy.effect_start_time = self.now + timedelta(seconds=1) self.assertEqual(ac.policy_reason(self.policy, self.now, '桌面端', set()), '') self.policy.effect_start_time = self.now self.assertTrue(ac.policy_reason(self.policy, self.now, '桌面端', set())) self.policy.effect_end_time = self.now self.assertEqual(ac.policy_reason(self.policy, self.now, '桌面端', set()), '') def test_invalid_time_denied(self): self.policy.access_time_enabled = True self.assertTrue(ac.policy_reason(self.policy, self.now, '桌面端', set())) def test_serializer_overnight_and_equal(self): values = {'name': '夜间策略', 'access_time_enabled': True, 'access_start_time': '22:00', 'access_end_time': '06:00'} self.assertTrue(AccessControlPolicySerializer(data=values).is_valid(raise_exception=True)) values['access_end_time'] = '22:00' with self.assertRaises(AppApiException): AccessControlPolicySerializer(data=values).is_valid(raise_exception=True) def test_serializer_device_options(self): with self.assertRaises(AppApiException): AccessControlPolicySerializer(data={'name': '无效设备策略', 'allowed_device_types': ['任意设备']}).is_valid(raise_exception=True) def test_auth_does_not_read_lazy_user(self): self.bind() class PendingRequest: META = {'REMOTE_ADDR': '10.1.2.3', 'HTTP_USER_AGENT': 'Mozilla'} path = '/chat/api/chat' @property def user(self): raise AssertionError('authentication recursion') ac.enforce(PendingRequest(), 'application', 'sample') def test_token_auth_enforces_published_and_api_requests(self): from common.auth.authenticate import TokenAuth from common.constants.permission_constants import ChatAuth auth = ChatAuth([], [], 'client', 'APPLICATION_API_KEY', 'sample') handler = SimpleNamespace(support=lambda *args: True, handle=lambda *args: (None, auth)) self.bind(); self.policy.allowed_device_types = ['移动终端']; self.policy.save() request = self.request(); request.META['HTTP_AUTHORIZATION'] = 'Bearer test' with patch('common.auth.authenticate.handles', [handler]), patch('traceback.print_stack'), self.assertRaises(AppUnauthorizedFailed): TokenAuth().authenticate(request) def test_token_cannot_call_another_application(self): from common.auth.authenticate import TokenAuth from common.constants.permission_constants import ChatAuth auth = ChatAuth([], [], 'client', 'APPLICATION_API_KEY', 'sample') handler = SimpleNamespace(support=lambda *args: True, handle=lambda *args: (None, auth)) request = self.request(); request.META['HTTP_AUTHORIZATION'] = 'Bearer test' request.resolver_match = SimpleNamespace(kwargs={'application_id': 'different'}) with patch('common.auth.authenticate.handles', [handler]), patch('traceback.print_stack'), self.assertRaises(AppUnauthorizedFailed): TokenAuth().authenticate(request) def test_direct_workbench_cannot_bypass_device_binding(self): ac.bind(self.policy.id, self.user, {'target_type': 'DEVICE', 'target_identifier': '10.1.0.0/16'}) self.policy.allowed_device_types = ['移动终端']; self.policy.save() with self.assertRaises(AppUnauthorizedFailed): ac.enforce_task(self.request(), nodes=[{'type': 'render'}]) def test_retry_checks_original_service(self): self.bind(target='mindmap:sample') self.policy.allowed_device_types = ['移动终端']; self.policy.save() with self.assertRaises(AppUnauthorizedFailed): ac.enforce_task(self.request(), 'sample', [{'type': 'render'}]) def test_parser_check_precedes_file_storage(self): from unittest.mock import Mock from django.core.files.uploadedfile import SimpleUploadedFile from knowledge.serializers.document import DocumentSerializers self.bind(target='parser:sample') self.policy.allowed_device_types = ['移动终端']; self.policy.save() serializer = DocumentSerializers.Split(data={}, context={'request': self.request()}) serializer._validated_data = {} serializer._errors = {} serializer._data = {'workspace_id': 'default', 'knowledge_id': 'sample'} serializer.is_valid = Mock(return_value=True) with patch('knowledge.serializers.document.QuerySet') as query, patch('knowledge.models.File.save') as store: query.return_value.filter.return_value.first.return_value = SimpleNamespace(meta={'parser_id': 'sample'}) with self.assertRaises(AppUnauthorizedFailed): serializer.parse({'file': [SimpleUploadedFile('CODEX.pdf', b'test')]}) store.assert_not_called()