UnisKB/apps/system_manage/test_access_control.py

235 lines
14 KiB
Python

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