public bool Enable()
{
/* 1. Выделить память под кейв
* 2. Записать байты кейва
* 3. Высчитать байты для прыжка из кейва обратно в оригинальный код
* 4. Высчитать байты для прыжка из оригинального кода в кейв
* 5. Записать байты обратного прыжка в кейв
* 6. Записать байты прыжка в кейв в оригинальную инструкцию, добив недостающие байты длины оригинальной инструкции нопами.
*/
caveAddress = WinAPIWrapper.AllocMem(patchBytes.Length + 5);
byte[] caveData = new byte[patchBytes.Length + 5];
Array.Copy(patchBytes, 0, caveData, 0, patchBytes.Length);
byte[] returnJump = CalculateJumpOpcode(caveAddress.ToInt32(), instructionAddress.ToInt32() + originalSize);
Array.Copy(returnJump, 0, caveData, patchBytes.Length, returnJump.Length);
WinAPIWrapper.WriteMem(caveAddress, caveData);
byte[] jmpBytes = CalculateJumpOpcode(instructionAddress.ToInt32(), caveAddress.ToInt32());
if (originalSize > 5)
{
byte[] jmpFromOriginal = new byte[originalSize];
Array.Copy(jmpBytes, 0, jmpFromOriginal, 0, jmpBytes.Length);
for (int i = 5; i < jmpFromOriginal.Length; i++)
{
jmpFromOriginal[i] = 0x90;
}
WinAPIWrapper.WriteMem(instructionAddress, jmpFromOriginal);
}
else
{
WinAPIWrapper.WriteMem(instructionAddress, jmpBytes);
}
isEnabled = true;
onEnabled.Invoke(this);
return(true);
}
protected override void OnSourceInitialized(EventArgs e)
{
base.OnSourceInitialized(e);
//Set the window style to noactivate.
WindowInteropHelper helper = new WindowInteropHelper(this);
WinAPIWrapper.SetWindowLong(helper.Handle, WinAPIWrapper.GWL_EXSTYLE,
GetWindowLong(helper.Handle, WinAPIWrapper.GWL_EXSTYLE) | WinAPIWrapper.WS_EX_NOACTIVATE);
}
protected override void OnSourceInitialized(EventArgs e)
{
base.OnSourceInitialized(e);
IntPtr handle = (new WindowInteropHelper(this)).Handle;
HwndSource.FromHwnd(handle).AddHook(new HwndSourceHook(WindowProc));
taskBarCreatedMsg = WinAPIWrapper.RegisterWindowMessage("TaskbarCreated");
uCallBackMsg = WinAPIWrapper.RegisterWindowMessage("APPBARMSG_CSDN_HELPER_USTC.Software.hanyizhao.NetSpeedMonitor");
RegisterAppBar(true);
}
private void UpdateProcessList()
{
try
{
var tempProcList = new List <Process>();
BackgroundWorker worker = new BackgroundWorker()
{
WorkerReportsProgress = true
};
worker.DoWork += (ws, we) =>
{
foreach (var proc in Process.GetProcesses())
{
var rect = WindowInfo.GetProcessDimensions(proc);
uDebugLogAdd($"Process {proc.ProcessName} | T{rect.Top} L{rect.Left} H{rect.Bottom - rect.Top} W{rect.Right - rect.Left}");
if (WindowInfo.DoesProcessHandleHaveSize(proc))
{
uDebugLogAdd($"Process {proc.ProcessName} has size");
uDebugLogAdd($"Process {proc.ProcessName} doesn't currently exist in the proclist, adding process");
tempProcList.Add(proc);
try
{
StringBuilder sb = new StringBuilder(1024);
WinAPIWrapper.GetClassName(proc.MainWindowHandle, sb, sb.Capacity);
uDebugLogAdd($"Process added: {proc.ProcessName} | Class: {sb.ToString()}");
}
catch
{
uDebugLogAdd($"Process {proc.ProcessName} was added but couldn't get the class");
}
}
}
worker.ReportProgress(1);
};
worker.ProgressChanged += (ps, pe) =>
{
if (pe.ProgressPercentage == 1)
{
lbProcList.ItemsSource = null;
ProcessList = tempProcList.OrderBy(x => x.ProcessName).ToList();
lbProcList.ItemsSource = ProcessList;
uDebugLogAdd("Updated process list");
}
};
worker.RunWorkerAsync();
}
catch (Exception ex)
{
LogException(ex);
}
}
/// <summary>
/// Call this method in main thread.
/// </summary>
/// <param name="causeNotFillScreen">The foreground window is not a full screen App because it doesn't fill the screen.
/// Otherwise, because it is Window Explorer or...</param>
/// <returns></returns>
private bool CheckHasFullScreenApp(out bool causeNotFillScreen)
{
causeNotFillScreen = false;
bool result;
IntPtr foreWindow = WinAPIWrapper.GetForegroundWindow();
WinAPIWrapper.GetWindowThreadProcessId(foreWindow, out uint processid);
String foreGroundWindowName = "";
try
{
foreGroundWindowName = Process.GetProcessById((int)processid).ProcessName;
//Console.WriteLine("foreGroundWindowName:" + foreGroundWindowName);
}
catch (Exception)
{
}
if (foreGroundWindowName != "explorer" && !foreWindow.Equals(new WindowInteropHelper(this).Handle))//"SearchUI"
{
IntPtr deskWindow = WinAPIWrapper.GetDesktopWindow();
if (!foreWindow.Equals(deskWindow) && !foreWindow.Equals(WinAPIWrapper.GetShellWindow()))
{
WinAPIWrapper.GetWindowRect(foreWindow, out Services.Detail.RECT foreWindowRECT);
WinAPIWrapper.GetWindowRect(deskWindow, out Services.Detail.RECT deskWindowRECT);
//Console.WriteLine("foreWindow RECT:" + foreWindowRECT);
//Console.WriteLine("deskWindow RECT:" + deskWindowRECT);
// Check whether foreground Window fills main screen.
result = foreWindowRECT.left <= deskWindowRECT.left &&
foreWindowRECT.top <= deskWindowRECT.top &&
foreWindowRECT.right >= deskWindowRECT.right &&
foreWindowRECT.bottom >= deskWindowRECT.bottom;
causeNotFillScreen = true;
}
else
{
// Foreground Window is DeskWindow or ShellWindow.
result = false;
}
}
else
{
// Foreground window is Windows Explorer or MainWindow itself.
result = false;
}
if (result)
{
}
return(result);
}
public static bool RunsAsService()
{
var commandline = System.Environment.CommandLine;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Microsoft.Azure.Web.DataProtection.Util.IsAzureEnvironment() == false)
{
if (IsUnderIisExpress())
{
return(false);
}
return(WinAPIWrapper.CheckForConsoleWindow() && IsUnderWindowsServiceManager());
}
return(false); // never can be a windows service
}
public void RegisterAppBar(bool register)
{
Services.Detail.APPBARDATA abd = new Services.Detail.APPBARDATA();
abd.cbSize = Marshal.SizeOf(abd);
abd.hWnd = new WindowInteropHelper(this).Handle;
if (register)
{
//register
abd.uCallbackMessage = uCallBackMsg;
_ = WinAPIWrapper.SHAppBarMessage((int)Services.Detail.ABMsg.ABM_NEW, ref abd);
// Check whether there is a full screen app now.
HideAllView(CheckHasFullScreenApp(out _));
}
else
{
WinAPIWrapper.SHAppBarMessage((int)Services.Detail.ABMsg.ABM_REMOVE, ref abd);
}
}
private void vKeyThreadRoutine()
{
while (isRunning)
{
if (WinAPIWrapper.GetAsyncKeyState(vKey) != 0)
{
if (isEnabled)
{
Disable();
}
else
{
Enable();
}
}
Thread.Sleep(200);
}
}
private static void OnWindowHeightAnimationChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
try
{
if (d is Window window)
{
IntPtr handle = new WindowInteropHelper(window).Handle;
if (WinAPIWrapper.GetWindowRect(handle, out RECT rect))
{
if (PresentationSource.FromVisual(window) != null)
{
int height = (int)Math.Round(window.PointToScreen(new Point(0, (double)e.NewValue)).Y - rect.top);
WinAPIWrapper.SetWindowPos(handle, new IntPtr((int)SpecialWindowHandles.TopMost), rect.left, rect.top, rect.right - rect.left, height, SetWindowPosFlags.SHOWWINDOW);
}
}
}
}
catch (Exception)
{
}
}
private static void ClearSystemKeepAlive()
{
WinAPIWrapper.AllowIdle();
}
private static void SetSystemKeepAlive()
{
WinAPIWrapper.KeepAlive();
WinAPIWrapper.ResetTimer();
}
private void UpdateWindowList()
{
try
{
ToggleLoading(LoadingType.Start);
var stopWatch = new Stopwatch();
stopWatch.Start();
var tempWindowList = new List <WindowListItem>();
BackgroundWorker worker = new BackgroundWorker()
{
WorkerReportsProgress = true
};
worker.DoWork += (ws, we) =>
{
try
{
foreach (var proc in Process.GetProcesses())
{
try
{
var rect = WindowInfo.GetProcessDimensions(proc);
uDebugLogAdd($"Process {proc.ProcessName} | T{rect.Top} L{rect.Left} H{rect.Bottom - rect.Top} W{rect.Right - rect.Left}");
if (WindowInfo.DoesProcessHandleHaveSize(proc))
{
uDebugLogAdd($"Process {proc.ProcessName} has size");
if (tempWindowList.Find(x => x.Process.MainWindowHandle == proc.MainWindowHandle) == null)
{
uDebugLogAdd($"Process {proc.ProcessName} doesn't currently exist in the windowList, adding process");
foreach (var handle in WinAPIWrapper.EnumerateProcessWindowHandles(proc.Id))
{
try
{
if (WindowInfo.DoesHandleHaveSize(handle) && WinAPIWrapper.IsWindowVisible(handle))
{
var windowListItem = WindowListItem.Create(proc, handle);
if (tempWindowList.Find(x => x.Display == windowListItem.Display) == null)
{
tempWindowList.Add(windowListItem);
uDebugLogAdd($"Added to list | [{windowListItem.Handle}]{windowListItem.Display}");
}
else
{
uDebugLogAdd($"Item already in the list, skipping | {windowListItem.Display}");
}
}
else
{
uDebugLogAdd($"Handle window doesn't have size, skipping | [{handle}]{proc.ProcessName}");
}
}
catch (Exception ex)
{
uDebugLogAdd($"Unable to add handle to the list | [{handle}]{proc.ProcessName}: {ex.Message}");
}
}
}
else
{
uDebugLogAdd($"Already enumerated through handles for {proc.ProcessName}, skipping this one");
}
}
}
catch (Exception ex)
{
uDebugLogAdd($"Unable to get proc {proc.ProcessName}: {ex.Message}");
}
}
}
catch (Exception ex)
{
LogException(ex);
}
worker.ReportProgress(1);
};
worker.ProgressChanged += (ps, pe) =>
{
if (pe.ProgressPercentage == 1)
{
lbProcList.ItemsSource = null;
WindowList = tempWindowList.OrderBy(x => x.Display).ToList();
lbProcList.ItemsSource = WindowList;
stopWatch.Stop();
uDebugLogAdd($"Updated window list, took: {stopWatch.Elapsed.Seconds}s {stopWatch.Elapsed.Milliseconds}ms");
ToggleLoading(LoadingType.Done);
}
};
worker.RunWorkerAsync();
}
catch (Exception ex)
{
LogException(ex);
}
}
