व्यवस्थापक सेवा: डेस्कटॉप में उपयोगकर्ता को लॉग इन करें, एक प्रक्रिया को जन्म दें जो डेस्कटॉप

Question

से बातचीत कर सकता है मुझे काम करने के लिए एक बहुत ही विशिष्ट उपयोग केस मिल रहा है। प्रश्न में आवेदन में दो घटक हैं: एक विंडोज सेवा, जिसे डेस्कटॉप के बाहर एक विशेषाधिकार प्राप्त संदर्भ में चलाने की आवश्यकता है (यानी उपयोगकर्ता लॉग इन करते समय कनेक्शन स्वीकार करने के लिए) या क्लाइंट Winforms ऐप। सेवा वेबस्केट कनेक्शन स्वीकार करती है, और कनेक्शन अनुरोध सफल होना चाहिए, यह उपयोगकर्ता को इंटरैक्टिव रूप से (डेस्कटॉप में) लॉग ऑन करना है और उस प्रक्रिया को उत्पन्न करना है जो उस उपयोगकर्ता को डेस्कटॉप एक्सेस के साथ है। मैंने निम्नलिखित लिंक का उपयोग किया है, और जब वे किसी उपयोगकर्ता का प्रतिरूपण करने में सक्षम होते हैं, तो वे वास्तव में उपयोगकर्ता को डेस्कटॉप में लॉग इन नहीं करते हैं, यानी यदि मैं वीएनसी का उपयोग कर सिस्टम देखता हूं, या यदि मैं इसे अपने स्थानीय सिस्टम पर परीक्षण करता हूं, तो उपयोगकर्ता लॉग इन नहीं होता है। हालांकि, प्रक्रिया उपयोगकर्ता के रूप में उत्पन्न होती है, लेकिन जाहिर है कि डेस्कटॉप एक्सेस के साथ नहीं।

क्या किसी के पास कोई कोड नमूना है जो उपयोगकर्ता को डेस्कटॉप में लॉग करेगा?

लिंक और कोड मैं कोशिश की है:

Using Process.Start() to start a process as a different user from within a Windows Service

How to use LogonUser properly to impersonate domain user from workgroup client सार्वजनिक

Launch a process under another user's credentials

https://social.msdn.microsoft.com/Forums/vstudio/en-US/9fb068b0-507b-4b6b-879a-b0fbe492ba92/c-start-program-with-different-user-credentials

वर्तमान कोड है:

using Cassia; 
using System; 
using System.Collections.Generic; 
using System.ComponentModel; 
using System.Diagnostics; 
using System.DirectoryServices; 
using System.Runtime.InteropServices; 
using System.Security; 
using System.Security.Permissions; 
using System.Security.Principal; 
using System.ServiceProcess; 

namespace program 
{ 
    public partial class service 
    { 
     #region Interop 

     [StructLayout(LayoutKind.Sequential)] 
     public struct LUID 
     { 
      public UInt32 LowPart; 
      public Int32 HighPart; 
     } 

     [StructLayout(LayoutKind.Sequential)] 
     public struct LUID_AND_ATTRIBUTES 
     { 
      public LUID Luid; 
      public UInt32 Attributes; 
     } 

     public struct TOKEN_PRIVILEGES 
     { 
      public UInt32 PrivilegeCount; 
      [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1)] 
      public LUID_AND_ATTRIBUTES[] Privileges; 
     } 

     enum TOKEN_INFORMATION_CLASS 
     { 
      TokenUser = 1, 
      TokenGroups, 
      TokenPrivileges, 
      TokenOwner, 
      TokenPrimaryGroup, 
      TokenDefaultDacl, 
      TokenSource, 
      TokenType, 
      TokenImpersonationLevel, 
      TokenStatistics, 
      TokenRestrictedSids, 
      TokenSessionId, 
      TokenGroupsAndPrivileges, 
      TokenSessionReference, 
      TokenSandBoxInert, 
      TokenAuditPolicy, 
      TokenOrigin, 
      TokenElevationType, 
      TokenLinkedToken, 
      TokenElevation, 
      TokenHasRestrictions, 
      TokenAccessInformation, 
      TokenVirtualizationAllowed, 
      TokenVirtualizationEnabled, 
      TokenIntegrityLevel, 
      TokenUIAccess, 
      TokenMandatoryPolicy, 
      TokenLogonSid, 
      MaxTokenInfoClass 
     } 

     [Flags] 
     enum CreationFlags : uint 
     { 
      CREATE_BREAKAWAY_FROM_JOB = 0x01000000, 
      CREATE_DEFAULT_ERROR_MODE = 0x04000000, 
      CREATE_NEW_CONSOLE = 0x00000010, 
      CREATE_NEW_PROCESS_GROUP = 0x00000200, 
      CREATE_NO_WINDOW = 0x08000000, 
      CREATE_PROTECTED_PROCESS = 0x00040000, 
      CREATE_PRESERVE_CODE_AUTHZ_LEVEL = 0x02000000, 
      CREATE_SEPARATE_WOW_VDM = 0x00001000, 
      CREATE_SUSPENDED = 0x00000004, 
      CREATE_UNICODE_ENVIRONMENT = 0x00000400, 
      DEBUG_ONLY_THIS_PROCESS = 0x00000002, 
      DEBUG_PROCESS = 0x00000001, 
      DETACHED_PROCESS = 0x00000008, 
      EXTENDED_STARTUPINFO_PRESENT = 0x00080000 
     } 

     public enum TOKEN_TYPE 
     { 
      TokenPrimary = 1, 
      TokenImpersonation 
     } 

     public enum SECURITY_IMPERSONATION_LEVEL 
     { 
      SecurityAnonymous, 
      SecurityIdentification, 
      SecurityImpersonation, 
      SecurityDelegation 
     } 

     [Flags] 
     enum LogonFlags 
     { 
      LOGON_NETCREDENTIALS_ONLY = 2, 
      LOGON_WITH_PROFILE = 1 
     } 

     enum LOGON_TYPE 
     { 
      LOGON32_LOGON_INTERACTIVE = 2, 
      LOGON32_LOGON_NETWORK, 
      LOGON32_LOGON_BATCH, 
      LOGON32_LOGON_SERVICE, 
      LOGON32_LOGON_UNLOCK = 7, 
      LOGON32_LOGON_NETWORK_CLEARTEXT, 
      LOGON32_LOGON_NEW_CREDENTIALS 
     } 

     enum LOGON_PROVIDER 
     { 
      LOGON32_PROVIDER_DEFAULT, 
      LOGON32_PROVIDER_WINNT35, 
      LOGON32_PROVIDER_WINNT40, 
      LOGON32_PROVIDER_WINNT50 
     } 

     struct SECURITY_ATTRIBUTES 
     { 
      public uint Length; 
      public IntPtr SecurityDescriptor; 
      public bool InheritHandle; 
     } 

     [Flags] 
     enum SECURITY_INFORMATION : uint 
     { 
      OWNER_SECURITY_INFORMATION = 0x00000001, 
      GROUP_SECURITY_INFORMATION = 0x00000002, 
      DACL_SECURITY_INFORMATION = 0x00000004, 
      SACL_SECURITY_INFORMATION = 0x00000008, 
      UNPROTECTED_SACL_SECURITY_INFORMATION = 0x10000000, 
      UNPROTECTED_DACL_SECURITY_INFORMATION = 0x20000000, 
      PROTECTED_SACL_SECURITY_INFORMATION = 0x40000000, 
      PROTECTED_DACL_SECURITY_INFORMATION = 0x80000000 
     } 

     [StructLayoutAttribute(LayoutKind.Sequential)] 
     struct SECURITY_DESCRIPTOR 
     { 
      public byte revision; 
      public byte size; 
      public short control; // public SECURITY_DESCRIPTOR_CONTROL control; 
      public IntPtr owner; 
      public IntPtr group; 
      public IntPtr sacl; 
      public IntPtr dacl; 
     } 

     struct STARTUPINFO 
     { 
      public uint cb; 
      [MarshalAs(UnmanagedType.LPTStr)] 
      public string Reserved; 
      [MarshalAs(UnmanagedType.LPTStr)] 
      public string Desktop; 
      [MarshalAs(UnmanagedType.LPTStr)] 
      public string Title; 
      public uint X; 
      public uint Y; 
      public uint XSize; 
      public uint YSize; 
      public uint XCountChars; 
      public uint YCountChars; 
      public uint FillAttribute; 
      public uint Flags; 
      public ushort ShowWindow; 
      public ushort Reserverd2; 
      public byte bReserverd2; 
      public IntPtr StdInput; 
      public IntPtr StdOutput; 
      public IntPtr StdError; 
     } 

     [StructLayout(LayoutKind.Sequential)] 
     struct PROCESS_INFORMATION 
     { 
      public IntPtr Process; 
      public IntPtr Thread; 
      public uint ProcessId; 
      public uint ThreadId; 
     } 

     [DllImport("advapi32.dll", SetLastError = true)] 
     static extern bool InitializeSecurityDescriptor(IntPtr pSecurityDescriptor, uint dwRevision); 
     const uint SECURITY_DESCRIPTOR_REVISION = 1; 

     [DllImport("advapi32.dll", SetLastError = true)] 
     static extern bool SetSecurityDescriptorDacl(ref SECURITY_DESCRIPTOR sd, bool daclPresent, IntPtr dacl, bool daclDefaulted); 

     [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)] 
     extern static bool DuplicateTokenEx(
      IntPtr hExistingToken, 
      uint dwDesiredAccess, 
      ref SECURITY_ATTRIBUTES lpTokenAttributes, 
      SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, 
      TOKEN_TYPE TokenType, 
      out IntPtr phNewToken); 

     [DllImport("advapi32.dll", SetLastError = true)] 
     public static extern bool LogonUser(
      string lpszUsername, 
      string lpszDomain, 
      string lpszPassword, 
      int dwLogonType, 
      int dwLogonProvider, 
      out IntPtr phToken 
      ); 

     [DllImport("advapi32.dll", SetLastError = true)] 
     static extern bool GetTokenInformation(
      IntPtr TokenHandle, 
      TOKEN_INFORMATION_CLASS TokenInformationClass, 
      IntPtr TokenInformation, 
      int TokenInformationLength, 
      out int ReturnLength 
      ); 

     [DllImport("advapi32.dll", CharSet = CharSet.Unicode, SetLastError = true)] 
     static extern bool CreateProcessAsUser(
      IntPtr Token, 
      [MarshalAs(UnmanagedType.LPTStr)] string ApplicationName, 
      [MarshalAs(UnmanagedType.LPTStr)] string CommandLine, 
      ref SECURITY_ATTRIBUTES ProcessAttributes, 
      ref SECURITY_ATTRIBUTES ThreadAttributes, 
      bool InheritHandles, 
      uint CreationFlags, 
      IntPtr Environment, 
      [MarshalAs(UnmanagedType.LPTStr)] string CurrentDirectory, 
      ref STARTUPINFO StartupInfo, 
      out PROCESS_INFORMATION ProcessInformation); 

     [DllImport("Kernel32.dll")] 
     extern static int CloseHandle(IntPtr handle); 

     [DllImport("advapi32.dll", ExactSpelling = true, SetLastError = true)] 
     internal static extern bool AdjustTokenPrivileges(IntPtr htok, bool disall, ref TokPriv1Luid newst, int len, IntPtr prev, IntPtr relen); 

     [DllImport("advapi32.dll", SetLastError = true)] 
     internal static extern bool LookupPrivilegeValue(string host, string name, ref long pluid); 

     [StructLayout(LayoutKind.Sequential, Pack = 1)] 
     internal struct TokPriv1Luid 
     { 
      public int Count; 
      public long Luid; 
      public int Attr; 
     } 

     internal const int SE_PRIVILEGE_ENABLED = 0x00000002; 
     internal const int TOKEN_QUERY = 0x00000008; 
     internal const int TOKEN_DUPLICATE = 0x0002; 
     internal const int TOKEN_ASSIGN_PRIMARY = 0x0001; 

     #endregion 

     public static bool LoginUser(string domain, string username, string password, string program, string workingDir) 
     { 
      IntPtr token = IntPtr.Zero; 
      IntPtr primaryToken = IntPtr.Zero; 

      try 
      { 
       bool result = LogonUser(username, domain, password, (int)LOGON_TYPE.LOGON32_LOGON_NETWORK, (int)LOGON_PROVIDER.LOGON32_PROVIDER_DEFAULT, out token); 
       if (!result) 
       { 
        int winError = Marshal.GetLastWin32Error(); 
        Console.WriteLine("LoginUser unable to login user " + username + ", error: " + winError); 
        return false; 
       } 

       SECURITY_ATTRIBUTES processAttributes = new SECURITY_ATTRIBUTES(); 
       SECURITY_DESCRIPTOR sd = new SECURITY_DESCRIPTOR(); 
       IntPtr ptr = Marshal.AllocCoTaskMem(Marshal.SizeOf(sd)); 
       Marshal.StructureToPtr(sd, ptr, false); 
       InitializeSecurityDescriptor(ptr, SECURITY_DESCRIPTOR_REVISION); 
       sd = (SECURITY_DESCRIPTOR)Marshal.PtrToStructure(ptr, typeof(SECURITY_DESCRIPTOR)); 

       result = SetSecurityDescriptorDacl(ref sd, true, IntPtr.Zero, false); 
       if (!result) 
       { 
        int winError = Marshal.GetLastWin32Error(); 
       } 

       primaryToken = new IntPtr(); 
       result = DuplicateTokenEx(token, 0, ref processAttributes, SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation, TOKEN_TYPE.TokenPrimary, out primaryToken); 
       if (!result) 
       { 
        int winError = Marshal.GetLastWin32Error(); 
       } 

       processAttributes.SecurityDescriptor = ptr; 
       processAttributes.Length = (uint)Marshal.SizeOf(sd); 
       processAttributes.InheritHandle = true; 

       SECURITY_ATTRIBUTES threadAttributes = new SECURITY_ATTRIBUTES(); 
       threadAttributes.SecurityDescriptor = IntPtr.Zero; 
       threadAttributes.Length = 0; 
       threadAttributes.InheritHandle = false; 

       bool inheritHandles = true; 
       IntPtr environment = IntPtr.Zero; 

       STARTUPINFO startupInfo = new STARTUPINFO(); 
       startupInfo.Desktop = ""; 

       PROCESS_INFORMATION processInformation; 

       result = CreateProcessAsUser(
        primaryToken, 
        program, 
        program, 
        ref processAttributes, 
        ref threadAttributes, 
        inheritHandles, 
        16, 
        environment, 
        workingDir, 
        ref startupInfo, 
        out processInformation); 

       if (!result) 
       { 
        int winError = Marshal.GetLastWin32Error(); 
        Console.WriteLine("LoginUser unable to create process as user " + username + ", error: " + winError); 
        return false; 
       } 

       return true; 
      } 
      catch (Exception e) 
      { 
       Console.WriteLine("LoginUser exception encountered: " + e.Message()); 
       return false; 
      } 
      finally 
      { 
       if (token != IntPtr.Zero) 
       { 
        int x = CloseHandle(token); 
        if (x == 0) 
         throw new Win32Exception(Marshal.GetLastWin32Error()); 
        x = CloseHandle(primaryToken); 
        if (x == 0) 
         throw new Win32Exception(Marshal.GetLastWin32Error()); 
       } 
      } 
     } 

     public static SecureString securePassword(string password) 
     { 
      if (string_null(password)) return null; 
      SecureString secure = new SecureString(); 
      foreach (char c in password) 
      { 
       secure.AppendChar(c); 
      } 
      return secure; 
     } 
    } 
} 

और मेरा लक्ष्य के रूप में बस यह कॉल करने के लिए सक्षम होने के लिए है:

if (!LoginUser("machinename", "username", "password", "c:\\path\\to\\program.exe", "c:\\path\\to")) 
{ 
    // error 
} 
else 
{ 
    // success, user is logged into desktop and app is launch 
    // as user with desktop access 
} 

Answer 1

मैं पहले की तरह ही परिदृश्य था और चीजें इतनी जटिल मैं सिर्फ के साथ संयोजन में PSEXEC इस्तेमाल किया Process.Start

वैसे ही जैसे क्या उनके नमूने पर दर्शाया PSEXEC का उपयोग कर तुम सब करने की है इस

कॉपी की तरह कुछ है या कॉड के माध्यम से अपने निष्पादन योग्य स्थापित ई या मैन्युअल रूप से (यानी। program.exe) दूरस्थ सिस्टम और यह सहभागी निष्पादित, खाते DannyGlover के तहत चल रहा:

psexec \\workstation64 -c program.exe -u YourUser -p YourPa55w0rd 

अब आप अपने मानकों को पता है कि तुम तो Process.Start उपयोग कर सकते हैं इसे चलाने के लिए। तो यह इस

using System.Diagnostics; 
... 
Process process = new Process(); 
process.StartInfo.FileName = "program.exe"; 
process.StartInfo.Arguments = "\\workstation64 -c program.exe -u YourUser -p YourPa55w0rd"; 
process.Start(); 
process.WaitForExit(); 

कुछ ऐसी दिखाई देगी जिस तरह से आप अधिक जानने के लिए और यहाँ PSEXEC डाउनलोड http://ss64.com/nt/psexec.html

Answer 2

मैं Elance.com पर आपकी समस्या को मिल गया है और इस लिंक मिल सकता है।

मुझे अपनी परियोजना में से एक के साथ एक ही तरह का मुद्दा था। इसके लिए विंडोज़ सेवा को पीओएस टर्मिनल कम्युनिकेटर एक्सई लॉन्च करने की आवश्यकता थी और यह यूआई के साथ प्रशासक पहुंच के साथ होना चाहिए। मैंने यूएसी से बचने के लिए winlogon.exe के समान प्रतिरूपण की कोशिश की लेकिन इससे मदद नहीं मिली।

मेरी समस्या के लिए मैंने अनुसूचित कार्य का उपयोग किया और सी # का उपयोग करके अपना कार्य बनाया। आप यहां एक बहुत अच्छी लाइब्रेरी पा सकते हैं http://taskscheduler.codeplex.com। अब एक आवश्यक कॉल पर आप कार्य को गतिशील रूप से चला सकते हैं और उस पर आपका पूरा नियंत्रण है।

आप अपने स्वयं के कार्य/गतिशील रूप से संपादित/हटा सकते हैं और यूएसी से बचने से अपने ऐप्स चला सकते हैं।

Answer 3

आप एक नया इंटरैक्टिव सत्र बनाना चाहते हैं। दुर्भाग्य से, यह संभव नहीं है। जहां तक ​​मैं इसे समझता हूं, आप एक प्रक्रिया शुरू करना चाहते हैं और फिर मशीन को दूरस्थ रूप से VNC के साथ नियंत्रित करना चाहते हैं। शायद आपको रिमोट डेस्कटॉप का उपयोग करने की आवश्यकता है?