private void InternalSetKeyDown(int virtualKeyCode) { var foreignThreadId = Win32Imports.GetWindowThreadProcessId(_processWindowHandle, IntPtr.Zero); var localThreadId = Win32Imports.GetCurrentThreadId(); Win32Imports.AttachThreadInput(localThreadId, foreignThreadId, true); var keys = new byte[256]; Win32Imports.GetKeyboardState(keys); keys[virtualKeyCode] |= 0x80; Win32Imports.SetKeyboardState(keys); Task.Delay(50).Wait(); }
public static void DeallocateAVICOMPRESSOPTIONS(ref AVIWriterImports.AVICOMPRESSOPTIONS opts) { #if false // test: increase stability by never freeing anything, ever if (opts.lpParms != IntPtr.Zero) { Win32Imports.HeapFree(Win32Imports.GetProcessHeap(), 0, opts.lpParms); } if (opts.lpFormat != IntPtr.Zero) { Win32Imports.HeapFree(Win32Imports.GetProcessHeap(), 0, opts.lpFormat); } #endif opts.lpParms = IntPtr.Zero; opts.lpFormat = IntPtr.Zero; }
private void InternalSetKeyUp(int virtualKeyCode) { var keys = new byte[256]; Win32Imports.GetKeyboardState(keys); keys[virtualKeyCode] &= 0x00; Win32Imports.SetKeyboardState(keys); var foreignThreadId = Win32Imports.GetWindowThreadProcessId(_processWindowHandle, IntPtr.Zero); var localThreadId = Win32Imports.GetCurrentThreadId(); Win32Imports.AttachThreadInput(localThreadId, foreignThreadId, false); Thread.Sleep(50); }
public void CopySections(byte[] data, IMAGE_NT_HEADERS oldHeaders, IntPtr headers, IMAGE_DOS_HEADER dosHeader) { int i; IntPtr codebase = module.codeBase; var section = PointerHelpers.ToStruct <IMAGE_SECTION_HEADER>(headers, (uint)(24 + dosHeader.e_lfanew + oldHeaders.FileHeader.SizeOfOptionalHeader)); for (i = 0; i < module.headers.FileHeader.NumberOfSections; i++) { IntPtr dest; if (section.SizeOfRawData == 0) { uint size = oldHeaders.OptionalHeader.SectionAlignment; if (size > 0) { dest = new IntPtr((Win32Imports.VirtualAlloc((uint)(codebase + (int)section.VirtualAddress), size, Win32Constants.MEM_COMMIT, Win32Constants.PAGE_READWRITE))); section.PhysicalAddress = (uint)dest; var write = new IntPtr(headers.ToInt32() + (32 + dosHeader.e_lfanew + oldHeaders.FileHeader.SizeOfOptionalHeader) + (Marshal.SizeOf(typeof(IMAGE_SECTION_HEADER)) * (i))); Marshal.WriteInt32(write, (int)dest); var datazz = new byte[size + 1]; Marshal.Copy(datazz, 0, dest, (int)size); } section = PointerHelpers.ToStruct <IMAGE_SECTION_HEADER>(headers, (uint)((24 + dosHeader.e_lfanew + oldHeaders.FileHeader.SizeOfOptionalHeader) + (Marshal.SizeOf(typeof(IMAGE_SECTION_HEADER)) * (i + 1)))); continue; } dest = new IntPtr((Win32Imports.VirtualAlloc((uint)(codebase + (int)section.VirtualAddress), section.SizeOfRawData, Win32Constants.MEM_COMMIT, Win32Constants.PAGE_READWRITE))); Marshal.Copy(data, (int)section.PointerToRawData, dest, (int)section.SizeOfRawData); section.PhysicalAddress = (uint)dest; var write2 = new IntPtr(headers.ToInt32() + (32 + dosHeader.e_lfanew + oldHeaders.FileHeader.SizeOfOptionalHeader) + (Marshal.SizeOf(typeof(IMAGE_SECTION_HEADER)) * (i))); Marshal.WriteInt32(write2, (int)dest); section = PointerHelpers.ToStruct <IMAGE_SECTION_HEADER>(headers, (uint)((24 + dosHeader.e_lfanew + oldHeaders.FileHeader.SizeOfOptionalHeader) + (Marshal.SizeOf(typeof(IMAGE_SECTION_HEADER)) * (i + 1)))); } }
private void InternalSetPlayerFacing(Radian radian, MappedKeyAction nudgeKey) { var thread = _process.Threads[0]; var threadPtr = Win32Imports.OpenThread(2032639U, false, (uint)thread.Id); Win32Imports.SuspendThread(threadPtr); _reader.WriteFloat(ObjectManager.Me.BaseAddress + (uint)Offsets.WowObject.OBJECT_FIELD_ROTATION, radian.Angle); thread = _process.Threads[0]; threadPtr = Win32Imports.OpenThread(2032639U, false, (uint)thread.Id); Win32Imports.ResumeThread(threadPtr); Task.Delay(50).Wait(); SendKey(nudgeKey); Task.Delay(50).Wait(); }
private void dataGridView1_CellClick(object sender, DataGridViewCellEventArgs e) { if (e.RowIndex == -1) { return; } var obj = (RowUnit)dataGridView1.Rows[e.RowIndex].DataBoundItem; _commandManager.SetTarget(obj.Address); // var kcd = new KeyboardCommandDispatcher(); // kcd.SendG(_process); Win32Imports.SetForegroundWindow(_process.MainWindowHandle); _commandManager.SetPlayerFacing(obj.Location); }
public void SendShiftClick(Point point) { var offsetPoint = GetOffsetPoint(point); Cursor.Position = offsetPoint; var lparam = CreateMouseParam(offsetPoint); var flags = MouseFlags.MK_LBUTTON | MouseFlags.MK_SHIFT; Win32Imports.PostMessage(_processWindowHandle, WM_KEYDOWN, 0x10, 0x002A0001); Task.Delay(100).Wait(); Win32Imports.PostMessage(_processWindowHandle, WM_MOVEMOUSE, 0, lparam); Win32Imports.PostMessage(_processWindowHandle, 0x0020, 0x00050038, 0x02000001); Task.Delay(100).Wait(); Win32Imports.PostMessage(_processWindowHandle, WM_RBUTTONDOWN, (int)flags, lparam); Task.Delay(100).Wait(); Win32Imports.PostMessage(_processWindowHandle, WM_RBUTTONUP, (int)flags, lparam); Task.Delay(100).Wait(); Win32Imports.PostMessage(_processWindowHandle, WM_KEYUP, 0x10, 0xC02A0001); }
public static void SetSortIcon(this ListView listViewControl, int columnIndex, SortOrder order) { if (OSTailoredCode.IsUnixHost) { return; } const int LVM_GETHEADER = 4127; const int HDM_GETITEM = 4619; const int HDM_SETITEM = 4620; var columnHeader = Win32Imports.SendMessage(listViewControl.Handle, LVM_GETHEADER, IntPtr.Zero, IntPtr.Zero); for (int columnNumber = 0, l = listViewControl.Columns.Count; columnNumber < l; columnNumber++) { var columnPtr = new IntPtr(columnNumber); var item = new Win32Imports.HDITEM { mask = Win32Imports.HDITEM.Mask.Format }; if (Win32Imports.SendMessage(columnHeader, HDM_GETITEM, columnPtr, ref item) == IntPtr.Zero) { throw new Win32Exception(); } if (columnNumber != columnIndex || order == SortOrder.None) { item.fmt &= ~Win32Imports.HDITEM.Format.SortDown & ~Win32Imports.HDITEM.Format.SortUp; } else if (order == SortOrder.Ascending) { item.fmt &= ~Win32Imports.HDITEM.Format.SortDown; item.fmt |= Win32Imports.HDITEM.Format.SortUp; } else if (order == SortOrder.Descending) { item.fmt &= ~Win32Imports.HDITEM.Format.SortUp; item.fmt |= Win32Imports.HDITEM.Format.SortDown; } if (Win32Imports.SendMessage(columnHeader, HDM_SETITEM, columnPtr, ref item) == IntPtr.Zero) { throw new Win32Exception(); } } }
public void SetPlayerFacing(Location destination) { var angle = GetFaceRadian(destination, ObjectManager.Me.Location); var thread = _process.Threads[0]; var threadPtr = Win32Imports.OpenThread(2032639U, false, (uint)thread.Id); Win32Imports.SuspendThread(threadPtr); _reader.WriteFloat(ObjectManager.Me.BaseAddress + (uint)Offsets.WowObject.OBJECT_FIELD_ROTATION, angle); thread = _process.Threads[0]; threadPtr = Win32Imports.OpenThread(2032639U, false, (uint)thread.Id); Win32Imports.ResumeThread(threadPtr); Thread.Sleep(50); Win32Imports.PostMessage(_process.MainWindowHandle, 0x100, (int)0x25, 0x14B0001); Win32Imports.PostMessage(_process.MainWindowHandle, 0x101, (int)0x25, (0x14B0001 + 0xC0000000)); }
static GamePad360() { try { // some users won't even have xinput installed. in order to avoid spurious exceptions and possible instability, check for the library first var llManager = OSTailoredCode.LinkedLibManager; var libraryHandle = llManager.LoadOrZero("xinput1_3.dll"); if (libraryHandle == IntPtr.Zero) { libraryHandle = llManager.LoadOrZero("xinput1_4.dll"); } if (libraryHandle != IntPtr.Zero) { XInputGetStateExProc = (XInputGetStateExProcDelegate)Marshal.GetDelegateForFunctionPointer( Win32Imports.GetProcAddressOrdinal(libraryHandle, new IntPtr(100)), typeof(XInputGetStateExProcDelegate) ); } else { libraryHandle = llManager.LoadOrZero("xinput9_1_0.dll"); } IsAvailable = libraryHandle != IntPtr.Zero; // don't remove this code. it's important to catch errors on systems with broken xinput installs. // (probably, checking for the library was adequate, but let's not get rid of this anyway) if (IsAvailable) { _ = new Controller(UserIndex.One).IsConnected; } } catch { // ignored } }
private void CreateMutex(StartupEventArgs e) { bool createdNew; _mutex = new Mutex(true, Utility.Md5Hash(Utility.Md5Checksum(Constants.AppDirectory) + Utility.Md5Hash(Environment.UserName)), out createdNew); if (!createdNew) { if (e.Args.Length > 0) { var wnd = Win32Imports.FindWindow(IntPtr.Zero, "UOFLauncher"); if (wnd != IntPtr.Zero) { Clipboard.SetText(e.Args[0]); ShowWindow(wnd, 5); SetForegroundWindow(wnd); } } _mutex = null; Environment.Exit(0); } }
public static void PrintCurrentFP() => Console.WriteLine($"Current FP word: 0x{Win32Imports._control87(0, 0):X8}");
public PeRunner(PeRunnerOptions opt) { _nextStart = opt.StartAddress; Initialize(_nextStart); using (this.EnterExit()) { // load any predefined exports _psx = new Psx(this); _exports.Add("libpsxscl.so", BizExvoker.GetExvoker(_psx, CallingConventionAdapters.Waterbox)); _emu = new Emu(this); _exports.Add("libemuhost.so", BizExvoker.GetExvoker(_emu, CallingConventionAdapters.Waterbox)); _syscalls = new Syscalls(this); _exports.Add("__syscalls", BizExvoker.GetExvoker(_syscalls, CallingConventionAdapters.Waterbox)); // load and connect all modules, starting with the executable var todoModules = new Queue <string>(); todoModules.Enqueue(opt.Filename); while (todoModules.Count > 0) { var moduleName = todoModules.Dequeue(); if (!_exports.ContainsKey(moduleName)) { var path = Path.Combine(opt.Path, moduleName); var gzpath = path + ".gz"; byte[] data; if (File.Exists(gzpath)) { using (var fs = new FileStream(gzpath, FileMode.Open, FileAccess.Read)) { data = Util.DecompressGzipFile(fs); } } else { data = File.ReadAllBytes(path); } var module = new PeWrapper(moduleName, data, _nextStart); ComputeNextStart(module.Size); AddMemoryBlock(module.Memory, moduleName); _savestateComponents.Add(module); _disposeList.Add(module); _exports.Add(moduleName, module); _modules.Add(module); foreach (var name in module.ImportsByModule.Keys) { todoModules.Enqueue(name); } } } _libcpatch = new LibcPatch(this); _exports["libc.so"] = new PatchImportResolver(_exports["libc.so"], BizExvoker.GetExvoker(_libcpatch, CallingConventionAdapters.Waterbox)); ConnectAllImports(); // load all heaps _heap = CreateHeapHelper(opt.SbrkHeapSizeKB, "brk-heap", true); _sealedheap = CreateHeapHelper(opt.SealedHeapSizeKB, "sealed-heap", true); _invisibleheap = CreateHeapHelper(opt.InvisibleHeapSizeKB, "invisible-heap", false); _plainheap = CreateHeapHelper(opt.PlainHeapSizeKB, "plain-heap", true); if (opt.MmapHeapSizeKB != 0) { _mmapheap = new MapHeap(_nextStart, opt.MmapHeapSizeKB * 1024, "mmap-heap"); _mmapheap.Memory.Activate(); ComputeNextStart(opt.MmapHeapSizeKB * 1024); AddMemoryBlock(_mmapheap.Memory, "mmap-heap"); _savestateComponents.Add(_mmapheap); _disposeList.Add(_mmapheap); } _syscalls.Init(); Console.WriteLine("About to enter unmanaged code"); if (!OSTailoredCode.IsUnixHost && !System.Diagnostics.Debugger.IsAttached && Win32Imports.IsDebuggerPresent()) { // this means that GDB or another unconventional debugger is attached. // if that's the case, and it's observing this core, it probably wants a break System.Diagnostics.Debugger.Break(); } // run unmanaged init code var libcEnter = _exports["libc.so"].GetProcAddrOrThrow("__libc_entry_routine"); var psxInit = _exports["libpsxscl.so"].GetProcAddrOrThrow("__psx_init"); var del = (LibcEntryRoutineD)CallingConventionAdapters.Waterbox.GetDelegateForFunctionPointer(libcEnter, typeof(LibcEntryRoutineD)); // the current mmglue code doesn't use the main pointer at all, and this just returns del(IntPtr.Zero, psxInit, 0); foreach (var m in _modules) { m.RunGlobalCtors(); } /*try * { * _modules[0].RunExeEntry(); * //throw new InvalidOperationException("main() returned!"); * } * catch //(EndOfMainException) * { * } * _modules[0].RunGlobalCtors(); * foreach (var m in _modules.Skip(1)) * { * if (!m.RunDllEntry()) * throw new InvalidOperationException("DllMain() returned false"); * m.RunGlobalCtors(); * }*/ } }
public static void RemoveMOTW(string path) => Win32Imports.DeleteFileW($"{path}:Zone.Identifier");
public void FinalizeSections(IntPtr headers, IMAGE_DOS_HEADER dosHeader, IMAGE_NT_HEADERS oldHeaders) { ProtectionFlags[0] = new Int32[2][]; ProtectionFlags[1] = new Int32[2][]; ProtectionFlags[0][0] = new Int32[2]; ProtectionFlags[0][1] = new Int32[2]; ProtectionFlags[1][0] = new Int32[2]; ProtectionFlags[1][1] = new Int32[2]; ProtectionFlags[0][0][0] = 0x01; ProtectionFlags[0][0][1] = 0x08; ProtectionFlags[0][1][0] = 0x02; ProtectionFlags[0][1][1] = 0x04; ProtectionFlags[1][0][0] = 0x10; ProtectionFlags[1][0][1] = 0x80; ProtectionFlags[1][1][0] = 0x20; ProtectionFlags[1][1][1] = 0x40; IMAGE_SECTION_HEADER section = PointerHelpers.ToStruct <IMAGE_SECTION_HEADER>(headers, (UInt32)(24 + dosHeader.e_lfanew + oldHeaders.FileHeader.SizeOfOptionalHeader)); for (Int32 i = 0; i < _module.headers.FileHeader.NumberOfSections; i++) { //Console.WriteLine("Finalizing " + Encoding.UTF8.GetString(section.Name)); Int32 executable = (section.Characteristics & 0x20000000) != 0 ? 1 : 0; Int32 readable = (section.Characteristics & 0x40000000) != 0 ? 1 : 0; Int32 writeable = (section.Characteristics & 0x80000000) != 0 ? 1 : 0; if ((section.Characteristics & 0x02000000) > 0) { Boolean aa = Win32Imports.VirtualFree(new IntPtr(section.PhysicalAddress), (UIntPtr)section.SizeOfRawData, 0x4000); continue; } UInt32 protect = (UInt32)ProtectionFlags[executable][readable][writeable]; if ((section.Characteristics & 0x04000000) > 0) { protect |= 0x200; } Int32 size = (Int32)section.SizeOfRawData; if (size == 0) { if ((section.Characteristics & 0x00000040) > 0) { size = (Int32)_module.headers.OptionalHeader.SizeOfInitializedData; } else if ((section.Characteristics & 0x00000080) > 0) { size = (Int32)_module.headers.OptionalHeader.SizeOfUninitializedData; } } if (size > 0) { UInt32 oldProtect; if (!Win32Imports.VirtualProtect(new IntPtr(section.PhysicalAddress), section.SizeOfRawData, protect, out oldProtect)) { } } section = PointerHelpers.ToStruct <IMAGE_SECTION_HEADER>(headers, (UInt32)((24 + dosHeader.e_lfanew + oldHeaders.FileHeader.SizeOfOptionalHeader) + (Marshal.SizeOf(typeof(IMAGE_SECTION_HEADER)) * (i + 1)))); } }
public WaterboxHost(WaterboxOptions opt) { _nextStart = opt.StartAddress; Initialize(_nextStart); using (this.EnterExit()) { _emu = new EmuLibc(this); _syscalls = new Syscalls(this); _imports = new PatchImportResolver( NotImplementedSyscalls.Instance, BizExvoker.GetExvoker(_emu, CallingConventionAdapters.Waterbox), BizExvoker.GetExvoker(_syscalls, CallingConventionAdapters.Waterbox) ); if (true) { var moduleName = opt.Filename; var path = Path.Combine(opt.Path, moduleName); var gzpath = path + ".gz"; byte[] data; if (File.Exists(gzpath)) { using var fs = new FileStream(gzpath, FileMode.Open, FileAccess.Read); data = Util.DecompressGzipFile(fs); } else { data = File.ReadAllBytes(path); } _module = new ElfLoader(moduleName, data, _nextStart, opt.SkipCoreConsistencyCheck, opt.SkipMemoryConsistencyCheck); ComputeNextStart(_module.Memory.Size); AddMemoryBlock(_module.Memory, moduleName); _savestateComponents.Add(_module); _disposeList.Add(_module); } ConnectAllImports(); // load all heaps _heap = CreateHeapHelper(opt.SbrkHeapSizeKB, "brk-heap", true); _sealedheap = CreateHeapHelper(opt.SealedHeapSizeKB, "sealed-heap", true); _invisibleheap = CreateHeapHelper(opt.InvisibleHeapSizeKB, "invisible-heap", false); _plainheap = CreateHeapHelper(opt.PlainHeapSizeKB, "plain-heap", true); if (opt.MmapHeapSizeKB != 0) { _mmapheap = new MapHeap(_nextStart, opt.MmapHeapSizeKB * 1024, "mmap-heap"); _mmapheap.Memory.Activate(); ComputeNextStart(opt.MmapHeapSizeKB * 1024); AddMemoryBlock(_mmapheap.Memory, "mmap-heap"); _savestateComponents.Add(_mmapheap); _disposeList.Add(_mmapheap); } System.Diagnostics.Debug.WriteLine($"About to enter unmanaged code for {opt.Filename}"); if (!OSTailoredCode.IsUnixHost && !System.Diagnostics.Debugger.IsAttached && Win32Imports.IsDebuggerPresent()) { // this means that GDB or another unconventional debugger is attached. // if that's the case, and it's observing this core, it probably wants a break System.Diagnostics.Debugger.Break(); } _module.RunNativeInit(); } }
/// <summary> /// Rebuilds the PE import table after address relocations. /// </summary> public int BuildImportTable() { int ucount = GetModuleCount(); module.modules = Marshal.AllocHGlobal((ucount) * sizeof(int)); int pcount = 0; int result = 1; IntPtr codeBase = module.codeBase; IMAGE_DATA_DIRECTORY directory = module.headers.OptionalHeader.DataDirectory[1]; if (directory.Size > 0) { var importDesc = PointerHelpers.ToStruct <IMAGE_IMPORT_DESCRIPTOR>(codeBase, directory.VirtualAddress); while (importDesc.Name > 0) { var str = codeBase + (int)importDesc.Name; string tmp = Marshal.PtrToStringAnsi(str); unsafe { uint *thunkRef; uint *funcRef; int handle = Win32Imports.LoadLibrary(tmp); if (handle == -1) { result = 0; break; } if (importDesc.CharacteristicsOrOriginalFirstThunk > 0) { IntPtr thunkRefAddr = codeBase + (int)importDesc.CharacteristicsOrOriginalFirstThunk; thunkRef = (uint *)thunkRefAddr; funcRef = (uint *)(codeBase + (int)importDesc.FirstThunk); } else { thunkRef = (uint *)(codeBase + (int)importDesc.FirstThunk); funcRef = (uint *)(codeBase + (int)importDesc.FirstThunk); } for (; *thunkRef > 0; thunkRef++, funcRef++) { if ((*thunkRef & 0x80000000) != 0) { *funcRef = (uint)Win32Imports.GetProcAddress(new IntPtr(handle), new IntPtr(*thunkRef & 0xffff)); } else { var str2 = codeBase + (int)(*thunkRef) + 2; var tmpaa = Marshal.PtrToStringAnsi(str2); * funcRef = Win32Imports.GetProcAddress(new IntPtr(handle), tmpaa); } if (*funcRef == 0) { result = 0; break; } } pcount++; importDesc = PointerHelpers.ToStruct <IMAGE_IMPORT_DESCRIPTOR>(codeBase, directory.VirtualAddress + (uint)(Marshal.SizeOf(typeof(IMAGE_IMPORT_DESCRIPTOR)) * pcount)); } } } return(result); }
/// <summary> /// Gets the version info for a given application /// </summary> /// <param name="AppName">Full path to the application to get version info</param> // marked with 'unsafe' because it uses pointers: unsafe public static VersionInfo GetVersionInfo(string AppName) { VersionInfo result = new VersionInfo(); try { int handle = 0; // Figure out how much version info there is: int size = Win32Imports.GetFileVersionInfoSize(AppName, out handle); if (size == 0) { throw new Exception("Couldn't find Application: " + AppName + "." + Environment.NewLine + "Error CNF-402 in " + PROJ_FILE_NAME + ".validateData()."); } byte[] buffer = new byte[size]; if (!Win32Imports.GetFileVersionInfo(AppName, handle, size, buffer)) { throw new Exception("Failed to query file version information." + Environment.NewLine + "Error CNF-403 in " + PROJ_FILE_NAME + ".validateData()."); } const int INFONUM = 10; string[] InfoStr = new string[INFONUM] { "CompanyName", "FileDescription", "FileVersion", "InternalName", "LegalCopyright", "LegalTradeMarks", "OriginalFileName", "ProductName", "ProductVersion", "Comments" }; short *subBlock = null; uint len = 0; string val; if (!Win32Imports.VerQueryValue(buffer, @"\VarFileInfo\Translation", out subBlock, out len)) { throw new Exception("Failed to query version information." + Environment.NewLine + "Error CNF-404 in " + PROJ_FILE_NAME + ".validateData()."); } for (int i = 0; i < INFONUM; i++) { string spv = "\\StringFileInfo\\" + subBlock[0].ToString("X4") + subBlock[1].ToString("X4") + "\\" + InfoStr[i]; if (Win32Imports.VerQueryValue(buffer, spv, out val, out len)) { switch (i) { case 0: result.CompanyName = val; break; case 1: result.FileDescription = val; break; case 2: result.FileVersion = val; break; case 3: result.InternalName = val; break; case 4: result.LegalCopyright = val; break; case 5: result.LegalTradeMarks = val; break; case 6: result.OriginalFileName = val; break; case 7: result.ProductName = val; break; case 8: result.ProductVersion = val; break; case 9: result.Comments = val; break; } // switch i } // if Win32Imports.VerQueryValue } } catch (Exception e) { throw new Exception("Error retrieving file info." + Environment.NewLine + "Error CNF-405 in " + PROJ_FILE_NAME + ".validateData(): " + e.Message); } return(result); }
/// <summary>Shows the folder browser dialog box with the specified owner window.</summary> public DialogResult ShowDialog(IWin32Window owner = null) { const Win32Imports.BROWSEINFO.FLAGS privateOptions = Win32Imports.BROWSEINFO.FLAGS.NewDialogStyle | Win32Imports.BROWSEINFO.FLAGS.ShowTextBox; const int startLocation = 0; // = Desktop CSIDL int Callback(IntPtr hwnd, uint uMsg, IntPtr lParam, IntPtr lpData) { if (uMsg == 1) { var str = Marshal.StringToHGlobalUni(SelectedPath); Win32Imports.SendMessage(hwnd, 0x400 + 103, (IntPtr)1, str); Marshal.FreeHGlobal(str); } return(0); } var hWndOwner = owner?.Handle ?? Win32Imports.GetActiveWindow(); _ = Win32Imports.SHGetSpecialFolderLocation(hWndOwner, startLocation, out var pidlRoot); if (pidlRoot == IntPtr.Zero) { return(DialogResult.Cancel); } var mergedOptions = publicOptions | privateOptions; if ((mergedOptions & Win32Imports.BROWSEINFO.FLAGS.NewDialogStyle) != 0 && ApartmentState.MTA == Application.OleRequired()) { mergedOptions &= ~Win32Imports.BROWSEINFO.FLAGS.NewDialogStyle; } IntPtr pidlRet = default; try { var buffer = Marshal.AllocHGlobal(Win32Imports.MAX_PATH); var bi = new Win32Imports.BROWSEINFO { hwndOwner = hWndOwner, pidlRoot = pidlRoot, pszDisplayName = buffer, lpszTitle = Description, ulFlags = mergedOptions, lpfn = Callback }; pidlRet = Win32Imports.SHBrowseForFolder(ref bi); Marshal.FreeHGlobal(buffer); if (pidlRet == IntPtr.Zero) { return(DialogResult.Cancel); // user clicked Cancel } var sb = new StringBuilder(Win32Imports.MAX_PATH); if (Win32Imports.SHGetPathFromIDList(pidlRet, sb) == 0) { return(DialogResult.Cancel); } SelectedPath = sb.ToString(); } finally { _ = Win32Imports.SHGetMalloc(out var malloc); malloc.Free(pidlRoot); if (pidlRet != IntPtr.Zero) { malloc.Free(pidlRet); } } return(DialogResult.OK); }
public static void SetForegroundWindow(IntPtr windowHandle) { Win32Imports.SetForegroundWindow(windowHandle); }
public static IntPtr GetForegroundWindow() { return(Win32Imports.GetForegroundWindow()); }
protected override void OnStartup(StartupEventArgs e) { if (File.Exists(Updater.SetupFile)) { Thread.Sleep(1000); } bool createdNew; _mutex = new Mutex(true, Utility.Md5Hash(Utility.Md5Checksum(Directories.LoaderFilePath) + Utility.Md5Hash(Environment.UserName)), out createdNew); if (!createdNew) { if (e.Args.Length > 0) { var wnd = Win32Imports.FindWindow(IntPtr.Zero, "LeagueSharp"); if (wnd != IntPtr.Zero) { Clipboard.SetText(e.Args[0]); ShowWindow(wnd, 5); SetForegroundWindow(wnd); } } _mutex = null; Environment.Exit(0); } Utility.CreateFileFromResource(Directories.ConfigFilePath, "LeagueSharp.Loader.Resources.config.xml"); var configCorrupted = false; try { Config.Instance = ((Config)Utility.MapXmlFileToClass(typeof(Config), Directories.ConfigFilePath)); } catch (Exception) { configCorrupted = true; } if (!configCorrupted) { try { if (File.Exists(Directories.ConfigFilePath + ".bak")) { File.Delete(Directories.ConfigFilePath + ".bak"); } File.Copy(Directories.ConfigFilePath, Directories.ConfigFilePath + ".bak"); File.SetAttributes(Directories.ConfigFilePath + ".bak", FileAttributes.Hidden); } catch (Exception) { //ignore } } else { try { Config.Instance = ((Config)Utility.MapXmlFileToClass(typeof(Config), Directories.ConfigFilePath + ".bak")); File.Delete(Directories.ConfigFilePath); File.Copy(Directories.ConfigFilePath + ".bak", Directories.ConfigFilePath); File.SetAttributes(Directories.ConfigFilePath, FileAttributes.Normal); } catch (Exception) { File.Delete(Directories.ConfigFilePath + ".bak"); File.Delete(Directories.ConfigFilePath); MessageBox.Show("Couldn't load config.xml."); Environment.Exit(0); } } #region Remove the old loader try { if (String.Compare( Process.GetCurrentProcess().ProcessName, "LeagueSharp.Loader.exe", StringComparison.InvariantCultureIgnoreCase) != 0 && File.Exists(Path.Combine(Directories.CurrentDirectory, "LeagueSharp.Loader.exe"))) { File.Delete(Path.Combine(Directories.CurrentDirectory, "LeagueSharp.Loader.exe")); File.Delete(Path.Combine(Directories.CurrentDirectory, "LeagueSharp.Loader.exe.config")); } } catch (Exception ex) { //ignore } #endregion #region AppData randomization try { if (!Directory.Exists(Directories.AppDataDirectory)) { Directory.CreateDirectory(Directories.AppDataDirectory); var oldPath = Path.Combine(Environment.GetFolderPath( Environment.SpecialFolder.ApplicationData), "LeagueSharp" + Environment.UserName.GetHashCode().ToString("X")); var oldPath2 = Path.Combine(Environment.GetFolderPath( Environment.SpecialFolder.ApplicationData), "LeagueSharp"); if (Directory.Exists(oldPath)) { Utility.CopyDirectory(oldPath, Directories.AppDataDirectory, true, true); Utility.ClearDirectory(oldPath); Directory.Delete(oldPath, true); } if (Directory.Exists(oldPath2)) { Utility.CopyDirectory(oldPath2, Directories.AppDataDirectory, true, true); Utility.ClearDirectory(oldPath2); Directory.Delete(oldPath2, true); } } } catch (Exception ex) { //ignore } #endregion //Load the language resources. var dict = new ResourceDictionary(); if (Config.Instance.SelectedLanguage != null) { dict.Source = new Uri( "..\\Resources\\Language\\" + Config.Instance.SelectedLanguage + ".xaml", UriKind.Relative); } else { var lid = Thread.CurrentThread.CurrentCulture.ToString().Contains("-") ? Thread.CurrentThread.CurrentCulture.ToString().Split('-')[0].ToUpperInvariant() : Thread.CurrentThread.CurrentCulture.ToString().ToUpperInvariant(); switch (lid) { case "DE": dict.Source = new Uri("..\\Resources\\Language\\German.xaml", UriKind.Relative); break; case "AR": dict.Source = new Uri("..\\Resources\\Language\\Arabic.xaml", UriKind.Relative); break; case "ES": dict.Source = new Uri("..\\Resources\\Language\\Spanish.xaml", UriKind.Relative); break; case "FR": dict.Source = new Uri("..\\Resources\\Language\\French.xaml", UriKind.Relative); break; case "IT": dict.Source = new Uri("..\\Resources\\Language\\Italian.xaml", UriKind.Relative); break; case "KO": dict.Source = new Uri("..\\Resources\\Language\\Korean.xaml", UriKind.Relative); break; case "NL": dict.Source = new Uri("..\\Resources\\Language\\Dutch.xaml", UriKind.Relative); break; case "PL": dict.Source = new Uri("..\\Resources\\Language\\Polish.xaml", UriKind.Relative); break; case "PT": dict.Source = new Uri("..\\Resources\\Language\\Portuguese.xaml", UriKind.Relative); break; case "RO": dict.Source = new Uri("..\\Resources\\Language\\Romanian.xaml", UriKind.Relative); break; case "RU": dict.Source = new Uri("..\\Resources\\Language\\Russian.xaml", UriKind.Relative); break; case "SE": dict.Source = new Uri("..\\Resources\\Language\\Swedish.xaml", UriKind.Relative); break; case "TR": dict.Source = new Uri("..\\Resources\\Language\\Turkish.xaml", UriKind.Relative); break; case "VI": dict.Source = new Uri("..\\Resources\\Language\\Vietnamese.xaml", UriKind.Relative); break; case "ZH": dict.Source = new Uri("..\\Resources\\Language\\Chinese.xaml", UriKind.Relative); break; case "LT": dict.Source = new Uri("..\\Resources\\Language\\Lithuanian.xaml", UriKind.Relative); break; default: dict.Source = new Uri("..\\Resources\\Language\\English.xaml", UriKind.Relative); break; } } if (Config.Instance.SelectedColor != null) { ThemeManager.ChangeAppStyle(Application.Current, ThemeManager.GetAccent(Config.Instance.SelectedColor), ThemeManager.GetAppTheme("BaseLight")); } Resources.MergedDictionaries.Add(dict); base.OnStartup(e); }
public IDisposable Save() { cw = Win32Imports._control87(0, 0); Win32Imports._control87(0x00000, 0x30000); return(this); }
internal unsafe bool LoadLibrary(byte[] data) { //fnDllEntry dllEntry; var dosHeader = PointerHelpers.ToStruct <IMAGE_DOS_HEADER>(data); var oldHeader = PointerHelpers.ToStruct <IMAGE_NT_HEADERS>(data, (uint)dosHeader.e_lfanew); var code = (IntPtr)(Win32Imports.VirtualAlloc(oldHeader.OptionalHeader.ImageBase, oldHeader.OptionalHeader.SizeOfImage, Win32Constants.MEM_RESERVE, Win32Constants.PAGE_READWRITE)); if (code.ToInt32() == 0) { code = (IntPtr)(Win32Imports.VirtualAlloc((uint)code, oldHeader.OptionalHeader.SizeOfImage, Win32Constants.MEM_RESERVE, Win32Constants.PAGE_READWRITE)); } module = new MEMORYMODULE { codeBase = code, numModules = 0, modules = new IntPtr(0), initialized = 0 }; Win32Imports.VirtualAlloc((uint)code, oldHeader.OptionalHeader.SizeOfImage, Win32Constants.MEM_COMMIT, Win32Constants.PAGE_READWRITE); var headers = (IntPtr)(Win32Imports.VirtualAlloc((uint)code, oldHeader.OptionalHeader.SizeOfHeaders, Win32Constants.MEM_COMMIT, Win32Constants.PAGE_READWRITE)); Marshal.Copy(data, 0, headers, (int)(dosHeader.e_lfanew + oldHeader.OptionalHeader.SizeOfHeaders)); module.headers = PointerHelpers.ToStruct <IMAGE_NT_HEADERS>(headers, (uint)dosHeader.e_lfanew); module.headers.OptionalHeader.ImageBase = (uint)code; CopySections(data, oldHeader, headers, dosHeader); var locationDelta = (uint)(code - (int)oldHeader.OptionalHeader.ImageBase); if (locationDelta != 0) { PerformBaseRelocation(locationDelta); } BuildImportTable(); FinalizeSections(headers, dosHeader, oldHeader); bool success = false; try { fnDllEntry dllEntry = (fnDllEntry) Marshal.GetDelegateForFunctionPointer( new IntPtr(module.codeBase.ToInt32() + (int)module.headers.OptionalHeader.AddressOfEntryPoint), typeof(fnDllEntry)); success = dllEntry(code.ToInt32(), 1, (void *)0); } catch (Exception ex) { return(false); } return(success); }
public void Dispose() { Win32Imports._control87(cw, 0x30000); }
public void SetFocus() { Win32Imports.SetForegroundWindow(_process.MainWindowHandle); }
/// <summary> /// Allocates memory pages and sets header permissions. /// </summary> /// <param name="headers">The headers to write to each section of the PE.</param> /// <param name="dosHeader">The current header of the PE.</param> /// <param name="oldHeaders">The old headers of the PE that have been overwritten.</param> public void FinalizeSections(IntPtr headers, IMAGE_DOS_HEADER dosHeader, IMAGE_NT_HEADERS oldHeaders) { ProtectionFlags[0] = new int[2][]; ProtectionFlags[1] = new int[2][]; ProtectionFlags[0][0] = new int[2]; ProtectionFlags[0][1] = new int[2]; ProtectionFlags[1][0] = new int[2]; ProtectionFlags[1][1] = new int[2]; ProtectionFlags[0][0][0] = 0x01; ProtectionFlags[0][0][1] = 0x08; ProtectionFlags[0][1][0] = 0x02; ProtectionFlags[0][1][1] = 0x04; ProtectionFlags[1][0][0] = 0x10; ProtectionFlags[1][0][1] = 0x80; ProtectionFlags[1][1][0] = 0x20; ProtectionFlags[1][1][1] = 0x40; var section = PointerHelpers.ToStruct <IMAGE_SECTION_HEADER>(headers, (uint)(24 + dosHeader.e_lfanew + oldHeaders.FileHeader.SizeOfOptionalHeader)); for (int i = 0; i < module.headers.FileHeader.NumberOfSections; i++) { int executable = (section.Characteristics & 0x20000000) != 0 ? 1 : 0; int readable = (section.Characteristics & 0x40000000) != 0 ? 1 : 0; int writeable = (section.Characteristics & 0x80000000) != 0 ? 1 : 0; if ((section.Characteristics & 0x02000000) > 0) { bool aa = Win32Imports.VirtualFree(new IntPtr(section.PhysicalAddress), (UIntPtr)section.SizeOfRawData, 0x4000); continue; } var protect = (uint)ProtectionFlags[executable][readable][writeable]; if ((section.Characteristics & 0x04000000) > 0) { protect |= 0x200; } var size = (int)section.SizeOfRawData; if (size == 0) { if ((section.Characteristics & 0x00000040) > 0) { size = (int)module.headers.OptionalHeader.SizeOfInitializedData; } else if ((section.Characteristics & 0x00000080) > 0) { size = (int)module.headers.OptionalHeader.SizeOfUninitializedData; } } if (size > 0) { uint oldProtect; if (!Win32Imports.VirtualProtect(new IntPtr(section.PhysicalAddress), section.SizeOfRawData, protect, out oldProtect)) { } } section = PointerHelpers.ToStruct <IMAGE_SECTION_HEADER>(headers, (uint)((24 + dosHeader.e_lfanew + oldHeaders.FileHeader.SizeOfOptionalHeader) + (Marshal.SizeOf(typeof(IMAGE_SECTION_HEADER)) * (i + 1)))); } }
public KeyboardCommandDispatcher(Process process) { _processWindowHandle = Win32Imports.FindWindowEx(process.MainWindowHandle, IntPtr.Zero, null, null); }