2022-11-14 06:03:58 +00:00
|
|
|
import base64
|
2022-07-11 10:09:06 +00:00
|
|
|
import json
|
2022-11-14 06:03:58 +00:00
|
|
|
import os
|
2022-07-11 10:09:06 +00:00
|
|
|
import urllib.parse
|
2022-11-14 06:03:58 +00:00
|
|
|
|
2021-02-24 07:31:22 +00:00
|
|
|
from django.http import HttpResponse
|
2022-07-11 10:09:06 +00:00
|
|
|
from django.shortcuts import get_object_or_404
|
2022-11-22 13:54:40 +00:00
|
|
|
from django.utils import timezone
|
2022-10-31 10:47:12 +00:00
|
|
|
from rest_framework import status
|
2022-07-11 10:09:06 +00:00
|
|
|
from rest_framework.decorators import action
|
2022-11-14 06:03:58 +00:00
|
|
|
from rest_framework.exceptions import PermissionDenied
|
2021-08-02 08:18:34 +00:00
|
|
|
from rest_framework.request import Request
|
2022-11-14 06:03:58 +00:00
|
|
|
from rest_framework.response import Response
|
2022-11-28 14:58:43 +00:00
|
|
|
from rest_framework.serializers import ValidationError
|
2022-07-11 10:09:06 +00:00
|
|
|
|
|
|
|
from common.drf.api import JMSModelViewSet
|
2021-08-03 02:57:57 +00:00
|
|
|
from common.http import is_true
|
2022-11-25 15:09:55 +00:00
|
|
|
from common.utils import random_string
|
2022-11-29 06:42:04 +00:00
|
|
|
from common.utils.django import get_request_os
|
2022-07-11 10:09:06 +00:00
|
|
|
from orgs.mixins.api import RootOrgViewMixin
|
2022-11-11 07:04:31 +00:00
|
|
|
from perms.models import ActionChoices
|
2022-12-07 07:09:01 +00:00
|
|
|
from terminal.connect_methods import NativeClient, ConnectMethodUtil
|
2022-11-29 10:36:42 +00:00
|
|
|
from terminal.models import EndpointRule, Applet
|
2022-11-14 06:03:58 +00:00
|
|
|
from ..models import ConnectionToken
|
2021-02-24 07:31:22 +00:00
|
|
|
from ..serializers import (
|
2022-07-20 05:18:56 +00:00
|
|
|
ConnectionTokenSerializer, ConnectionTokenSecretSerializer,
|
2022-12-07 07:09:01 +00:00
|
|
|
SuperConnectionTokenSerializer, ConnectTokenAppletOptionSerializer
|
2022-11-29 13:41:33 +00:00
|
|
|
)
|
2019-02-27 12:55:28 +00:00
|
|
|
|
2022-07-11 10:09:06 +00:00
|
|
|
__all__ = ['ConnectionTokenViewSet', 'SuperConnectionTokenViewSet']
|
2022-02-17 12:13:31 +00:00
|
|
|
|
2022-11-14 06:03:58 +00:00
|
|
|
|
2022-10-31 10:47:12 +00:00
|
|
|
class RDPFileClientProtocolURLMixin:
|
|
|
|
request: Request
|
|
|
|
get_serializer: callable
|
2022-07-11 10:09:06 +00:00
|
|
|
|
2022-11-29 10:36:42 +00:00
|
|
|
@staticmethod
|
|
|
|
def set_applet_info(token, rdp_options):
|
|
|
|
# remote-app
|
|
|
|
applet = Applet.objects.filter(name=token.connect_method).first()
|
|
|
|
if not applet:
|
|
|
|
return rdp_options
|
|
|
|
|
|
|
|
cmdline = {
|
|
|
|
'app_name': applet.name,
|
|
|
|
'user_id': str(token.user.id),
|
|
|
|
'asset_id': str(token.asset.id),
|
2022-11-29 13:50:48 +00:00
|
|
|
'token_id': str(token.id)
|
2022-11-29 10:36:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
|
2022-07-11 10:09:06 +00:00
|
|
|
def get_rdp_file_info(self, token: ConnectionToken):
|
|
|
|
rdp_options = {
|
2021-02-24 07:31:22 +00:00
|
|
|
'full address:s': '',
|
|
|
|
'username:s': '',
|
2021-07-16 06:15:10 +00:00
|
|
|
'use multimon:i': '0',
|
2021-04-29 06:18:52 +00:00
|
|
|
'session bpp:i': '32',
|
2021-02-24 07:31:22 +00:00
|
|
|
'audiomode:i': '0',
|
|
|
|
'disable wallpaper:i': '0',
|
|
|
|
'disable full window drag:i': '0',
|
|
|
|
'disable menu anims:i': '0',
|
|
|
|
'disable themes:i': '0',
|
|
|
|
'alternate shell:s': '',
|
|
|
|
'shell working directory:s': '',
|
|
|
|
'authentication level:i': '2',
|
|
|
|
'connect to console:i': '0',
|
|
|
|
'disable cursor setting:i': '0',
|
|
|
|
'allow font smoothing:i': '1',
|
|
|
|
'allow desktop composition:i': '1',
|
|
|
|
'redirectprinters:i': '0',
|
|
|
|
'prompt for credentials on client:i': '0',
|
|
|
|
'autoreconnection enabled:i': '1',
|
|
|
|
'bookmarktype:i': '3',
|
|
|
|
'use redirection server name:i': '0',
|
2022-03-25 02:43:48 +00:00
|
|
|
'smart sizing:i': '1',
|
2021-02-24 07:31:22 +00:00
|
|
|
}
|
|
|
|
|
2021-11-16 03:32:25 +00:00
|
|
|
# 设置磁盘挂载
|
2022-07-11 10:09:06 +00:00
|
|
|
drives_redirect = is_true(self.request.query_params.get('drives_redirect'))
|
2022-02-16 07:48:28 +00:00
|
|
|
if drives_redirect:
|
2022-11-23 08:11:17 +00:00
|
|
|
if ActionChoices.contains(token.actions, ActionChoices.transfer()):
|
2022-07-11 10:09:06 +00:00
|
|
|
rdp_options['drivestoredirect:s'] = '*'
|
2021-10-07 07:30:39 +00:00
|
|
|
|
2022-07-11 10:09:06 +00:00
|
|
|
# 设置全屏
|
|
|
|
full_screen = is_true(self.request.query_params.get('full_screen'))
|
|
|
|
rdp_options['screen mode id:i'] = '2' if full_screen else '1'
|
2021-11-16 03:32:25 +00:00
|
|
|
|
2022-07-11 10:09:06 +00:00
|
|
|
# 设置 RDP Server 地址
|
2022-10-27 07:47:05 +00:00
|
|
|
endpoint = self.get_smart_endpoint(protocol='rdp', asset=token.asset)
|
2022-07-11 10:09:06 +00:00
|
|
|
rdp_options['full address:s'] = f'{endpoint.host}:{endpoint.rdp_port}'
|
2021-11-09 09:10:29 +00:00
|
|
|
|
2022-07-11 10:09:06 +00:00
|
|
|
# 设置用户名
|
|
|
|
rdp_options['username:s'] = '{}|{}'.format(token.user.username, str(token.id))
|
2022-10-27 07:47:05 +00:00
|
|
|
# rdp_options['domain:s'] = token.account_ad_domain
|
2021-11-09 09:10:29 +00:00
|
|
|
|
2022-07-11 10:09:06 +00:00
|
|
|
# 设置宽高
|
|
|
|
height = self.request.query_params.get('height')
|
|
|
|
width = self.request.query_params.get('width')
|
|
|
|
if width and height:
|
|
|
|
rdp_options['desktopwidth:i'] = width
|
|
|
|
rdp_options['desktopheight:i'] = height
|
|
|
|
rdp_options['winposstr:s:'] = f'0,1,0,0,{width},{height}'
|
|
|
|
|
|
|
|
# 设置其他选项
|
|
|
|
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')
|
|
|
|
|
2022-11-29 10:36:42 +00:00
|
|
|
# 设置远程应用
|
2022-12-07 07:09:01 +00:00
|
|
|
remote_app_options = token.get_remote_app_option()
|
|
|
|
rdp_options.update(remote_app_options)
|
2022-11-29 10:36:42 +00:00
|
|
|
|
|
|
|
# 文件名
|
|
|
|
name = token.asset.name
|
2022-08-10 10:17:59 +00:00
|
|
|
prefix_name = f'{token.user.username}-{name}'
|
|
|
|
filename = self.get_connect_filename(prefix_name)
|
2022-07-11 10:09:06 +00:00
|
|
|
|
2021-09-24 07:31:25 +00:00
|
|
|
content = ''
|
2022-07-11 10:09:06 +00:00
|
|
|
for k, v in rdp_options.items():
|
2021-09-24 07:31:25 +00:00
|
|
|
content += f'{k}:{v}\n'
|
2021-07-27 05:35:25 +00:00
|
|
|
|
2022-07-11 10:09:06 +00:00
|
|
|
return filename, content
|
|
|
|
|
2022-08-10 10:17:59 +00:00
|
|
|
@staticmethod
|
|
|
|
def get_connect_filename(prefix_name):
|
|
|
|
prefix_name = prefix_name.replace('/', '_')
|
|
|
|
prefix_name = prefix_name.replace('\\', '_')
|
|
|
|
prefix_name = prefix_name.replace('.', '_')
|
|
|
|
filename = f'{prefix_name}-jumpserver'
|
|
|
|
filename = urllib.parse.quote(filename)
|
|
|
|
return filename
|
|
|
|
|
2022-10-31 10:47:12 +00:00
|
|
|
@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):
|
2022-11-29 06:42:04 +00:00
|
|
|
_os = get_request_os(self.request)
|
2022-10-31 10:47:12 +00:00
|
|
|
|
2022-11-29 13:41:33 +00:00
|
|
|
connect_method_name = token.connect_method
|
2022-12-07 07:09:01 +00:00
|
|
|
connect_method_dict = ConnectMethodUtil.get_connect_method(
|
2022-11-29 13:41:33 +00:00
|
|
|
token.connect_method, token.protocol, _os
|
|
|
|
)
|
|
|
|
if connect_method_dict is None:
|
|
|
|
raise ValueError('Connect method not support: {}'.format(connect_method_name))
|
2022-03-28 11:52:48 +00:00
|
|
|
|
2022-07-11 10:09:06 +00:00
|
|
|
data = {
|
2022-11-29 06:42:04 +00:00
|
|
|
'id': str(token.id),
|
|
|
|
'value': token.value,
|
2022-11-30 12:02:13 +00:00
|
|
|
'protocol': token.protocol,
|
2022-11-29 06:45:29 +00:00
|
|
|
'command': '',
|
2022-11-29 06:42:04 +00:00
|
|
|
'file': {}
|
2022-03-28 11:52:48 +00:00
|
|
|
}
|
2022-11-29 06:42:04 +00:00
|
|
|
|
2022-11-29 13:41:33 +00:00
|
|
|
if connect_method_name == NativeClient.mstsc:
|
2022-11-29 06:42:04 +00:00
|
|
|
filename, content = self.get_rdp_file_info(token)
|
|
|
|
data.update({
|
|
|
|
'file': {
|
2022-11-29 06:45:29 +00:00
|
|
|
'name': filename,
|
2022-11-29 06:42:04 +00:00
|
|
|
'content': content,
|
|
|
|
}
|
|
|
|
})
|
|
|
|
else:
|
2022-11-29 13:41:33 +00:00
|
|
|
endpoint = self.get_smart_endpoint(
|
|
|
|
protocol=connect_method_dict['endpoint_protocol'],
|
|
|
|
asset=token.asset
|
|
|
|
)
|
|
|
|
cmd = NativeClient.get_launch_command(connect_method_name, token, endpoint)
|
2022-11-29 06:45:29 +00:00
|
|
|
data.update({'command': cmd})
|
2022-11-29 06:42:04 +00:00
|
|
|
return data
|
2022-03-28 11:52:48 +00:00
|
|
|
|
2022-10-31 10:47:12 +00:00
|
|
|
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
|
2021-09-24 07:31:25 +00:00
|
|
|
|
2021-11-16 03:32:25 +00:00
|
|
|
|
2022-10-31 10:47:12 +00:00
|
|
|
class ExtraActionApiMixin(RDPFileClientProtocolURLMixin):
|
|
|
|
request: Request
|
|
|
|
get_object: callable
|
|
|
|
get_serializer: callable
|
|
|
|
perform_create: callable
|
2022-07-11 10:09:06 +00:00
|
|
|
|
2022-11-28 07:01:16 +00:00
|
|
|
@action(methods=['POST', 'GET'], detail=True, url_path='rdp-file')
|
|
|
|
def get_rdp_file(self, *args, **kwargs):
|
|
|
|
token = self.get_object()
|
2022-11-23 08:11:17 +00:00
|
|
|
token.is_valid()
|
2022-07-11 10:09:06 +00:00
|
|
|
filename, content = self.get_rdp_file_info(token)
|
|
|
|
filename = '{}.rdp'.format(filename)
|
|
|
|
response = HttpResponse(content, content_type='application/octet-stream')
|
2022-04-24 09:00:48 +00:00
|
|
|
response['Content-Disposition'] = 'attachment; filename*=UTF-8\'\'%s' % filename
|
|
|
|
return response
|
|
|
|
|
2022-11-28 07:01:16 +00:00
|
|
|
@action(methods=['POST', 'GET'], detail=True, url_path='client-url')
|
|
|
|
def get_client_protocol_url(self, *args, **kwargs):
|
|
|
|
token = self.get_object()
|
2022-11-23 08:11:17 +00:00
|
|
|
token.is_valid()
|
2021-11-16 03:32:25 +00:00
|
|
|
try:
|
2022-07-11 10:09:06 +00:00
|
|
|
protocol_data = self.get_client_protocol_data(token)
|
2021-11-16 03:32:25 +00:00
|
|
|
except ValueError as e:
|
2022-07-11 10:09:06 +00:00
|
|
|
return Response(data={'error': str(e)}, status=status.HTTP_400_BAD_REQUEST)
|
2021-11-16 03:32:25 +00:00
|
|
|
protocol_data = json.dumps(protocol_data).encode()
|
|
|
|
protocol_data = base64.b64encode(protocol_data).decode()
|
2021-08-02 08:18:34 +00:00
|
|
|
data = {
|
2022-07-11 10:09:06 +00:00
|
|
|
'url': 'jms://{}'.format(protocol_data)
|
2021-08-02 08:18:34 +00:00
|
|
|
}
|
|
|
|
return Response(data=data)
|
|
|
|
|
2022-07-11 10:09:06 +00:00
|
|
|
@action(methods=['PATCH'], detail=True)
|
|
|
|
def expire(self, request, *args, **kwargs):
|
|
|
|
instance = self.get_object()
|
|
|
|
instance.expire()
|
|
|
|
return Response(status=status.HTTP_204_NO_CONTENT)
|
2022-05-31 08:20:33 +00:00
|
|
|
|
2022-10-31 10:47:12 +00:00
|
|
|
|
|
|
|
class ConnectionTokenViewSet(ExtraActionApiMixin, RootOrgViewMixin, JMSModelViewSet):
|
|
|
|
filterset_fields = (
|
|
|
|
'user_display', 'asset_display'
|
|
|
|
)
|
|
|
|
search_fields = filterset_fields
|
|
|
|
serializer_classes = {
|
|
|
|
'default': ConnectionTokenSerializer,
|
|
|
|
}
|
|
|
|
rbac_perms = {
|
2022-11-29 06:42:04 +00:00
|
|
|
'list': 'authentication.view_connectiontoken',
|
2022-10-31 10:47:12 +00:00
|
|
|
'retrieve': 'authentication.view_connectiontoken',
|
|
|
|
'create': 'authentication.add_connectiontoken',
|
|
|
|
'expire': 'authentication.add_connectiontoken',
|
|
|
|
'get_rdp_file': 'authentication.add_connectiontoken',
|
|
|
|
'get_client_protocol_url': 'authentication.add_connectiontoken',
|
|
|
|
}
|
|
|
|
|
|
|
|
def get_queryset(self):
|
2022-11-29 06:42:04 +00:00
|
|
|
queryset = ConnectionToken.objects \
|
|
|
|
.filter(user=self.request.user) \
|
|
|
|
.filter(date_expired__gt=timezone.now())
|
2022-11-28 14:58:43 +00:00
|
|
|
return queryset
|
2022-10-31 10:47:12 +00:00
|
|
|
|
|
|
|
def get_user(self, serializer):
|
|
|
|
return self.request.user
|
|
|
|
|
|
|
|
def perform_create(self, serializer):
|
2022-11-22 13:54:40 +00:00
|
|
|
self.validate_serializer(serializer)
|
|
|
|
return super().perform_create(serializer)
|
2022-10-31 10:47:12 +00:00
|
|
|
|
2022-11-22 13:54:40 +00:00
|
|
|
def validate_serializer(self, serializer):
|
2022-10-31 10:47:12 +00:00
|
|
|
from perms.utils.account import PermAccountUtil
|
2022-11-22 13:54:40 +00:00
|
|
|
|
|
|
|
data = serializer.validated_data
|
|
|
|
user = self.get_user(serializer)
|
|
|
|
asset = data.get('asset')
|
2022-12-05 04:42:15 +00:00
|
|
|
account_name = data.get('account')
|
2022-11-22 13:54:40 +00:00
|
|
|
data['org_id'] = asset.org_id
|
|
|
|
data['user'] = user
|
2022-11-25 15:09:55 +00:00
|
|
|
data['value'] = random_string(16)
|
2022-11-22 13:54:40 +00:00
|
|
|
|
|
|
|
util = PermAccountUtil()
|
2022-11-25 15:09:55 +00:00
|
|
|
permed_account = util.validate_permission(user, asset, account_name)
|
2022-11-22 13:54:40 +00:00
|
|
|
|
|
|
|
if not permed_account or not permed_account.actions:
|
2022-12-15 08:02:34 +00:00
|
|
|
msg = 'user `{}` not has asset `{}` permission for account `{}`'.format(
|
2022-11-25 15:09:55 +00:00
|
|
|
user, asset, account_name
|
2022-11-22 13:54:40 +00:00
|
|
|
)
|
|
|
|
raise PermissionDenied(msg)
|
|
|
|
|
|
|
|
if permed_account.date_expired < timezone.now():
|
|
|
|
raise PermissionDenied('Expired')
|
|
|
|
|
|
|
|
if permed_account.has_secret:
|
2022-11-25 15:09:55 +00:00
|
|
|
data['input_secret'] = ''
|
2022-11-22 13:54:40 +00:00
|
|
|
if permed_account.username != '@INPUT':
|
2022-11-25 15:09:55 +00:00
|
|
|
data['input_username'] = ''
|
2022-11-22 13:54:40 +00:00
|
|
|
return permed_account
|
2022-10-31 10:47:12 +00:00
|
|
|
|
|
|
|
|
2022-07-11 10:09:06 +00:00
|
|
|
class SuperConnectionTokenViewSet(ConnectionTokenViewSet):
|
2022-04-24 09:00:48 +00:00
|
|
|
serializer_classes = {
|
|
|
|
'default': SuperConnectionTokenSerializer,
|
2022-12-07 07:09:01 +00:00
|
|
|
'get_secret_detail': ConnectionTokenSecretSerializer,
|
2022-04-24 09:00:48 +00:00
|
|
|
}
|
|
|
|
rbac_perms = {
|
|
|
|
'create': 'authentication.add_superconnectiontoken',
|
2022-12-07 07:09:01 +00:00
|
|
|
'renewal': 'authentication.add_superconnectiontoken',
|
|
|
|
'get_secret_detail': 'authentication.view_connectiontokensecret',
|
|
|
|
'get_applet_info': 'authentication.view_superconnectiontoken',
|
|
|
|
'release_applet_account': 'authentication.view_superconnectiontoken',
|
2022-04-24 09:00:48 +00:00
|
|
|
}
|
|
|
|
|
2022-10-31 10:47:12 +00:00
|
|
|
def get_queryset(self):
|
|
|
|
return ConnectionToken.objects.all()
|
|
|
|
|
|
|
|
def get_user(self, serializer):
|
2022-07-20 05:23:43 +00:00
|
|
|
return serializer.validated_data.get('user')
|
|
|
|
|
2022-07-11 10:09:06 +00:00
|
|
|
@action(methods=['PATCH'], detail=False)
|
2022-04-24 09:00:48 +00:00
|
|
|
def renewal(self, request, *args, **kwargs):
|
2022-07-11 10:09:06 +00:00
|
|
|
from common.utils.timezone import as_current_tz
|
|
|
|
|
2022-11-28 14:58:43 +00:00
|
|
|
token_id = request.data.get('id') or ''
|
2022-07-11 10:09:06 +00:00
|
|
|
token = get_object_or_404(ConnectionToken, pk=token_id)
|
|
|
|
date_expired = as_current_tz(token.date_expired)
|
|
|
|
if token.is_expired:
|
|
|
|
raise PermissionDenied('Token is expired at: {}'.format(date_expired))
|
|
|
|
token.renewal()
|
|
|
|
data = {
|
|
|
|
'ok': True,
|
|
|
|
'msg': f'Token is renewed, date expired: {date_expired}'
|
|
|
|
}
|
|
|
|
return Response(data=data, status=status.HTTP_200_OK)
|
2022-12-07 07:09:01 +00:00
|
|
|
|
|
|
|
@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)
|
|
|
|
|
|
|
|
@action(methods=['POST'], detail=False, url_path='applet-option')
|
|
|
|
def get_applet_info(self, *args, **kwargs):
|
|
|
|
token_id = self.request.data.get('id')
|
|
|
|
token = get_object_or_404(ConnectionToken, pk=token_id)
|
|
|
|
if token.is_expired:
|
|
|
|
return Response({'error': 'Token expired'}, status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
data = token.get_applet_option()
|
|
|
|
serializer = ConnectTokenAppletOptionSerializer(data)
|
|
|
|
return Response(serializer.data)
|
|
|
|
|
|
|
|
@action(methods=['DELETE', 'POST'], detail=False, url_path='applet-account/release')
|
|
|
|
def release_applet_account(self, *args, **kwargs):
|
|
|
|
account_id = self.request.data.get('id')
|
|
|
|
msg = ConnectionToken.release_applet_account(account_id)
|
|
|
|
return Response({'msg': msg})
|