using System;
using System.Runtime.InteropServices;
using EasyHook;
using System.Drawing;
using System.IO;
using System.Threading;

namespace ScreenHook
{
    public class Main : IEntryPoint
    {
        // 原始API声明
        [DllImport("gdi32.dll")]
        static extern bool BitBlt(IntPtr hdcDest, int xDest, int yDest, int w, int h, IntPtr hdcSrc, int xSrc, int ySrc, uint rop);

        [DllImport("user32.dll")]
        static extern bool PrintWindow(IntPtr hWnd, IntPtr hdc, uint flags);

        [DllImport("gdi32.dll")]
        static extern int GetDIBits(IntPtr hdc, IntPtr hbm, uint start, uint cLines, IntPtr bits, ref BITMAPINFO bi, uint usage);

        [StructLayout(LayoutKind.Sequential)]
        public struct BITMAPINFO
        {
            public int biSize;
            public int biWidth;
            public int biHeight;
            public short biPlanes;
            public short biBitCount;
            public int biCompression;
            public int biSizeImage;
            public int biXPelsPerMeter;
            public int biYPelsPerMeter;
            public int biClrUsed;
            public int biClrImportant;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 1024)]
            public byte[] bmiColors;
        }

        // 共享资源
        static Bitmap _fakeImage;
        static IntPtr _fakeHdc;
        static string _fakeImagePath;
        static FileSystemWatcher _watcher;
        static Mutex _imgMutex = new Mutex(false, "Global\\FakeImageMutex");

        public Main(RemoteHooking.IContext context, string fakeImagePath)
        {
            _fakeImagePath = fakeImagePath;
            LoadImageWithMutex();
        }

        void LoadImageWithMutex()
        {
            _imgMutex.WaitOne();
            try
            {
                if (File.Exists(_fakeImagePath))
                {
                    _fakeImage?.Dispose();
                    _fakeImage = new Bitmap(_fakeImagePath);
                    using (var g = Graphics.FromImage(_fakeImage))
                        _fakeHdc = g.GetHdc();
                }
            }
            finally { _imgMutex.ReleaseMutex(); }
        }

        // Hook函数
        [Hook(TargetDll = "gdi32.dll", TargetName = "BitBlt", CallingConvention = CallingConvention.StdCall)]
        public static bool BitBlt_Hooked(IntPtr hdcDest, int xDest, int yDest, int w, int h, IntPtr hdcSrc, int xSrc, int ySrc, uint rop)
        {
            try
            {
                if (IsScreenDC(hdcSrc) && _fakeHdc != IntPtr.Zero)
                {
                    return BitBlt(hdcDest, xDest, yDest, w, h, _fakeHdc, xSrc, ySrc, rop);
                }
            }
            catch { }
            return BitBlt(hdcDest, xDest, yDest, w, h, hdcSrc, xSrc, ySrc, rop);
        }

        // 其他Hook函数实现类似...

        public void Run(RemoteHooking.IContext context, string fakeImagePath)
        {
            // 启动文件监控
            _watcher = new FileSystemWatcher(Path.GetDirectoryName(_fakeImagePath))
            {
                Filter = Path.GetFileName(_fakeImagePath),
                NotifyFilter = NotifyFilters.LastWrite
            };
            _watcher.Changed += (s, e) => LoadImageWithMutex();
            _watcher.EnableRaisingEvents = true;

            RemoteHooking.WakeUpProcess();
            while (true) Thread.Sleep(10000);
        }

        static bool IsScreenDC(IntPtr hdc)
        {
            try
            {
                const int TECHNOLOGY = 2;
                const int DT_RASDISPLAY = 0;
                return GetDeviceCaps(hdc, TECHNOLOGY) == DT_RASDISPLAY;
            }
            catch { return false; }
        }

        [DllImport("gdi32.dll")]
        static extern int GetDeviceCaps(IntPtr hdc, int index);
    }
}

using EasyHook;
using System;
using System.Diagnostics;
using System.Linq;

class Program
{
    static void Main()
    {
        string fakeImagePath = @"C:\fake\screen.png";
        string[] protectedProcesses = { "csrss", "wininit", "smss", "system", "lsass", "jietu" };

        // 自动生成强名称签名
        Config.Register(
            "GlobalScreenHook",
            "Injector.exe.config",
            Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ScreenHook.dll")
        );

        foreach (var proc in Process.GetProcesses()
            .Where(p => 
                p.Id != Process.GetCurrentProcess().Id &&
                !protectedProcesses.Contains(p.ProcessName.ToLower()) &&
                !IsWow64Process(p)))
        {
            try
            {
                RemoteHooking.Inject(
                    proc.Id,
                    InjectionOptions.Default | InjectionOptions.NoWOW64Bypass,
                    "ScreenHook.dll",
                    "ScreenHook.dll",
                    fakeImagePath
                );
                Log($"[SUCCESS] Injected {proc.ProcessName} (PID: {proc.Id})");
            }
            catch (Exception ex)
            {
                Log($"[FAIL] {proc.ProcessName} (PID: {proc.Id}) - {ex.Message.Substring(0, 80)}");
            }
        }
    }

    static bool IsWow64Process(Process p)
    {
        try
        {
            bool isWow64;
            return NativeMethods.IsWow64Process(p.Handle, out isWow64) && isWow64;
        }
        catch { return false; }
    }

    static void Log(string message)
    {
        string logPath = @"C:\fake\inject.log";
        File.AppendAllText(logPath, $"{DateTime.Now:yyyy-MM-dd HH:mm:ss} {message}\n");
    }

    static class NativeMethods
    {
        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool IsWow64Process(IntPtr hProcess, out bool wow64Process);
    }
}