public static bool Init(string path, int windowState = 0, bool isInstallM16 = true, bool isDebug = false) { Global.Registry.Warcraft.SetFullQualityGraphics(); string EXEPath = Path.Combine(path, "Warcraft III.exe"); if (!(File.Exists(EXEPath) || File.Exists(EXEPath = Path.Combine(path, "war3.exe"))) || FileVersionInfo.GetVersionInfo(EXEPath).FileVersion != "1.28.5.7680") { return(false); } CheckDelete(Path.Combine(path, "m16l.mix")); if (isInstallM16) { string M16Mix = Path.Combine(path, "M16.mix"); string M16Mixnew = $"{M16Mix}_new"; if (File.Exists(M16Mixnew)) { CheckDelete(M16Mix); File.Move(M16Mixnew, M16Mix); } else { CheckInstall(M16Mix, Resources.M16); } } string JNServicePath = Path.Combine(Global.Globals.ResourcePath, "JNService"); string RuntimePath = Path.Combine(JNServicePath, "Cirnix.JassNative.Runtime.dll"); string JNServicePluginPath = Path.Combine(JNServicePath, "Plugins"); CheckDirectory(JNServicePath); CheckInstall(RuntimePath, Resources.Cirnix_JassNative_Runtime); CheckInstall(Path.Combine(JNServicePath, "Cirnix.JassNative.Plugin.dll"), Resources.Cirnix_JassNative_Plugin); CheckDirectory(JNServicePluginPath); CheckInstall(Path.Combine(JNServicePluginPath, "Cirnix.JassNative.dll"), Resources.Cirnix_JassNative); CheckInstall(Path.Combine(JNServicePluginPath, "Cirnix.JassNative.Common.dll"), Resources.Cirnix_JassNative_Common); //Global.LogManager.Write($"InEXEPath = {EXEPath}\n" // + $"InCommandLine = {((windowState == 0) ? "-window" : ((windowState == 1) ? "-nativefullscr" : ""))}\n" // + $"InProcessCreationFlags = 0\n" // + $"InLibraryPath_x86 = {RuntimePath}\n" // + $"InLibraryPath_x64 = {RuntimePath}\n" // + $"OutProcessId = \n" // + $"InPassThruArgs[0] = {isDebug}\n" // + $"InPassThruArgs[1] = {CurrentPath}\n" // + $"InPassThruArgs[2] = {path}"); //Config.HelperLibraryLocation = CurrentPath; string WindowsStateString; switch (windowState) { case 0: WindowsStateString = "-windows"; break; case 1: WindowsStateString = string.Empty; break; case 2: WindowsStateString = "-nativefullscr"; break; default: return(false); } RemoteHooking.CreateAndInject(EXEPath, WindowsStateString, 0, RuntimePath, RuntimePath, out _, isDebug, JNServicePath, path); return(true); }
public HookEntity Handle(ProxyEntity request) { return(_repository.ActionResult(x => x.Port == request.Port, x => { HookElement _hook = x.Hooker.Hook; RemoteHooking.CreateAndInject( x.Hooker.ExePath, string.Empty, 0x00000004, InjectionOptions.DoNotRequireStrongName, "./SocketHook.dll", "./SocketHook.dll", out _hook.ProcessId, _hook.ChannelName, request.Port); while (_hook.ProcessId == 0) { ; } x.ProcessId = _hook.ProcessId; logger.Debug($"Process id : {_hook.ProcessId}"); return x; }).Hooker); }
static void Main(string[] args) { if (args.Length == 0) { args = new[] { @"C:\Program Files (x86)\Steam\steamapps\common\Hades\x64\Hades.exe" } } ; string clientArgs = ""; if (Debugger.IsAttached) { DebugHelper.DetachDebugger(); clientArgs += "--launch-debugger"; } RemoteHooking.CreateAndInject(args[0], clientArgs, InProcessCreationFlags: 0, InjectionOptions.DoNotRequireStrongName, typeof(EntryPoint).Assembly.Location, typeof(EntryPoint).Assembly.Location, out int processID); Process.GetProcessById(processID).WaitForExit(); } }
public void Start(string targetExecutable, string commandLine = "") { try { // All loaded modules should use .Net Framework <= 3.5 Config.Register( "Lua injection", "LuaInjectAgent.dll", "System.ComponentModel.Composition.dll" ); string channelName = null; RemoteHooking.IpcCreateServer <Client>(ref channelName, WellKnownObjectMode.SingleCall); int targetPid; RemoteHooking.CreateAndInject(targetExecutable, commandLine, 0, "LuaInjectAgent.dll", "LuaInjectAgent.dll", out targetPid, channelName, //channel Path.Combine(Directory.GetCurrentDirectory(), "HookPlugins"), //plugins directory Path.Combine(Directory.GetCurrentDirectory(), "Config"), //config directory targetExecutable //target executable ); } catch (Exception e) { MessageBox.Show(e.Message + "\n" + e.StackTrace, "Failed", MessageBoxButtons.OK); } }
public bool TryCreateAndInject(string exePath, int redirectionPort, params string[] redirectedIps) { if (!File.Exists(exePath)) { return(false); } if (redirectionPort == default) { throw new ArgumentNullException(nameof(redirectionPort)); } RemoteHooking.CreateAndInject( exePath, string.Empty, 0x00000004, InjectionOptions.DoNotRequireStrongName, _settings.HookPath, _settings.HookPath, out var pId, _ipcChannelName, redirectedIps, redirectionPort); _registeredPid.TryAdd(pId, pId); return(true); }
/// <summary> /// Creates and injects the current <see cref="VirtualizedProcess"/>, /// and sets the created process component to the <see cref="_process"/> variable. /// </summary> /// <exception cref="FileNotFoundException"></exception> private void CreateAndInject() { int processId; // Get the location of the library to inject string libraryLocation = HostCore.Configuration.Application.LibtoInject; if (!File.Exists(libraryLocation)) { throw new FileNotFoundException("Unable to locate the library to inject.", libraryLocation); } RemoteHooking.CreateAndInject( Path.Combine(_startInfo.WorkingDirectory.FileName, _startInfo.Files.Executable.FileName), // Optional command line parameters for process creation _startInfo.Arguments, // ProcessCreationFlags, no conditions are set on the created process. 0, // Absolute paths of the libraries to inject, we use the same one for 32bit and 64bit libraryLocation, libraryLocation, // The process ID of the newly created process out processId, // Extra parameters being passed to the injected library entry points Run() and Initialize() _connection.ChannelName); // The process has been created, set the _process variable. _process = SystemProcess.GetProcessById(processId, HostCore.Runtime.CurrentProcess.MachineName); _process.EnableRaisingEvents = true; _process.Exited += Process_Exited; }
/// <summary> /// Executes VB6. The VB6 log output is written to the specified writer. /// </summary> public int Execute(TextWriter writer) { Prepare(); if (File.Exists(log)) { File.Delete(log); } // generate new channel to call back into parent string channelName = null; RemoteHooking.IpcCreateServer <RemoteExecutor>(ref channelName, WellKnownObjectMode.Singleton, this); // spawn VB6 process RemoteHooking.CreateAndInject( Exe, BuildArgs(), 0, InjectionOptions.DoNotRequireStrongName, typeof(RemoteEntryPoint).Assembly.Location, typeof(RemoteEntryPoint).Assembly.Location, out var pid, channelName); // wait for exit of process var prc = Process.GetProcessById(pid); while (prc != null && !prc.HasExited) { prc.WaitForExit(500); } // copy output to writer if (writer != null) { if (File.Exists(log)) { using (var l = new StreamReader(File.OpenRead(log))) while (l.ReadLine() is string s) { writer.WriteLine(s); } } } try { if (File.Exists(log)) { File.Delete(log); } } catch { } return((int)exitCode); }
// // Core hook methods public IProcess CreateAndHook( SMCollection collection, ISMHookSystem systemCallback, IEnumerable <ISMHookIO> ioCallbacks) { try { SystemCallback = systemCallback; IOCallbacks.AddRange(ioCallbacks); IOTargetFilePaths.AddRange(IOCallbacks.SelectMany(c => c.GetTargetFilePaths())); // Initialize event to non-Signaled HookInitEvent = new AutoResetEvent(false); SMAInitEvent = new AutoResetEvent(false); HookSuccess = false; HookException = null; // Start a new IPC server StartIPCServer(); // Start SuperMemo application with given collection as parameter, // and immediatly install hooks RemoteHooking.CreateAndInject( SMConst.BinPath, collection.GetKnoFilePath().Quotify(), 0, InjectionOptions.Default, SMAConst.Assembly.GetInjectionLibFilePath(), null, out var pId ); // Wait for Signal from OnHookInstalled with timeout HookInitEvent.WaitOne(WaitTimeout); if (HookSuccess == false) { StopIPCServer(); var ex = new HookException("Hook setup failed: " + HookException?.Message, HookException); HookException = null; throw ex; } return(new ProcessSharp <SM17Natives>( pId, Process.NET.Memory.MemoryType.Remote, true, SMA.Instance.Config.PatternsHintAddresses)); } finally { HookInitEvent = null; } }
// // Core hook methods public async Task <IProcess> CreateAndHook( SMCollection collection, string binPath, ISMAHookSystem systemCallback, IEnumerable <ISMAHookIO> ioCallbacks) { LogTo.Debug("Starting and injecting SuperMemo"); SystemCallback = systemCallback; IOCallbacks.AddRange(ioCallbacks); IOTargetFilePaths.AddRange(IOCallbacks.SelectMany(c => c.GetTargetFilePaths())); HookSuccess = false; HookException = null; // Start a new IPC server var channelName = StartIPCServer(); // Start SuperMemo application with given collection as parameter, // and immediatly install hooks RemoteHooking.CreateAndInject( binPath, collection.GetKnoFilePath().Quotify(), 0, InjectionOptions.Default, SMAFileSystem.InjectionLibFile.FullPath, null, out var pId, channelName ); LogTo.Debug("Waiting for signal from Injected library"); // Wait for Signal from OnHookInstalled with timeout await HookInitEvent.WaitAsync(WaitTimeout); if (HookSuccess == false) { LogTo.Debug("Hook failed, aborting"); StopIPCServer(); var ex = new HookException("Hook setup failed: " + HookException?.Message, HookException); HookException = null; throw ex; } LogTo.Debug($"SuperMemo started and injected, pId: {pId}"); return(new ProcessSharp <SM17Natives>( pId, Process.NET.Memory.MemoryType.Remote, true, SMA.SMA.Instance.StartupConfig.PatternsHintAddresses)); }
private int DoCreation(CreateDetails createDetails) { progress.ProgressUpdate("Creating process and injecting logging agent", 100); ProcessStartInfo psi = createDetails.Info; int processId; RemoteHooking.CreateAndInject(psi.FileName, (psi.Arguments != String.Empty) ? psi.Arguments : null, (psi.WorkingDirectory != String.Empty) ? psi.WorkingDirectory : null, 0, AGENT_DLL, AGENT_DLL, out processId, serverChannelName, details.SoftwallRules); return(processId); }
///// <summary> ///// Starts process and injects library with redirection of standard input, output and error to handles provided ///// </summary> ///// <param name="what_to_start"></param> ///// <param name="command_line_parameters"></param> ///// <returns>process ID of newly created process</returns> //public Process startProcessAndInject(string what_to_start, string command_line_parameters, IntPtr stdIn, IntPtr stdOut, IntPtr stdErr) //{ // int process_id; // MessageFromInjector message = new MessageFromInjector(); // message.channel_name = ChannelName; // RemoteHooking.CreateAndInjectEx(what_to_start, command_line_parameters, getMainModuleDirectory() + "APIMonInject.dll", null, out process_id, // stdIn, stdOut, stdErr, message); // return System.Diagnostics.Process.GetProcessById(process_id); //} /// <summary> /// Starts process and injects library /// </summary> /// <param name="what_to_start"></param> /// <param name="command_line_parameters"></param> /// <returns>process ID of newly created process</returns> public Process startProcessAndInject(ProgramStartDescription tp) { int process_id; MessageFromInjector message = new MessageFromInjector(); message.channel_name = ChannelName; RemoteHooking.CreateAndInject(tp.image_path, tp.command_line, (int)AliasProcessCreationFlags.CREATE_NEW_CONSOLE, getMainModuleDirectory() + "APIMonInject.dll", null, out process_id, message); return(System.Diagnostics.Process.GetProcessById(process_id)); //Process notePad = new Process(); //notePad.StartInfo.FileName = tp.image_path; //notePad.StartInfo.Arguments = tp.command_line; //notePad.Start(); //return notePad; }
private static int CreateProcessAndHook(string channelName) { int processId; RemoteHooking.CreateAndInject( Environment.CurrentDirectory + @"\TargetUnManagedProcess.exe", "", 0, InjectionOptions.DoNotRequireStrongName, Environment.CurrentDirectory + @"\DllInjection.dll", // 32 bits Environment.CurrentDirectory + @"\DllInjection.dll", // 64 bits out processId, channelName); return(processId); }
private static void LaunchHiSuite() { System.Int32 targetPID = 0; //const string LibraryPath = "Interceptor.dll"; // EasyHook try { RemoteHooking.CreateAndInject(hiSuitePath, string.Empty, 0, LibraryPath, LibraryPath, out targetPID, string.Empty); } catch (Exception ex) { // The given EXE path could not be found. Console.WriteLine("Could not launch HiSuite:"); Console.WriteLine(ex.Message); } }
static void Main(string[] args) { try { bool onlyInject = int.TryParse(args[0], out int processIdReq); string processPathReq = onlyInject ? string.Empty : args[0]; int redirectionPortReq = int.Parse(args[1]); HookElement hook = new HookElement(); { hook.IpcServer = RemoteHooking.IpcCreateServer <HookInterface>(ref hook.ChannelName, WellKnownObjectMode.Singleton); } if (onlyInject) { RemoteHooking.Inject( processIdReq, "./SocketHook.dll", "./SocketHook.dll", hook.ChannelName, redirectionPortReq ); } else { RemoteHooking.CreateAndInject( processPathReq, string.Empty, 0x00000004, InjectionOptions.DoNotRequireStrongName, "./SocketHook.dll", "./SocketHook.dll", out hook.ProcessId, hook.ChannelName, redirectionPortReq ); } Console.Read(); } catch (Exception e) { Console.WriteLine(e); } }
public void InitHook(string exePath, string hookDllPath, int instanceCount = 1) { if (instanceCount <= 0) { return; } int port = Port; HookElement element = new HookElement(); { element.IpcServer = RemoteHooking.IpcCreateServer <CustomHookInterface>(ref element.ChannelName, WellKnownObjectMode.Singleton); } RemoteHooking.CreateAndInject( exePath, string.Empty, 0x00000004, InjectionOptions.DoNotRequireStrongName, hookDllPath, hookDllPath, out element.ProcessId, element.ChannelName, port); PortUsedByProcess.Add(element.ProcessId, port); Process process = Process.GetProcessById(element.ProcessId); process.EnableRaisingEvents = true; process.Exited += (obj, arg) => { PortUsedByProcess.Remove(process.Id); UIManager.Instance.RemovePage(process.Id); }; UIManager.Instance.OpenPage(process.Id); Task.Delay(TimeSpan.FromMilliseconds(ConfigurationManager.Instance.Startup.time_wait_in_ms)).ContinueWith(task => { InitHook(exePath, hookDllPath, instanceCount - 1); }); }
static void Main(string[] args) { try { Write("Enter path to the Ubuntu image file: "); var imagePath = Path.GetFullPath(Console.ReadLine()); Write("Enter path to the icon file: "); var iconPath = Path.GetFullPath(Console.ReadLine()); RemoteHooking.CreateAndInject(@"C:\Windows\System32\LxRun.exe", string.Join(" ", args), 0, "LxRunHook.dll", "LxRunHook.dll", out var pId, imagePath, iconPath); var process = Process.GetProcessById(pId); process.WaitForExit(); } catch (Exception e) { WriteLine("Error: Failed to launch LxRun."); WriteLine(e); Environment.Exit(-1); } }
/// <summary> /// Starts the game client, injects the current assembly and analyzes it. /// </summary> /// <param name="token"> /// The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />. /// </param> /// <returns> /// A task that represents the asynchronous analysis operation. The task's <see cref="Task{T}.Result" /> contains the /// results of the analysis. /// </returns> public Task <AnalysisResult> Analyze(CancellationToken token = default(CancellationToken)) { var channelName = default(string); RemoteHooking.IpcCreateServer(ref channelName, WellKnownObjectMode.Singleton, this); RemoteHooking.CreateAndInject( gameClientPath, string.Empty, 0, Assembly.GetExecutingAssembly().Location, string.Empty, out int processId, InPassThruArgs: channelName); if (token.CanBeCanceled) { token.Register(() => completionSource.TrySetCanceled()); } return(completionSource.Task); }
static void Main(string[] args) { try { if (args.Count() == 0) { args = new string[2]; args[0] = @"C:\Program Files (x86)\CCP\EVE\bin"; args[1] = @"setting.ini"; } if (args.Count() < 2) { Console.WriteLine("Usage: Adapteve.exe [ExeFile-path] [IniFile] [Optional-Questor-DLL] [Optional-Questor-Parameters]"); Console.ReadLine(); return; } var exefilePath = Utility.GetExefilePath(args[0]); var iniFile = Utility.VerifyIniFile(args[1]); var dll = Directory.GetCurrentDirectory() + "/AdapteveDLL.dll"; RemoteHooking.CreateAndInject(exefilePath, "", (int)InjectionOptions.Default, dll, dll, out pid, "", iniFile); if (args.Count() == 4) { var qDll = args[2]; var qParam = args[3]; System.Threading.Thread.Sleep(500); RemoteHooking.Inject(pid, qDll, qDll, qParam); } } catch (Exception ex) { Console.WriteLine(ex.Message); Console.ReadLine(); } }
public void Inject() { StartupConfiguration configuration = ConfigurationManager.Instance.Startup; if (configuration is null) { logger.Error("startup configuration is null"); return; } int port = ProxyPort; _hook = new HookElement(); { _hook.IpcServer = RemoteHooking.IpcCreateServer <BotoxHookInterface <T> >(ref _hook.ChannelName, WellKnownObjectMode.Singleton); } RemoteHooking.CreateAndInject( configuration.game_location, string.Empty, 0x00000004, InjectionOptions.DoNotRequireStrongName, configuration.dll_location, configuration.dll_location, out _hook.ProcessId, _hook.ChannelName, port); Proxy = new CustomProxy <T>(ProxyPort, _hook.ProcessId); Process process = Process.GetProcessById(_hook.ProcessId); process.EnableRaisingEvents = true; if (process.WaitForInputIdle()) { logger.Info($"process opened : {process.ProcessName} {process.Id}"); OnProcessStarted?.Invoke(this); } process.Exited += Process_Exited; }
public static string InjectDll(string dllToInject, string targetExe, ref int targetPid, out string channelName, INotifyClient notifyClient) { channelName = null; RemoteHooking.IpcCreateServer <PostbackMessageHandler>(ref channelName, WellKnownObjectMode.SingleCall); var location = Assembly.GetExecutingAssembly().Location; var directoryName = Path.GetDirectoryName(location); var directoryIsNotNull = directoryName != null; string formattableString = null; if (directoryIsNotNull) { var injectionLibrary = Path.Combine(directoryName, dllToInject); if (File.Exists(injectionLibrary)) { if (string.IsNullOrEmpty(targetExe)) { RemoteHooking.Inject( targetPid, injectionLibrary, injectionLibrary, channelName); formattableString = $"Injected to process {targetPid}"; } else if (File.Exists(targetExe)) { RemoteHooking.CreateAndInject(targetExe, "", 0, InjectionOptions.DoNotRequireStrongName, injectionLibrary, injectionLibrary, out targetPid, channelName); formattableString = $"Created and injected process {targetPid}"; } } } if (notifyClient != null) { PostbackMessageHandler.RemoteHookerBasesToNotify.Add( new Tuple <INotifyClient, int>(notifyClient, targetPid)); } return(formattableString); }
static void Main(string[] args) { _targetExe = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), args[0]); Int32 targetPID = 0; try { if (!File.Exists(_targetExe)) { Console.WriteLine(String.Format("{0} not found !", _targetExe)); Console.WriteLine("Press any key to exit... "); Console.ReadKey(); return; } RemoteHooking.IpcCreateServer <IpcInterface>(ref ChannelName, WellKnownObjectMode.SingleCall); string injectionLibrary = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "REHookLib.dll"); RemoteHooking.CreateAndInject(_targetExe, "", 0, InjectionOptions.DoNotRequireStrongName, injectionLibrary, injectionLibrary, out targetPID, ChannelName); Console.WriteLine("Resident Evil successfully launched."); ShowWindow(GetConsoleWindow(), SW_HIDE); string processName = Path.GetFileNameWithoutExtension(_targetExe); while (Process.GetProcessesByName(processName).Length >= 1) { Thread.Sleep(2000); } Environment.Exit(0); } catch (Exception exception) { ShowWindow(GetConsoleWindow(), SW_SHOW); Console.WriteLine("Unexpected error occurred while launching Resident Evil \r\n{0}", exception.ToString()); Console.WriteLine("Press any key to exit... "); Console.ReadKey(); } }
private string InjectLUAHost() { string logChannelName = null; string res = ""; try { if (IsInjected) { return("WoW is already injected."); } IpcServerChannel ipcLogChannel = RemoteHooking.IpcCreateServer <SystemLog>(ref logChannelName, WellKnownObjectMode.Singleton); remoteLog = RemoteHooking.IpcConnectClient <SystemLog>(logChannelName); remoteLog.OnServerEvent += EventShim.Create(prov_OnServerEvent); int outprocessid; RemoteHooking.CreateAndInject(WoWHelper.GetWowInstallationPath(), "", (int)WoWHelper.CreationFlags.NewConsole | (int)WoWHelper.CreationFlags.Suspended, "LUAHost.dll", "LUAHost.dll", out outprocessid, logChannelName); IPCObject = RemoteHooking.IpcConnectClient <IPCInterface>(remoteLog.InjectedDLLChannelName); res = "Injection has been completed"; IsInjected = true; } catch (Exception e) { res = e.Message; IsInjected = false; } return(res); }
public bool Run() { if (TargetExePath != null) { RemoteHooking.CreateAndInject(TargetExePath, CommandLine, 0, InjectedLibPath, InjectedLibPath, out int pid, new Func <Dictionary <string, FileMapping> >(() => PuppetFiles)); TargetPid = pid; } else if (TargetPid > 0) { RemoteHooking.Inject(TargetPid, InjectedLibPath, InjectedLibPath, _channel); } return(false); }
static void Main(string[] args) { SetupConsole(); var configuration = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("hooksettings.json", optional: false) .Build(); var settings = new HookSettings(); configuration.Bind(settings); try { _ipcServer = RemoteHooking.IpcCreateServer <HookInterface>(ref _channelName, WellKnownObjectMode.Singleton); RemoteHooking.CreateAndInject( settings.ExePath, string.Empty, 0x00000004, InjectionOptions.DoNotRequireStrongName, hookPath, hookPath, out var pId, _channelName, settings.RedirectedIps, settings.RedirectionPort); } catch (Exception ex) { Console.WriteLine(ex); } while (true) { Thread.Sleep(1000); // TODO: handle close request etc. } }
static void Main(string[] args) { if (args.Length == 0) { args = new[] { @"C:\Program Files (x86)\Steam\steamapps\common\Hades\x64\Hades.exe" } } ; if (!File.Exists(args[0])) { Console.WriteLine(@"Cannot locate Hades executable, please run with 'HadesExtender.exe <HadesDirectory>\x64\Hades.exe'"); return; } RemoteHooking.CreateAndInject(args[0], "", InProcessCreationFlags: 0, InjectionOptions.DoNotRequireStrongName, typeof(EntryPoint).Assembly.Location, typeof(EntryPoint).Assembly.Location, out int processID); Process.GetProcessById(processID).WaitForExit(); } }
/// <summary> /// Start the application at <paramref name="exePath"/> /// and then inject and load the CoreHook hooking module <paramref name="injectionLibrary"/> /// in the newly created process. /// </summary> /// <param name="exePath">The path to the application to be launched.</param> /// <param name="injectionLibrary">The CoreHook hooking library to loaded in the target.</param> /// <param name="injectionPipeName"></param> private static void CreateAndInjectDll( string exePath, string injectionLibrary, string injectionPipeName = InjectionPipeName) { ValidateFilePath(exePath); ValidateFilePath(injectionLibrary); if (Examples.Common.ModulesPathHelper.GetCoreLoadPaths( false, out CoreHookNativeConfig configX86) && Examples.Common.ModulesPathHelper.GetCoreLoadPaths( true, out CoreHookNativeConfig configX64) && Examples.Common.ModulesPathHelper.GetCoreLoadModulePath( out string coreLoadLibrary)) { RemoteHooking.CreateAndInject( new ProcessCreationConfig { ExecutablePath = exePath, CommandLine = null, ProcessCreationFlags = 0x00 }, configX86, configX64, new RemoteHookingConfig { CLRBootstrapLibrary = coreLoadLibrary, InjectionPipeName = injectionPipeName, PayloadLibrary = injectionLibrary, VerboseLog = HostVerboseLog, WaitForDebugger = HostWaitForDebugger }, PipePlatform, out _, CoreHookPipeName); } }
private static void Main(string[] args) { try { args = new string[4]; args[0] = @"C:/Program Files (x86)/CCP/EVE/bin"; args[1] = @"setting.ini"; args[2] = @"C:/Users/Arjen/Documents/EvE Programming/Adapteve/Adapteve/Adapteve/bin/Debug/QuestorDLL.DLL"; args[3] = @"1"; if (args.Count() < 4) { Console.WriteLine("Usage: Adapteve.exe [ExeFile-path] [IniFile] [Questor-DLL] [Questor-Parameters]"); Console.ReadLine(); return; } var exefilePath = Utility.GetExefilePath(args[0]); var iniFile = Utility.VerifyIniFile(args[1]); var dll = Directory.GetCurrentDirectory() + "/AdapteveDLL.dll"; var qDll = args[2]; var qParam = args[3]; RemoteHooking.CreateAndInject(exefilePath, "", (int)InjectionOptions.Default, dll, dll, out pid, "", iniFile, qDll, qParam); Thread.Sleep(500); RemoteHooking.Inject(pid, qDll, qDll, qParam); } catch (Exception ex) { Console.WriteLine(ex.Message); Console.ReadLine(); } }
private static void LaunchHiSuite() { const string LibraryPath = "Interceptor.dll"; RemoteHooking.CreateAndInject(hiSuitePath, string.Empty, 0, LibraryPath, LibraryPath, out var _, string.Empty); }
private static void CreateAndInjectProcess(string networkId, string filePath, string arguments) { var injectorAddress = Assembly.GetExecutingAssembly().Location; var tries = 0; var processId = 0; while (true) { try { Console.WriteLine("Trying to create the process as suspended."); RemoteHooking.CreateAndInject( filePath, arguments, 0, injectorAddress, injectorAddress, out processId, networkId, injectorAddress, CommandLineOptions.Default.Delay, CommandLineOptions.Default.ChangeWindowTitle, CommandLineOptions.Default.Debug); var process = Process.GetProcessById(processId); Thread.Sleep(2000); if (process.HasExited) { return; } if (IsProcessStuckByInjection(process)) { Console.WriteLine("Process stuck in suspended state."); // Create and Inject failed if (!process.HasExited) { Console.WriteLine("Killing process ..."); process.Kill(); process.WaitForExit(3000); } throw new AccessViolationException("Failed to start the application."); } return; } catch { if (tries < 3 && processId == 0) { tries++; Thread.Sleep(1000); } else { throw; } } } }
// // Core hook methods public async Task <ProcessSharp <SMNatives> > CreateAndHookAsync( SMCollection collection, string binPath, IEnumerable <ISMAHookIO> ioCallbacks, NativeData nativeData) { LogTo.Debug("Starting and injecting SuperMemo"); IOCallbacks.AddRange(ioCallbacks); IOTargetFilePaths.AddRange(IOCallbacks.SelectMany(c => c.GetTargetFilePaths())); HookSuccess = false; HookException = null; // Start a new IPC server var channelName = StartIPCServer(); // Start SuperMemo application with given collection as parameter, // and immediately install hooks int pId = -1; try { RemoteHooking.CreateAndInject( binPath, collection.GetKnoFilePath().Quotify(), 0, InjectionOptions.Default, SMAFileSystem.InjectionLibFile.FullPath, null, out pId, channelName, nativeData ); } catch (ArgumentException ex) { LogTo.Warning(ex, "Failed to start and inject SuperMemo. Command line: '{BinPath} {V}'", binPath, collection.GetKnoFilePath().Quotify()); } LogTo.Debug("Waiting for signal from Injected library"); // Wait for Signal from OnHookInstalled with timeout await HookInitEvent.WaitAsync(WaitTimeout).ConfigureAwait(false); if (HookSuccess == false) { LogTo.Debug("Hook failed, aborting"); StopIPCServer(); var ex = new HookException("Hook setup failed: " + HookException?.Message, HookException); HookException = null; throw ex; } LogTo.Debug("SuperMemo started and injected, pId: {PId}", pId); return(new ProcessSharp <SMNatives>( pId, Process.NET.Memory.MemoryType.Remote, true, Core.CoreConfig.SuperMemo.PatternsHintAddresses, nativeData)); }