235 lines
14 KiB
Python
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()
|