/// <summary> /// Executes the assembly code located in the remote process at the specified address. /// </summary> /// <param name="address">The address where the assembly code is located.</param> /// <param name="callingConvention">The calling convention used to execute the assembly code with the parameters.</param> /// <param name="parameters">An array of parameters used to execute the assembly code.</param> /// <returns>The return value is the exit code of the thread created to execute the assembly code.</returns> public T Execute <T>(IntPtr address, Native.Types.CallingConventions callingConvention, params dynamic[] parameters) { // Marshal the parameters var marshalledParameters = parameters.Select(p => MarshalValue.Marshal(Process, p)).Cast <IMarshalledValue>().ToArray(); // Start a transaction AssemblyTransaction t; using (t = BeginTransaction()) { // Get the object dedicated to create mnemonics for the given calling convention var calling = CallingConventionSelector.Get(callingConvention); // Push the parameters t.AddLine(calling.FormatParameters(marshalledParameters.Select(p => p.Reference).ToArray())); // Call the function t.AddLine(calling.FormatCalling(address)); // Clean the parameters if (calling.Cleanup == CleanupTypes.Caller) { t.AddLine(calling.FormatCleaning(marshalledParameters.Length)); } // Add the return mnemonic t.AddLine("retn"); } // Clean the marshalled parameters foreach (var parameter in marshalledParameters) { parameter.Dispose(); } // Return the exit code return(t.GetExitCode <T>()); }
public T Execute <T>(IntPtr address, CallingConvention callingConvention, params dynamic[] parameters) { var marshalledParameters = parameters.Select(p => MarshalValue.Marshal(m_Process, p)).Cast <IMarshalledValue>().ToArray(); var calling = callingConvention == CallingConvention.Default ? CallingConventionSelector.Get(m_Process.Is64Bit ? CallingConvention.FastCall64 : CallingConvention.StdCall) : CallingConventionSelector.Get(m_Process.Is64Bit ? CallingConvention.FastCall64 : callingConvention); AssemblyTransaction t; using (t = BeginTransaction()) { t.Add(calling.FormatCall(address, marshalledParameters.Select(p => p.Reference).ToArray())); } foreach (var parameter in marshalledParameters) { parameter.Dispose(); } return(t.GetExitCode <T>()); }
/// <summary>Executes the assembly code located in the remote process at the specified address.</summary> /// <param name="address">The address where the assembly code is located.</param> /// <param name="callingConvention"> /// The calling convention used to execute the assembly code with /// the parameters. /// </param> /// <param name="executingThread">Thread to hijack.</param> /// <returns>The return value is the exit code of the thread created to execute the assembly code.</returns> public T Execute <T>(IntPtr address, Native.Types.CallingConventions callingConvention, IRemoteThread executingThread) { // Start a transaction AssemblyTransaction t; using (t = BeginTransaction(true, executingThread)) { // Get the object dedicated to create mnemonics for the given calling convention var calling = CallingConventionSelector.Get(callingConvention); // Call the function t.AddLine(calling.FormatCalling(address)); // Add the return mnemonic t.AddLine("retn"); } return(t.GetExitCode <T>()); }