Пример #1
0
 AttachableProcessInfo(int processId, RuntimeId runtimeId, Guid runtimeGuid, Guid runtimeKindGuid, string runtimeName, string name, string title, string filename, string commandLine, DbgArchitecture architecture, DbgOperatingSystem operatingSystem)
 {
     ProcessId       = processId;
     RuntimeId       = runtimeId ?? throw new ArgumentNullException(nameof(runtimeId));
     RuntimeGuid     = runtimeGuid;
     RuntimeKindGuid = runtimeKindGuid;
     RuntimeName     = runtimeName ?? throw new ArgumentNullException(nameof(runtimeName));
     Name            = name ?? throw new ArgumentNullException(nameof(name));
     Title           = title ?? throw new ArgumentNullException(nameof(title));
     Filename        = filename ?? throw new ArgumentNullException(nameof(filename));
     CommandLine     = commandLine ?? throw new ArgumentNullException(nameof(commandLine));
     Architecture    = architecture;
     OperatingSystem = operatingSystem;
 }
Пример #2
0
        static string GetArchitectureString(DbgArchitecture architecture)
        {
            switch (architecture)
            {
            case DbgArchitecture.X86:       return("x86");

            case DbgArchitecture.X64:       return("x64");

            case DbgArchitecture.Arm:       return("ARM");

            case DbgArchitecture.Arm64:     return("ARM64");

            default:
                Debug.Fail($"Unknown architecture: {architecture}");
                return("???");
            }
        }
Пример #3
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="dll">DLL name including dll extension, case sensitive. It can be any name, it's only used to make sure only one handler patches a function.</param>
 /// <param name="function">Function name, case sensitive. It can be any name, it's only used to make sure only one handler patches a function.</param>
 /// <param name="architecture">Supported architecture</param>
 /// <param name="operatingSystem">Supported operating system</param>
 /// <param name="order">Order</param>
 public ExportDbgNativeFunctionHookAttribute(string dll, string function, DbgArchitecture architecture, DbgOperatingSystem operatingSystem, double order = double.MaxValue)
     : this(dll, function, new[] { architecture }, new[] { operatingSystem }, order)
 {
 }
 public Key(DbgArchitecture architecture, DbgOperatingSystem operatingSystem)
 {
     this.architecture    = architecture;
     this.operatingSystem = operatingSystem;
 }
Пример #5
0
        static bool TryGetRegisterX86(DbgArchitecture architecture, CorDebugRegister corReg, out X86Register register)
        {
            switch (architecture)
            {
            case DbgArchitecture.X86:
                switch (corReg)
                {
                case CorDebugRegister.REGISTER_X86_EIP:
                    register = X86Register.EIP;
                    return(true);

                case CorDebugRegister.REGISTER_X86_ESP:
                    register = X86Register.ESP;
                    return(true);

                case CorDebugRegister.REGISTER_X86_EBP:
                    register = X86Register.EBP;
                    return(true);

                case CorDebugRegister.REGISTER_X86_EAX:
                    register = X86Register.EAX;
                    return(true);

                case CorDebugRegister.REGISTER_X86_ECX:
                    register = X86Register.ECX;
                    return(true);

                case CorDebugRegister.REGISTER_X86_EDX:
                    register = X86Register.EDX;
                    return(true);

                case CorDebugRegister.REGISTER_X86_EBX:
                    register = X86Register.EBX;
                    return(true);

                case CorDebugRegister.REGISTER_X86_ESI:
                    register = X86Register.ESI;
                    return(true);

                case CorDebugRegister.REGISTER_X86_EDI:
                    register = X86Register.EDI;
                    return(true);

                case CorDebugRegister.REGISTER_X86_FPSTACK_0:
                    register = X86Register.ST0;
                    return(true);

                case CorDebugRegister.REGISTER_X86_FPSTACK_1:
                    register = X86Register.ST1;
                    return(true);

                case CorDebugRegister.REGISTER_X86_FPSTACK_2:
                    register = X86Register.ST2;
                    return(true);

                case CorDebugRegister.REGISTER_X86_FPSTACK_3:
                    register = X86Register.ST3;
                    return(true);

                case CorDebugRegister.REGISTER_X86_FPSTACK_4:
                    register = X86Register.ST4;
                    return(true);

                case CorDebugRegister.REGISTER_X86_FPSTACK_5:
                    register = X86Register.ST5;
                    return(true);

                case CorDebugRegister.REGISTER_X86_FPSTACK_6:
                    register = X86Register.ST6;
                    return(true);

                case CorDebugRegister.REGISTER_X86_FPSTACK_7:
                    register = X86Register.ST7;
                    return(true);

                default:
                    Debug.Fail($"Unknown register number {(int)corReg}");
                    register = X86Register.None;
                    return(false);
                }

            case DbgArchitecture.X64:
                switch (corReg)
                {
                case CorDebugRegister.REGISTER_AMD64_RIP:
                    register = X86Register.RIP;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_RSP:
                    register = X86Register.RSP;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_RBP:
                    register = X86Register.RBP;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_RAX:
                    register = X86Register.RAX;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_RCX:
                    register = X86Register.RCX;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_RDX:
                    register = X86Register.RDX;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_RBX:
                    register = X86Register.RBX;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_RSI:
                    register = X86Register.RSI;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_RDI:
                    register = X86Register.RDI;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_R8:
                    register = X86Register.R8;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_R9:
                    register = X86Register.R9;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_R10:
                    register = X86Register.R10;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_R11:
                    register = X86Register.R11;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_R12:
                    register = X86Register.R12;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_R13:
                    register = X86Register.R13;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_R14:
                    register = X86Register.R14;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_R15:
                    register = X86Register.R15;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM0:
                    register = X86Register.XMM0;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM1:
                    register = X86Register.XMM1;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM2:
                    register = X86Register.XMM2;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM3:
                    register = X86Register.XMM3;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM4:
                    register = X86Register.XMM4;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM5:
                    register = X86Register.XMM5;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM6:
                    register = X86Register.XMM6;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM7:
                    register = X86Register.XMM7;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM8:
                    register = X86Register.XMM8;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM9:
                    register = X86Register.XMM9;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM10:
                    register = X86Register.XMM10;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM11:
                    register = X86Register.XMM11;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM12:
                    register = X86Register.XMM12;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM13:
                    register = X86Register.XMM13;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM14:
                    register = X86Register.XMM14;
                    return(true);

                case CorDebugRegister.REGISTER_AMD64_XMM15:
                    register = X86Register.XMM15;
                    return(true);

                default:
                    Debug.Fail($"Unknown register number {(int)corReg}");
                    register = X86Register.None;
                    return(false);
                }

            case DbgArchitecture.Arm:
            case DbgArchitecture.Arm64:
            default:
                Debug.Fail($"Unsupported architecture: {architecture}");
                register = default;
                return(false);
            }
        }