C#

<code>
namespace ExecuteAnExeUsingCurrentLoggedOnUser
{
    class Program
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct STARTUPINFO
        {
            public Int32 cb;
            public string lpReserved;
            public string lpDesktop;
            public string lpTitle;
            public Int32 dwX;
            public Int32 dwY;
            public Int32 dwXSize;
            public Int32 dwXCountChars;
            public Int32 dwYCountChars;
            public Int32 dwFillAttribute;
            public Int32 dwFlags;
            public Int16 wShowWindow;
            public Int16 cbReserved2;
            public IntPtr lpReserved2;
            public IntPtr hStdInput;
            public IntPtr hStdOutput;
            public IntPtr hStdError;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct PROCESS_INFORMATION
        {
            public IntPtr hProcess;
            public IntPtr hThread;
            public Int32 dwProcessID;
            public Int32 dwThreadID;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct SECURITY_ATTRIBUTES
        {
            public Int32 Length;
            public IntPtr lpSecurityDescriptor;
            public bool bInheritHandle;
        }

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

        public enum TOKEN_TYPE
        {
            TokenPrimary = 1,
            TokenImpersonation
        }

        public const int GENERIC_ALL_ACCESS = 0x10000000;
        public const int TOKEN_DUPLICATE = 2;
        public const int TOKEN_QUERY = 0X00000008;
        public const int TOKEN_IMPERSONATE = 0X00000004;

        [
           System.Runtime.InteropServices.DllImport("kernel32.dll",
              EntryPoint = "CloseHandle", SetLastError = true,
              CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)
        ]
        public static extern bool CloseHandle(IntPtr handle);

        [
           DllImport("advapi32.dll",
              EntryPoint = "CreateProcessAsUser", SetLastError = true,
              CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)
        ]
        public static extern bool
           CreateProcessAsUser(IntPtr hToken, string lpApplicationName, string lpCommandLine,
                               ref SECURITY_ATTRIBUTES lpProcessAttributes, ref SECURITY_ATTRIBUTES lpThreadAttributes,
                               bool bInheritHandle, Int32 dwCreationFlags, IntPtr lpEnvrionment,
                               string lpCurrentDirectory, ref STARTUPINFO lpStartupInfo,
                               ref PROCESS_INFORMATION lpProcessInformation);

        [
           DllImport("advapi32.dll",
              EntryPoint = "DuplicateTokenEx")
        ]
        public static extern bool
           DuplicateTokenEx(IntPtr hExistingToken, Int32 dwDesiredAccess,
                            ref SECURITY_ATTRIBUTES lpThreadAttributes,
                            Int32 ImpersonationLevel, Int32 dwTokenType,
                            ref IntPtr phNewToken);

        [
            DllImport("advapi32", SetLastError = true),
                SuppressUnmanagedCodeSecurityAttribute
        ]
        public static extern int
            OpenProcessToken(
                System.IntPtr ProcessHandle, // handle to process
                int DesiredAccess, // desired access to process
                ref IntPtr TokenHandle // handle to open access token
                );
        [DllImport("advapi32.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool OpenProcessToken(IntPtr ProcessHandle,
            UInt32 DesiredAccess, out IntPtr TokenHandle);
        static void Main(string[] args)
        {
            CreateProcessAsUser1("c:\\ServiceManager.exe", "");
        }
        private static void CreateProcessAsUser1(string strApplication, string strArg)
        {

                IntPtr hToken = IntPtr.Zero;
                Process[] proc = Process.GetProcessesByName("explorer");
                if (OpenProcessToken(proc[0].Handle,
                        TOKEN_QUERY | TOKEN_IMPERSONATE | TOKEN_DUPLICATE,
                        ref hToken) != 0)
                {
                }

                IntPtr hDupedToken = IntPtr.Zero;

                PROCESS_INFORMATION pi = new PROCESS_INFORMATION();

                try
                {
                    SECURITY_ATTRIBUTES sa = new SECURITY_ATTRIBUTES();
                    sa.Length = Marshal.SizeOf(sa);

                    bool result = DuplicateTokenEx(
                          hToken,
                          GENERIC_ALL_ACCESS,
                          ref sa,
                          (int)SECURITY_IMPERSONATION_LEVEL.SecurityIdentification,
                          (int)TOKEN_TYPE.TokenPrimary,
                          ref hDupedToken
                       );

                    if (!result)
                    {
                        throw new ApplicationException("DuplicateTokenEx failed");
                    }


                    STARTUPINFO si = new STARTUPINFO();
                    si.cb = Marshal.SizeOf(si);
                    si.lpDesktop = String.Empty;

                    result = CreateProcessAsUser(
                                         hDupedToken,
                                         strApplication, strArg,
                                         ref sa, ref sa,
                                         false, 0, IntPtr.Zero,
                                         @"C:\", ref si, ref pi
                                   );

                    if (!result)
                    {
                        int error = Marshal.GetLastWin32Error();
                        string message = String.Format("CreateProcessAsUser Error: {0}", error);
                        throw new ApplicationException(message);
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Inner Catch " + ex.Message.ToString());
                }
            


            finally
            {
                if (pi.hProcess != IntPtr.Zero)
                    CloseHandle(pi.hProcess);
                if (pi.hThread != IntPtr.Zero)
                    CloseHandle(pi.hThread);
                if (hDupedToken != IntPtr.Zero)
                    CloseHandle(hDupedToken);
            }
        }

    }
}</code>

finally
   {
   if (pi.hProcess != IntPtr.Zero)
      CloseHandle(pi.hProcess);
   if (pi.hThread != IntPtr.Zero)
      CloseHandle(pi.hThread);
   if (hDupedToken != IntPtr.Zero)
      CloseHandle(hDupedToken);
   }

result = CreateProcessAsUser(hDupedToken,
                             strApplication, strArg,
                             ref sa, ref sa,
                             false, 0, IntPtr.Zero,
                             @"C:\", ref si, ref pi
                             );

Sunil G wrote:

First of all sorry for what i have posted.

Sunil G wrote:

Exception is not occuring in my application. I have debugged my application, it never goes to catch block. But when below line of code get executed then only it gives an error (JIT dialog box). The function runs successfully. The function returns a non-zero value.

Sunil G wrote:

what kind of permissions I have to set?

finally
{
if (pi.hProcess != IntPtr.Zero)
CloseHandle(pi.hProcess);
if (pi.hThread != IntPtr.Zero)
CloseHandle(pi.hThread);
if (hDupedToken != IntPtr.Zero)
CloseHandle(hDupedToken);
}

private void AutoSizeCustomMenuItem(ToolStripMenuItem oMenuItem, string sText)
{
  int iPreferredHeight = 50;
  int iPreferredWidth = 0;
  int iPadding = 50;
  SizeF oSizeSpace = SizeF.Empty;

  using (Graphics oGraphics = oMenuItem.Owner.CreateGraphics())
  {
    iPreferredWidth = (int)oGraphics.MeasureString(sText, oMenuItem.Font).Width + iPadding;
    oSizeSpace = oGraphics.MeasureString(" ", oMenuItem.Font);
  }

  int iSpacesWidth = (int)Math.Ceiling((double)(iPreferredWidth / oSizeSpace.Width));
  int iSpacesHeight = (int)Math.Ceiling((double)(iPreferredHeight / oSizeSpace.Height));
  string sSpacesWidth = new String(' ', iSpacesWidth);

  StringBuilder sbMenuItemText = new StringBuilder();
  if (iSpacesHeight > 0)
  {
    string sLineDivider = String.Empty;
    for (int i = 0; i < iSpacesHeight; i++)
    {
      sbMenuItemText.Append(sLineDivider);
      sbMenuItemText.Append(sSpacesWidth);
      sLineDivider = "\r\n";
    }
  }
  oMenuItem.Text = sbMenuItemText.ToString();
}