private HostConnectionData() { _state = ConnectionState.Invalid; _helperInterface = null; _remoteInfo = null; _unmanagedInfo = null; }
private static void Install() { lock (ThreadSafe) { // Ensure we create a new one if the existing // channel cannot be pinged try { if (m_Interface != null) { m_Interface.Ping(); } } catch { m_Interface = null; } if (m_Interface == null) { String ChannelName = RemoteHooking.GenerateName(); String SvcExecutablePath = (Config.DependencyPath.Length > 0 ? Config.DependencyPath : Config.GetProcessPath()) + Config.GetWOW64BypassExecutableName(); Process Proc = new Process(); ProcessStartInfo StartInfo = new ProcessStartInfo( SvcExecutablePath, "\"" + ChannelName + "\""); // create sync objects EventWaitHandle Listening = new EventWaitHandle( false, EventResetMode.ManualReset, "Global\\Event_" + ChannelName); m_TermMutex = new Mutex(true, "Global\\Mutex_" + ChannelName); // start and connect program StartInfo.CreateNoWindow = true; StartInfo.WindowStyle = ProcessWindowStyle.Hidden; Proc.StartInfo = StartInfo; Proc.Start(); if (!Listening.WaitOne(5000, true)) { throw new ApplicationException("Unable to wait for service application due to timeout."); } HelperServiceInterface Interface = RemoteHooking.IpcConnectClient <HelperServiceInterface>(ChannelName); Interface.Ping(); m_Interface = Interface; } } }
private static void Install() { lock (ThreadSafe) { // Ensure we create a new one if the existing // channel cannot be pinged try { if (m_Interface != null) { m_Interface.Ping(); } } catch { m_Interface = null; } if (m_Interface == null) { // create sync objects String ChannelName = RemoteHooking.GenerateName(); EventWaitHandle Listening = new EventWaitHandle( false, EventResetMode.ManualReset, "Global\\Event_" + ChannelName); Mutex TermMutex = new Mutex(true, "Global\\Mutex_" + ChannelName); using (TermMutex) { // install and start service NativeAPI.RtlInstallService( "EasyHook" + (NativeAPI.Is64Bit?"64":"32") + "Svc", Path.GetFullPath(Config.GetDependantSvcExecutableName()), ChannelName); if (!Listening.WaitOne(5000, true)) { throw new ApplicationException("Unable to wait for service startup."); } HelperServiceInterface Interface = RemoteHooking.IpcConnectClient <HelperServiceInterface>(ChannelName); Interface.Ping(); // now we can be sure that all things are fine... m_Interface = Interface; m_TermMutex = TermMutex; } } } }
/// <summary> /// Loads the user library (trying the strong name first, then the file name), /// creates an instance for the <see cref="IEntryPoint"/> specified in the library /// and invokes the Run() method specified in that instance. /// </summary> /// <param name="userLibraryStrongName">The assembly strong name provided by the user, located in the global assembly cache.</param> /// <param name="userLibraryFileName">The assembly file name provided by the user to be loaded.</param> /// <param name="paramArray">Array of parameters to use with the constructor and with the Run() method. Note that all but the first parameter should be binary encoded.</param> /// <param name="helperServiceInterface"><see cref="HelperServiceInterface"/> to use for reporting to the host side.</param> /// <returns>The exit code to be returned by the main() method.</returns> private static int LoadUserLibrary(string userLibraryStrongName, string userLibraryFileName, object[] paramArray, HelperServiceInterface helperServiceInterface) { Type entryPoint = null; MethodInfo runMethod; object instance; // 1. Load the assembly and find the EasyHook.IEntryPoint and matching Run() method try { // Load the given assembly and find the first EasyHook.IEntryPoint entryPoint = FindEntryPoint(userLibraryStrongName, userLibraryFileName); // Only attempt to deserialise parameters after we have loaded the userAssembly // this allows types from the userAssembly to be passed as parameters BinaryFormatter format = new BinaryFormatter(); format.Binder = new AllowAllAssemblyVersionsDeserializationBinder(entryPoint.Assembly); for (int i = 1; i < paramArray.Length; i++) { using (MemoryStream ms = new MemoryStream((byte[])paramArray[i])) { paramArray[i] = format.Deserialize(ms); } } // Determine if a Run() method is defined with matching parameters, before initializing an instance for the type. runMethod = FindMatchingMethod(entryPoint, "Run", paramArray); if (runMethod == null) { throw new MissingMethodException(ConstructMissingMethodExceptionMessage("Run", paramArray)); } // Initialize an object for the entrypoint. instance = InitializeInstance(entryPoint, paramArray); if (instance == null) { throw new MissingMethodException(ConstructMissingMethodExceptionMessage(entryPoint.Name, paramArray)); } // Notify the host about successful injection. helperServiceInterface.InjectionCompleted(RemoteHooking.GetCurrentProcessId()); } catch (Exception e) { // Provide error information on host side. try { helperServiceInterface.InjectionException(RemoteHooking.GetCurrentProcessId(), e); } finally { Release(entryPoint); } return(-1); } // 2. Invoke the Run() method try { // After this it is safe to enter the Run() method, which will block until assembly unloading... // From now on the user library has to take care about error reporting! runMethod.Invoke(instance, BindingFlags.Public | BindingFlags.Instance | BindingFlags.ExactBinding | BindingFlags.InvokeMethod, null, paramArray, null); } finally { Release(entryPoint); } return(0); }