merge: with v3

apps/authentication/api/connection_token.py

@@ -1,109 +1,67 @@
-import abc
-import os
-import json
 import base64
+import json
+import os
 import urllib.parse
+
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404
-from rest_framework.exceptions import PermissionDenied
-from rest_framework.decorators import action
-from rest_framework.response import Response
+from django.utils import timezone
 from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.exceptions import PermissionDenied
 from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.serializers import ValidationError
 
 from common.drf.api import JMSModelViewSet
 from common.http import is_true
+from common.utils import random_string
+from common.utils.django import get_request_os
 from orgs.mixins.api import RootOrgViewMixin
-from perms.models.base import Action
-from terminal.models import EndpointRule
+from perms.models import ActionChoices
+from terminal.const import NativeClient, TerminalType
+from terminal.models import EndpointRule, Applet
+from ..models import ConnectionToken
 from ..serializers import (
     ConnectionTokenSerializer, ConnectionTokenSecretSerializer,
-    SuperConnectionTokenSerializer, ConnectionTokenDisplaySerializer,
+    SuperConnectionTokenSerializer,
 )
-from ..models import ConnectionToken
 
 __all__ = ['ConnectionTokenViewSet', 'SuperConnectionTokenViewSet']
 
 
-class ConnectionTokenMixin:
+class RDPFileClientProtocolURLMixin:
     request: Request
+    get_serializer: callable
 
     @staticmethod
-    def check_token_valid(token: ConnectionToken):
-        is_valid, error = token.check_valid()
-        if not is_valid:
-            raise PermissionDenied(error)
+    def set_applet_info(token, rdp_options):
+        # remote-app
+        applet = Applet.objects.filter(name=token.connect_method).first()
+        if not applet:
+            return rdp_options
 
-    @abc.abstractmethod
-    def get_request_resource_user(self, serializer):
-        raise NotImplementedError
-
-    def get_request_resources(self, serializer):
-        user = self.get_request_resource_user(serializer)
-        asset = serializer.validated_data.get('asset')
-        application = serializer.validated_data.get('application')
-        system_user = serializer.validated_data.get('system_user')
-        return user, asset, application, system_user
-
-    @staticmethod
-    def check_user_has_resource_permission(user, asset, application, system_user):
-        from perms.utils.asset import has_asset_system_permission
-        from perms.utils.application import has_application_system_permission
-
-        if asset and not has_asset_system_permission(user, asset, system_user):
-            error = f'User not has this asset and system user permission: ' \
-                    f'user={user.id} system_user={system_user.id} asset={asset.id}'
-            raise PermissionDenied(error)
-
-        if application and not has_application_system_permission(user, application, system_user):
-            error = f'User not has this application and system user permission: ' \
-                    f'user={user.id} system_user={system_user.id} application={application.id}'
-            raise PermissionDenied(error)
-
-    def get_smart_endpoint(self, protocol, asset=None, application=None):
-        if asset:
-            target_instance = asset
-            target_ip = asset.get_target_ip()
-        elif application:
-            target_instance = application
-            target_ip = application.get_target_ip()
-        else:
-            target_instance = None
-            target_ip = ''
-        endpoint = EndpointRule.match_endpoint(target_instance, target_ip, protocol, self.request)
-        return endpoint
-
-    @staticmethod
-    def parse_env_bool(env_key, env_default, true_value, false_value):
-        return true_value if is_true(os.getenv(env_key, env_default)) else false_value
-
-    def get_client_protocol_data(self, token: ConnectionToken):
-        from assets.models import SystemUser
-        protocol = token.system_user.protocol
-        username = token.user.username
-        rdp_config = ssh_token = ''
-        if protocol == SystemUser.Protocol.rdp:
-            filename, rdp_config = self.get_rdp_file_info(token)
-        elif protocol == SystemUser.Protocol.ssh:
-            filename, ssh_token = self.get_ssh_token(token)
-        else:
-            raise ValueError('Protocol not support: {}'.format(protocol))
-        filename = urllib.parse.unquote(filename)
-        return {
-            "filename": filename,
-            "protocol": protocol,
-            "username": username,
-            "token": ssh_token,
-            "config": rdp_config
+        cmdline = {
+            'app_name': applet.name,
+            'user_id': str(token.user.id),
+            'asset_id': str(token.asset.id),
+            'token_id': str(token.id)
         }
 
+        app = '||tinker'
+        rdp_options['remoteapplicationmode:i'] = '1'
+        rdp_options['alternate shell:s'] = app
+        rdp_options['remoteapplicationprogram:s'] = app
+        rdp_options['remoteapplicationname:s'] = app
+
+        cmdline_b64 = base64.b64encode(json.dumps(cmdline).encode()).decode()
+        rdp_options['remoteapplicationcmdline:s'] = cmdline_b64
+        return rdp_options
+
     def get_rdp_file_info(self, token: ConnectionToken):
         rdp_options = {
             'full address:s': '',
             'username:s': '',
-            # 'screen mode id:i': '1',
-            # 'desktopwidth:i': '1280',
-            # 'desktopheight:i': '800',
             'use multimon:i': '0',
             'session bpp:i': '32',
             'audiomode:i': '0',
@@ -124,18 +82,12 @@ class ConnectionTokenMixin:
             'bookmarktype:i': '3',
             'use redirection server name:i': '0',
             'smart sizing:i': '1',
-            # 'drivestoredirect:s': '*',
-            # 'domain:s': ''
-            # 'alternate shell:s:': '||MySQLWorkbench',
-            # 'remoteapplicationname:s': 'Firefox',
-            # 'remoteapplicationcmdline:s': '',
         }
 
         # 设置磁盘挂载
         drives_redirect = is_true(self.request.query_params.get('drives_redirect'))
         if drives_redirect:
-            actions = Action.choices_to_value(token.actions)
-            if actions & Action.UPDOWNLOAD == Action.UPDOWNLOAD:
+            if ActionChoices.contains(token.actions, ActionChoices.transfer()):
                 rdp_options['drivestoredirect:s'] = '*'
 
         # 设置全屏
@@ -143,15 +95,12 @@ class ConnectionTokenMixin:
         rdp_options['screen mode id:i'] = '2' if full_screen else '1'
 
         # 设置 RDP Server 地址
-        endpoint = self.get_smart_endpoint(
-            protocol='rdp', asset=token.asset, application=token.application
-        )
+        endpoint = self.get_smart_endpoint(protocol='rdp', asset=token.asset)
         rdp_options['full address:s'] = f'{endpoint.host}:{endpoint.rdp_port}'
 
         # 设置用户名
         rdp_options['username:s'] = '{}|{}'.format(token.user.username, str(token.id))
-        if token.system_user.ad_domain:
-            rdp_options['domain:s'] = token.system_user.ad_domain
+        # rdp_options['domain:s'] = token.account_ad_domain
 
         # 设置宽高
         height = self.request.query_params.get('height')
@@ -165,17 +114,11 @@ class ConnectionTokenMixin:
         rdp_options['session bpp:i'] = os.getenv('JUMPSERVER_COLOR_DEPTH', '32')
         rdp_options['audiomode:i'] = self.parse_env_bool('JUMPSERVER_DISABLE_AUDIO', 'false', '2', '0')
 
-        if token.asset:
-            name = token.asset.hostname
-        elif token.application and token.application.category_remote_app:
-            app = '||jmservisor'
-            name = token.application.name
-            rdp_options['remoteapplicationmode:i'] = '1'
-            rdp_options['alternate shell:s'] = app
-            rdp_options['remoteapplicationprogram:s'] = app
-            rdp_options['remoteapplicationname:s'] = name
-        else:
-            name = '*'
+        # 设置远程应用
+        self.set_applet_info(token, rdp_options)
+
+        # 文件名
+        name = token.asset.name
         prefix_name = f'{token.user.username}-{name}'
         filename = self.get_connect_filename(prefix_name)
 
@@ -194,104 +137,71 @@ class ConnectionTokenMixin:
         filename = urllib.parse.quote(filename)
         return filename
 
-    def get_ssh_token(self, token: ConnectionToken):
-        if token.asset:
-            name = token.asset.hostname
-        elif token.application:
-            name = token.application.name
-        else:
-            name = '*'
-        prefix_name = f'{token.user.username}-{name}'
-        filename = self.get_connect_filename(prefix_name)
+    @staticmethod
+    def parse_env_bool(env_key, env_default, true_value, false_value):
+        return true_value if is_true(os.getenv(env_key, env_default)) else false_value
 
-        endpoint = self.get_smart_endpoint(
-            protocol='ssh', asset=token.asset, application=token.application
+    def get_client_protocol_data(self, token: ConnectionToken):
+        _os = get_request_os(self.request)
+
+        connect_method_name = token.connect_method
+        connect_method_dict = TerminalType.get_connect_method(
+            token.connect_method, token.protocol, _os
         )
+        if connect_method_dict is None:
+            raise ValueError('Connect method not support: {}'.format(connect_method_name))
+
         data = {
-            'ip': endpoint.host,
-            'port': str(endpoint.ssh_port),
-            'username': 'JMS-{}'.format(str(token.id)),
-            'password': token.secret
+            'id': str(token.id),
+            'value': token.value,
+            'protocol': token.protocol,
+            'command': '',
+            'file': {}
         }
-        token = json.dumps(data)
-        return filename, token
 
-
-class ConnectionTokenViewSet(ConnectionTokenMixin, RootOrgViewMixin, JMSModelViewSet):
-    filterset_fields = (
-        'type', 'user_display', 'system_user_display',
-        'application_display', 'asset_display'
-    )
-    search_fields = filterset_fields
-    serializer_classes = {
-        'default': ConnectionTokenSerializer,
-        'list': ConnectionTokenDisplaySerializer,
-        'retrieve': ConnectionTokenDisplaySerializer,
-        'get_secret_detail': ConnectionTokenSecretSerializer,
-    }
-    rbac_perms = {
-        'retrieve': 'authentication.view_connectiontoken',
-        'create': 'authentication.add_connectiontoken',
-        'expire': 'authentication.add_connectiontoken',
-        'get_secret_detail': 'authentication.view_connectiontokensecret',
-        'get_rdp_file': 'authentication.add_connectiontoken',
-        'get_client_protocol_url': 'authentication.add_connectiontoken',
-    }
-
-    def get_queryset(self):
-        return ConnectionToken.objects.filter(user=self.request.user)
-
-    def get_request_resource_user(self, serializer):
-        return self.request.user
-
-    def get_object(self):
-        if self.request.user.is_service_account:
-            # TODO: 组件获取 token 详情，将来放在 Super-connection-token API 中
-            obj = get_object_or_404(ConnectionToken, pk=self.kwargs.get('pk'))
+        if connect_method_name == NativeClient.mstsc:
+            filename, content = self.get_rdp_file_info(token)
+            data.update({
+                'file': {
+                    'name': filename,
+                    'content': content,
+                }
+            })
         else:
-            obj = super(ConnectionTokenViewSet, self).get_object()
-        return obj
+            endpoint = self.get_smart_endpoint(
+                protocol=connect_method_dict['endpoint_protocol'],
+                asset=token.asset
+            )
+            cmd = NativeClient.get_launch_command(connect_method_name, token, endpoint)
+            data.update({'command': cmd})
+        return data
 
-    def create_connection_token(self):
-        data = self.request.query_params if self.request.method == 'GET' else self.request.data
-        serializer = self.get_serializer(data=data)
-        serializer.is_valid(raise_exception=True)
-        self.perform_create(serializer)
-        token: ConnectionToken = serializer.instance
-        return token
+    def get_smart_endpoint(self, protocol, asset=None):
+        target_ip = asset.get_target_ip() if asset else ''
+        endpoint = EndpointRule.match_endpoint(target_ip, protocol, self.request)
+        return endpoint
 
-    def perform_create(self, serializer):
-        user, asset, application, system_user = self.get_request_resources(serializer)
-        self.check_user_has_resource_permission(user, asset, application, system_user)
-        return super(ConnectionTokenViewSet, self).perform_create(serializer)
 
-    @action(methods=['POST'], detail=False, url_path='secret-info/detail')
-    def get_secret_detail(self, request, *args, **kwargs):
-        # 非常重要的 api，在逻辑层再判断一下，双重保险
-        perm_required = 'authentication.view_connectiontokensecret'
-        if not request.user.has_perm(perm_required):
-            raise PermissionDenied('Not allow to view secret')
-        token_id = request.data.get('token') or ''
-        token = get_object_or_404(ConnectionToken, pk=token_id)
-        self.check_token_valid(token)
-        token.load_system_user_auth()
-        serializer = self.get_serializer(instance=token)
-        return Response(serializer.data, status=status.HTTP_200_OK)
+class ExtraActionApiMixin(RDPFileClientProtocolURLMixin):
+    request: Request
+    get_object: callable
+    get_serializer: callable
+    perform_create: callable
 
-    @action(methods=['POST', 'GET'], detail=False, url_path='rdp/file')
-    def get_rdp_file(self, request, *args, **kwargs):
-        token = self.create_connection_token()
-        self.check_token_valid(token)
+    @action(methods=['POST', 'GET'], detail=True, url_path='rdp-file')
+    def get_rdp_file(self, *args, **kwargs):
+        token = self.get_object()
+        token.is_valid()
         filename, content = self.get_rdp_file_info(token)
         filename = '{}.rdp'.format(filename)
         response = HttpResponse(content, content_type='application/octet-stream')
         response['Content-Disposition'] = 'attachment; filename*=UTF-8\'\'%s' % filename
         return response
 
-    @action(methods=['POST', 'GET'], detail=False, url_path='client-url')
-    def get_client_protocol_url(self, request, *args, **kwargs):
-        token = self.create_connection_token()
-        self.check_token_valid(token)
+    @action(methods=['POST', 'GET'], detail=True, url_path='client-url')
+    def get_client_protocol_url(self, *args, **kwargs):
+        token = self.get_object()
+        token.is_valid()
         try:
             protocol_data = self.get_client_protocol_data(token)
         except ValueError as e:
@@ -310,6 +220,88 @@ class ConnectionTokenViewSet(ConnectionTokenMixin, RootOrgViewMixin, JMSModelVie
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
+class ConnectionTokenViewSet(ExtraActionApiMixin, RootOrgViewMixin, JMSModelViewSet):
+    filterset_fields = (
+        'user_display', 'asset_display'
+    )
+    search_fields = filterset_fields
+    serializer_classes = {
+        'default': ConnectionTokenSerializer,
+        'get_secret_detail': ConnectionTokenSecretSerializer,
+    }
+    rbac_perms = {
+        'list': 'authentication.view_connectiontoken',
+        'retrieve': 'authentication.view_connectiontoken',
+        'create': 'authentication.add_connectiontoken',
+        'expire': 'authentication.add_connectiontoken',
+        'get_secret_detail': 'authentication.view_connectiontokensecret',
+        'get_rdp_file': 'authentication.add_connectiontoken',
+        'get_client_protocol_url': 'authentication.add_connectiontoken',
+    }
+
+    @action(methods=['POST'], detail=False, url_path='secret')
+    def get_secret_detail(self, request, *args, **kwargs):
+        """ 非常重要的 api, 在逻辑层再判断一下 rbac 权限, 双重保险 """
+        rbac_perm = 'authentication.view_connectiontokensecret'
+        if not request.user.has_perm(rbac_perm):
+            raise PermissionDenied('Not allow to view secret')
+
+        token_id = request.data.get('id') or ''
+        token = get_object_or_404(ConnectionToken, pk=token_id)
+        if token.is_expired:
+            raise ValidationError({'id': 'Token is expired'})
+
+        token.is_valid()
+        serializer = self.get_serializer(instance=token)
+        expire_now = request.data.get('expire_now', True)
+        if expire_now:
+            token.expire()
+
+        return Response(serializer.data, status=status.HTTP_200_OK)
+
+    def get_queryset(self):
+        queryset = ConnectionToken.objects \
+            .filter(user=self.request.user) \
+            .filter(date_expired__gt=timezone.now())
+        return queryset
+
+    def get_user(self, serializer):
+        return self.request.user
+
+    def perform_create(self, serializer):
+        self.validate_serializer(serializer)
+        return super().perform_create(serializer)
+
+    def validate_serializer(self, serializer):
+        from perms.utils.account import PermAccountUtil
+
+        data = serializer.validated_data
+        user = self.get_user(serializer)
+        asset = data.get('asset')
+        account_name = data.get('account')
+        data['org_id'] = asset.org_id
+        data['user'] = user
+        data['value'] = random_string(16)
+
+        util = PermAccountUtil()
+        permed_account = util.validate_permission(user, asset, account_name)
+
+        if not permed_account or not permed_account.actions:
+            msg = 'user `{}` not has asset `{}` permission for login `{}`'.format(
+                user, asset, account_name
+            )
+            raise PermissionDenied(msg)
+
+        if permed_account.date_expired < timezone.now():
+            raise PermissionDenied('Expired')
+
+        if permed_account.has_secret:
+            data['input_secret'] = ''
+        if permed_account.username != '@INPUT':
+            data['input_username'] = ''
+        return permed_account
+
+
 class SuperConnectionTokenViewSet(ConnectionTokenViewSet):
     serializer_classes = {
         'default': SuperConnectionTokenSerializer,
@@ -319,14 +311,17 @@ class SuperConnectionTokenViewSet(ConnectionTokenViewSet):
         'renewal': 'authentication.add_superconnectiontoken'
     }
 
-    def get_request_resource_user(self, serializer):
+    def get_queryset(self):
+        return ConnectionToken.objects.all()
+
+    def get_user(self, serializer):
         return serializer.validated_data.get('user')
 
     @action(methods=['PATCH'], detail=False)
     def renewal(self, request, *args, **kwargs):
         from common.utils.timezone import as_current_tz
 
-        token_id = request.data.get('token') or ''
+        token_id = request.data.get('id') or ''
         token = get_object_or_404(ConnectionToken, pk=token_id)
         date_expired = as_current_tz(token.date_expired)
         if token.is_expired:

apps/authentication/api/temp_token.py

@@ -2,10 +2,10 @@ from django.utils import timezone
 from rest_framework.response import Response
 from rest_framework.decorators import action
 
+from rbac.permissions import RBACPermission
 from common.drf.api import JMSModelViewSet
 from ..models import TempToken
 from ..serializers import TempTokenSerializer
-from rbac.permissions import RBACPermission
 
 
 class TempTokenViewSet(JMSModelViewSet):