Beispiel #1
0
        /// <summary>
        ///     Gets the disassembly lines.
        /// </summary>
        /// <param name="threadId">The thread identifier.</param>
        /// <param name="numInstructions">The number instructions.</param>
        /// <returns>IEnumerable&lt;DisassemblyLine&gt;</returns>
        /// <exception cref="ArgumentOutOfRangeException">Number of instructions must be &gt; 0</exception>
        public IEnumerable <DisassemblyLine> GetDisassemblyLines(int threadId, int numInstructions)
        {
            if (numInstructions <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(numInstructions), "Number of instructions must be > 0");
            }
            var ipRegister      = DebugEngineProxy.Is32Bit ? "eip" : "rip";
            var instructionText = DebugEngineProxy.Execute(threadId, $"u {ipRegister} L{numInstructions:X}");
            var matches         = Regex.Matches(instructionText,
                                                @"(?<ip>[a-fA-F0-9`]+)\s+(?<opcode>[a-fA-F0-9]+)\s+(?<ins>\w+)\s+(?<extra>.+)?");
            var list = new List <DisassemblyLine>();

            foreach (var match in matches.Cast <Match>())
            {
                var ip = match.Groups["ip"].Success
                    ? Convert.ToUInt64(match.Groups["ip"].Value.Replace("`", ""), 16)
                    : 0;
                byte[] opcode = null;
                if (match.Groups["opcode"].Success)
                {
                    opcode = ByteArrayBuilder.StringToByteArray(match.Groups["opcode"].Value);
                }
                var instruction = match.Groups["ins"].Success ? match.Groups["ins"].Value : "";
                var note        = match.Groups["extra"].Success ? match.Groups["extra"].Value : "";
                var newLine     = new DisassemblyLine(ip, opcode, instruction, note);
                list.Add(newLine);
            }

            return(list);
        }
Beispiel #2
0
        /*
         * Todo: add ability to tag all frames in a range e.g. thread 1 from a to b or all threads a to b0
         */
        /// <summary>
        ///     Processes the specified arguments.
        /// </summary>
        /// <param name="args">The arguments.</param>
        /// <returns>Task.</returns>
        /// <exception cref="ArgumentNullException">args</exception>
        /// <exception cref="ArgumentOutOfRangeException"></exception>
        public void Process(string[] args)
        {
            if (args == null)
            {
                throw new ArgumentNullException(nameof(args));
            }
            if (!args.Any())
            {
                // list tags at the current position
                var tags   = ServerClient.GetRecentTags(10);
                var output = FormatTagsForOutput(tags);
                DebugEngineProxy.WriteLine(output);
            }
            else
            {
                var command = args[0];
                switch (command)
                {
                case "add":
                    var addOptions = ExtractAddOptions(args.Skip(1));
                    AddTag(addOptions);
                    break;

                // todo: edit, delete
                default:
                    throw new ArgumentOutOfRangeException($"Unknown subcommand {command}");
                }
            }
        }
Beispiel #3
0
 /// <summary>
 ///     Indexes the breakpoint hits.
 /// </summary>
 /// <param name="options">The options.</param>
 internal virtual void IndexBreakpointHits(IndexOptions options)
 {
     var end = GetEndingPosition(options);
     var start = GetStartingPosition(options);
     var curPos = TimeTravelFacade.SetPosition(start).ActualPosition;
     BreakpointFacade.ClearBreakpoints();
     SetBreakpoints(options);
     while (curPos <= end)
     {
         DebugEngineProxy.RunUntilBreak();
         curPos = TimeTravelFacade.GetCurrentPosition();
         if (curPos <= end)
             UpsertCurrentPosition(options);
         for (int i = 0; i < options.Step; i++)
         {
             var newPosition = new Position(curPos.High, curPos.Low + 1);
             var posRes = TimeTravelFacade.SetPosition(newPosition);
             curPos = posRes.ActualPosition;
             if (posRes.BreakpointHit.HasValue)
                 i = -1;
             if (curPos >= end)
                 return;
             UpsertCurrentPosition(options);
         }
     }
 }
Beispiel #4
0
        /// <summary>
        ///     Gets the stack frames.
        /// </summary>
        /// <param name="threadId">The thread identifier.</param>
        /// <returns>IEnumerable&lt;StackFrame&gt;.</returns>
        public IEnumerable <StackFrame> GetStackFrames(int threadId)
        {
            var command = $"k";
            var raw     = DebugEngineProxy.Execute(threadId, command);

            return(ExtractStackFrames(raw));
        }
Beispiel #5
0
        public static void DebugExtensionNotify(uint Notify, ulong Argument)
        {
            if (Notify == 2)
            {
                if (!showedIntro)
                {
                    var assembly = Assembly.GetExecutingAssembly();
                    var path     = Path.Combine(Path.GetDirectoryName(assembly.Location), "mcfly.log");
                    log = new DefaultLog(path);
                    InitApi(log);
                    var types = assembly.GetTypes().Where(x => typeof(IInjectable).IsAssignableFrom(x));
                    log.Debug($"Injectable types: {string.Join(", ", types.Select(x => x.FullName))}");
                    var typeCatalog = new TypeCatalog(types);
                    compositionContainer = new CompositionContainer(typeCatalog);
                    log.Debug("Creating debug engine proxy");
                    var dbgEng = new DebugEngineProxy(control, client, registers, systemObjects, debugDataSpaces);

                    log.Debug("Composing debug engine");
                    compositionContainer.ComposeExportedValue <IDebugEngineProxy>(dbgEng);
                    compositionContainer.ComposeExportedValue(log);
                    PopulateSettings();
                    app = compositionContainer.GetExportedValue <McFlyApp>();
                    WriteLine("When this baby hits 88 miles per hour... you're gonna see some serious shit.");
                    showedIntro = true;
                }
            }
        }
Beispiel #6
0
        /// <summary>
        ///     Gets the current stack trace.
        /// </summary>
        /// <returns>StackTrace.</returns>
        public StackTrace GetCurrentStackTrace()
        {
            var stackTrace = DebugEngineProxy.Execute("k");
            var frames     = ExtractStackFrames(stackTrace);

            return(new StackTrace(frames));
        }
Beispiel #7
0
        /// <summary>
        ///     Processes the specified arguments.
        /// </summary>
        /// <param name="args">The arguments.</param>
        /// <returns>Task.</returns>
        /// <exception cref="ArgumentNullException">args</exception>
        /// <exception cref="ArgumentOutOfRangeException">
        ///     args
        ///     or
        ///     args
        /// </exception>
        public void Process(string[] args)
        {
            if (args == null)
            {
                throw new ArgumentNullException(nameof(args));
            }
            if (args.Length != 1)
            {
                throw new ArgumentOutOfRangeException(nameof(args),
                                                      $"SettingsMethod expects exactly 1 argument, but was given {args.Length}");
            }
            switch (args[0].ToLower())
            {
            case "list":
                foreach (var settings in AllSettings)
                {
                    DebugEngineProxy.WriteLine(settings.GetType().FullName);
                    DebugEngineProxy.WriteLine(JsonConvert.SerializeObject(settings, Formatting.Indented));
                }

                break;

            case "reload":
                McFlyExtension.PopulateSettings();
                break;

            case "open":
                var p = System.Diagnostics.Process.Start(McFlyExtension.GetLogPath());
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(args),
                                                      $"Settings takes 3 commands: list, reload, or open. Found {args[0]}");
            }
        }
Beispiel #8
0
        /// <summary>
        ///     Gets the ending position
        /// </summary>
        /// <returns>Position.</returns>
        public Position GetEndingPosition()
        {
            var end      = DebugEngineProxy.Execute("!tt 100"); // todo: get from trace_info
            var endMatch = Regex.Match(end, "Setting position: (?<pos>[A-F0-9]+:[A-F0-9]+)");

            return(Position.Parse(endMatch.Groups["pos"].Value));
        }
Beispiel #9
0
        /// <summary>
        ///     Positionses this instance.
        /// </summary>
        /// <returns>PositionsResult.</returns>
        public PositionsResult Positions()
        {
            var positionsText = DebugEngineProxy.Execute("!positions");
            var records       = ParsePositionsCommandText(positionsText);

            return(new PositionsResult(records));
        }
Beispiel #10
0
 /// <summary>
 ///     Is32s the bit.
 /// </summary>
 /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
 internal bool Is32Bit()
 {
     if (!_is32Bit.HasValue)
     {
         _is32Bit = Regex.Match(DebugEngineProxy.Execute("!peb"), @"PEB at (?<peb>[a-fA-F0-9]+)").Groups["peb"]
                    .Value
                    .Length ==
                    8;
     }
     return(_is32Bit.Value);
 }
Beispiel #11
0
        /// <summary>
        ///     Processes the internal.
        /// </summary>
        /// <param name="startingPosition">The starting position.</param>
        /// <param name="endingPosition">The ending position.</param>
        /// <param name="options">The options.</param>
        internal void ProcessInternal(Position startingPosition, Position endingPosition, IndexOptions options)
        {
            SetBreakpoints(options);
            TimeTravelFacade.SetPosition(startingPosition);
            // loop through all the set break points and record relevant values
            var      frames = new List <Frame>();
            Position last   = null;

            /*
             * todo: PRIORITY FIX
             */

            while (true) // todo: have better abstraction... while(!TimeTravelFacade.RunTo(endingPosition))
            {
                DebugEngineProxy.RunUntilBreak();
                var positions   = TimeTravelFacade.Positions();
                var breakRecord = positions.CurrentThreadResult;
                if (last == breakRecord.Position)
                {
                    break;
                }

                var newFrames = CreateFramesForUpsert(positions, breakRecord, options);
                frames.AddRange(newFrames);

                foreach (var optionsMemoryRange in options?.MemoryRanges ?? new List <MemoryRange>())
                {
                    var bytes = DebugEngineProxy.ReadVirtualMemory(optionsMemoryRange); // todo: errors?
                    ServerClient.AddMemoryRange(new MemoryChunk
                    {
                        MemoryRange = optionsMemoryRange,
                        Bytes       = bytes,
                        Position    = breakRecord.Position
                    });
                }

                last = breakRecord.Position;
            }

            try
            {
                ServerClient.UpsertFrames(frames);
            }
            catch (Exception e)
            {
                Log.Error($"Error persisting frames: {e.GetType().FullName} - {e.Message}");
                DebugEngineProxy.WriteLine($"Error persisting frames: {e.GetType().FullName} - {e.Message}");
            }
        }
Beispiel #12
0
        /// <summary>
        ///     Processes the specified arguments.
        /// </summary>
        /// <param name="args">The arguments.</param>
        /// <returns>Task.</returns>
        public void Process(string[] args)
        {
            if (IsEmptyArgs(args))
            {
                var commandListing = GetCommandListing();
                DebugEngineProxy.WriteLine(commandListing);
                return;
            }

            if (IsSingleCommand(args))
            {
                var commandHelp = GetCommandHelp(args[0]);
                DebugEngineProxy.WriteLine(commandHelp);
            }
        }
Beispiel #13
0
 /// <summary>
 ///     Upserts the current position.
 /// </summary>
 /// <param name="options">The options.</param>
 internal virtual void UpsertCurrentPosition(IndexOptions options)
 {
     var positions = TimeTravelFacade.Positions();
     var frames = CreateFramesForUpsert(positions);
     ServerClient.UpsertFrames(frames);
     foreach (var optionsMemoryRange in options?.MemoryRanges ?? new List<MemoryRange>())
     {
         var bytes = DebugEngineProxy.ReadVirtualMemory(optionsMemoryRange); // todo: errors?
         ServerClient.AddMemoryRange(new MemoryChunk
         {
             MemoryRange = optionsMemoryRange,
             Bytes = bytes,
             Position = positions.CurrentThreadResult.Position
         });
     }
 }
Beispiel #14
0
        /// <summary>
        ///     Gets the current frame.
        /// </summary>
        /// <returns>Frame.</returns>
        public Frame GetCurrentFrame()
        {
            var position     = GetCurrentPosition();
            var currentStack = StackFacade.GetCurrentStackTrace();
            var registers    = RegisterFacade.GetCurrentRegisterSet(Register.All);
            var disassembly  = DisassemblyFacade.GetDisassemblyLines(1).Single();

            return(new Frame
            {
                Position = position,
                StackTrace = currentStack,
                RegisterSet = registers,
                DisassemblyLine = disassembly,
                ThreadId = DebugEngineProxy.GetCurrentThreadId()
            });
        }
Beispiel #15
0
        /// <summary>
        ///     Sets the position.
        /// </summary>
        /// <param name="position">The position.</param>
        public SetPositionResult SetPosition(Position position)
        {
            var result = new SetPositionResult();
            var output = DebugEngineProxy.Execute($"!tt {position}");
            var match  = Regex.Match(output, "Time Travel Position: (?<pos>[a-f0-9]+:[a-f0-9]+)", RegexOptions.IgnoreCase);

            if (!match.Success)
            {
                throw new ApplicationException(
                          $"Attempted to set position to {position}, but was unable to process the output");
            }
            result.ActualPosition = Position.Parse(match.Groups["pos"].Value);
            var breakpointMatch = Regex.Match(output, @"Breakpoint (?<bp>\d+) hit");

            if (breakpointMatch.Success)
            {
                result.BreakpointHit = Convert.ToInt32(breakpointMatch.Groups["bp"].Value);
            }
            return(result);
        }
Beispiel #16
0
 /// <summary>
 ///     Sets the breakpoint by mask.
 /// </summary>
 /// <param name="moduleMask">The module mask.</param>
 /// <param name="functionMask">The function mask.</param>
 public void SetBreakpointByMask(string moduleMask, string functionMask)
 {
     DebugEngineProxy.Execute($"bm {moduleMask}!{functionMask}");
 }
Beispiel #17
0
 /// <summary>
 ///     Sets the write access breakpoint.
 /// </summary>
 /// <param name="length">The length.</param>
 /// <param name="address">The address.</param>
 public void SetWriteAccessBreakpoint(int length, ulong address)
 {
     ValidateLength(length);
     DebugEngineProxy.Execute($"ba w{length} {address:X}");
 }
Beispiel #18
0
        /// <summary>
        ///     Di
        /// </summary>
        /// <param name="numInstructions">The number instructions.</param>
        /// <returns>IEnumerable&lt;DisassemblyLine&gt;.</returns>
        public IEnumerable <DisassemblyLine> GetDisassemblyLines(int numInstructions)
        {
            var threadId = DebugEngineProxy.GetCurrentThreadId();

            return(GetDisassemblyLines(threadId, numInstructions));
        }
Beispiel #19
0
        /// <summary>
        ///     Gets the registers.
        /// </summary>
        /// <param name="threadId">The thread identifier.</param>
        /// <param name="registers">The registers.</param>
        /// <returns>RegisterSet.</returns>
        public RegisterSet GetCurrentRegisterSet(int threadId, IEnumerable <Register> registers)
        {
            var registerSet = new RegisterSet();

            foreach (var register in registers)
            {
                var bytes = DebugEngineProxy.GetRegisterValue(threadId, register);
                if (register == Register.Af)
                {
                    registerSet.Af = Convert.ToBoolean(bytes[0]);
                }
                else if (register == Register.Ah)
                {
                    registerSet.Ah = bytes[0];
                }
                else if (register == Register.Al)
                {
                    registerSet.Al = bytes[0];
                }
                else if (register == Register.Ax)
                {
                    registerSet.Ax = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Bh)
                {
                    registerSet.Bh = bytes[0];
                }
                else if (register == Register.Bl)
                {
                    registerSet.Bl = bytes[0];
                }
                else if (register == Register.Bp)
                {
                    registerSet.Bp = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Bpl)
                {
                    registerSet.Bpl = bytes[0];
                }
                else if (register == Register.Brfrom)
                {
                    registerSet.Brfrom = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Brto)
                {
                    registerSet.Brto = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Bx)
                {
                    registerSet.Bx = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Cf)
                {
                    registerSet.Cf = Convert.ToBoolean(bytes[0]);
                }
                else if (register == Register.Ch)
                {
                    registerSet.Ch = bytes[0];
                }
                else if (register == Register.Cl)
                {
                    registerSet.Cl = bytes[0];
                }
                else if (register == Register.Cs)
                {
                    registerSet.Cs = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Cx)
                {
                    registerSet.Cx = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Df)
                {
                    registerSet.Df = Convert.ToBoolean(bytes[0]);
                }
                else if (register == Register.Dh)
                {
                    registerSet.Dh = bytes[0];
                }
                else if (register == Register.Di)
                {
                    registerSet.Di = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Dil)
                {
                    registerSet.Dil = bytes[0];
                }
                else if (register == Register.Dl)
                {
                    registerSet.Dl = bytes[0];
                }
                else if (register == Register.Dr0)
                {
                    registerSet.Dr0 = DebugEngineProxy.Is32Bit
                        ? BitConverter.ToUInt32(bytes, 0)
                        : BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Dr1)
                {
                    registerSet.Dr1 = DebugEngineProxy.Is32Bit
                        ? BitConverter.ToUInt32(bytes, 0)
                        : BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Dr2)
                {
                    registerSet.Dr2 = DebugEngineProxy.Is32Bit
                        ? BitConverter.ToUInt32(bytes, 0)
                        : BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Dr3)
                {
                    registerSet.Dr3 = DebugEngineProxy.Is32Bit
                        ? BitConverter.ToUInt32(bytes, 0)
                        : BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Dr6)
                {
                    registerSet.Dr6 = DebugEngineProxy.Is32Bit
                        ? BitConverter.ToUInt32(bytes, 0)
                        : BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Dr7)
                {
                    registerSet.Dr7 = DebugEngineProxy.Is32Bit
                        ? BitConverter.ToUInt32(bytes, 0)
                        : BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Ds)
                {
                    registerSet.Ds = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Dx)
                {
                    registerSet.Dx = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Eax)
                {
                    registerSet.Eax = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Ebp)
                {
                    registerSet.Ebp = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Ebx)
                {
                    registerSet.Ebx = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Ecx)
                {
                    registerSet.Ecx = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Edi)
                {
                    registerSet.Edi = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Edx)
                {
                    registerSet.Edx = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Efl)
                {
                    registerSet.Efl = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Eip)
                {
                    registerSet.Eip = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Es)
                {
                    registerSet.Es = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Esi)
                {
                    registerSet.Esi = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Esp)
                {
                    registerSet.Esp = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Exfrom)
                {
                    registerSet.Exfrom = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Exto)
                {
                    registerSet.Exto = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Fl)
                {
                    registerSet.Fl = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Fopcode)
                {
                    registerSet.Fopcode = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Fpcw)
                {
                    registerSet.Fpcw = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Fpdp)
                {
                    registerSet.Fpdp = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Fpdpsel)
                {
                    registerSet.Fpdpsel = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Fpip)
                {
                    registerSet.Fpip = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Fpipsel)
                {
                    registerSet.Fpipsel = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Fpsw)
                {
                    registerSet.Fpsw = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Fptw)
                {
                    registerSet.Fptw = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Fs)
                {
                    registerSet.Fs = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Gs)
                {
                    registerSet.Gs = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.If)
                {
                    registerSet.If = Convert.ToBoolean(bytes[0]);
                }
                else if (register == Register.Iopl)
                {
                    registerSet.Iopl = bytes[0];
                }
                else if (register == Register.Ip)
                {
                    registerSet.Ip = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Mm0)
                {
                    registerSet.Mm0 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Mm1)
                {
                    registerSet.Mm1 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Mm2)
                {
                    registerSet.Mm2 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Mm3)
                {
                    registerSet.Mm3 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Mm4)
                {
                    registerSet.Mm4 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Mm5)
                {
                    registerSet.Mm5 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Mm6)
                {
                    registerSet.Mm6 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Mm7)
                {
                    registerSet.Mm7 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Mxcsr)
                {
                    registerSet.Mxcsr = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.Of)
                {
                    registerSet.Of = Convert.ToBoolean(bytes[0]);
                }
                else if (register == Register.Pf)
                {
                    registerSet.Pf = Convert.ToBoolean(bytes[0]);
                }
                else if (register == Register.R10)
                {
                    registerSet.R10 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.R10b)
                {
                    registerSet.R10b = bytes[0];
                }
                else if (register == Register.R10d)
                {
                    registerSet.R10d = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.R10w)
                {
                    registerSet.R10w = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.R11)
                {
                    registerSet.R11 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.R11b)
                {
                    registerSet.R11b = bytes[0];
                }
                else if (register == Register.R11d)
                {
                    registerSet.R11d = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.R11w)
                {
                    registerSet.R11w = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.R12)
                {
                    registerSet.R12 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.R12b)
                {
                    registerSet.R12b = bytes[0];
                }
                else if (register == Register.R12d)
                {
                    registerSet.R12d = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.R12w)
                {
                    registerSet.R12w = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.R13)
                {
                    registerSet.R13 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.R13b)
                {
                    registerSet.R13b = bytes[0];
                }
                else if (register == Register.R13d)
                {
                    registerSet.R13d = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.R13w)
                {
                    registerSet.R13w = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.R14)
                {
                    registerSet.R14 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.R14b)
                {
                    registerSet.R14b = bytes[0];
                }
                else if (register == Register.R14d)
                {
                    registerSet.R14d = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.R14w)
                {
                    registerSet.R14w = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.R15)
                {
                    registerSet.R15 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.R15b)
                {
                    registerSet.R15b = bytes[0];
                }
                else if (register == Register.R15d)
                {
                    registerSet.R15d = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.R15w)
                {
                    registerSet.R15w = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.R8)
                {
                    registerSet.R8 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.R8b)
                {
                    registerSet.R8b = bytes[0];
                }
                else if (register == Register.R8d)
                {
                    registerSet.R8d = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.R8w)
                {
                    registerSet.R8w = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.R9)
                {
                    registerSet.R9 = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.R9b)
                {
                    registerSet.R9b = bytes[0];
                }
                else if (register == Register.R9d)
                {
                    registerSet.R9d = BitConverter.ToUInt32(bytes, 0);
                }
                else if (register == Register.R9w)
                {
                    registerSet.R9w = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Rax)
                {
                    registerSet.Rax = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Rbp)
                {
                    registerSet.Rbp = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Rbx)
                {
                    registerSet.Rbx = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Rcx)
                {
                    registerSet.Rcx = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Rdi)
                {
                    registerSet.Rdi = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Rdx)
                {
                    registerSet.Rdx = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Rip)
                {
                    registerSet.Rip = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Rsi)
                {
                    registerSet.Rsi = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Rsp)
                {
                    registerSet.Rsp = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Sf)
                {
                    registerSet.Sf = Convert.ToBoolean(bytes[0]);
                }
                else if (register == Register.Si)
                {
                    registerSet.Si = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Sil)
                {
                    registerSet.Sil = bytes[0];
                }
                else if (register == Register.Sp)
                {
                    registerSet.Sp = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.Spl)
                {
                    registerSet.Spl = bytes[0];
                }
                else if (register == Register.Ss)
                {
                    registerSet.Ss = BitConverter.ToUInt16(bytes, 0);
                }
                else if (register == Register.St0)
                {
                    registerSet.St0 = bytes.Take(10).ToArray();
                }
                else if (register == Register.St1)
                {
                    registerSet.St1 = bytes.Take(10).ToArray();
                }
                else if (register == Register.St2)
                {
                    registerSet.St2 = bytes.Take(10).ToArray();
                }
                else if (register == Register.St3)
                {
                    registerSet.St3 = bytes.Take(10).ToArray();
                }
                else if (register == Register.St4)
                {
                    registerSet.St4 = bytes.Take(10).ToArray();
                }
                else if (register == Register.St5)
                {
                    registerSet.St5 = bytes.Take(10).ToArray();
                }
                else if (register == Register.St6)
                {
                    registerSet.St6 = bytes.Take(10).ToArray();
                }
                else if (register == Register.St7)
                {
                    registerSet.St7 = bytes.Take(10).ToArray();
                }
                else if (register == Register.Tf)
                {
                    registerSet.Tf = Convert.ToBoolean(bytes[0]);
                }
                else if (register == Register.Vif)
                {
                    registerSet.Vif = Convert.ToBoolean(bytes[0]);
                }
                else if (register == Register.Vip)
                {
                    registerSet.Vip = Convert.ToBoolean(bytes[0]);
                }
                else if (register == Register.Xmm0)
                {
                    registerSet.Xmm0 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm0h)
                {
                    registerSet.Xmm0h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm0l)
                {
                    registerSet.Xmm0l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm1)
                {
                    registerSet.Xmm1 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm10)
                {
                    registerSet.Xmm10 = bytes.Take(16).ToArray();
                }

                else if (register == Register.Xmm10h)
                {
                    registerSet.Xmm10h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm10l)
                {
                    registerSet.Xmm10l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm11)
                {
                    registerSet.Xmm11 = bytes.Take(16).ToArray();
                    ;
                }
                else if (register == Register.Xmm11h)
                {
                    registerSet.Xmm11h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm11l)
                {
                    registerSet.Xmm11l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm12)
                {
                    registerSet.Xmm12 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm12h)
                {
                    registerSet.Xmm12h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm12l)
                {
                    registerSet.Xmm12l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm13)
                {
                    registerSet.Xmm13 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm13h)
                {
                    registerSet.Xmm13h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm13l)
                {
                    registerSet.Xmm13l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm14)
                {
                    registerSet.Xmm14 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm14h)
                {
                    registerSet.Xmm14h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm14l)
                {
                    registerSet.Xmm14l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm15)
                {
                    registerSet.Xmm15 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm15h)
                {
                    registerSet.Xmm15h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm15l)
                {
                    registerSet.Xmm15l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm1h)
                {
                    registerSet.Xmm1h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm1l)
                {
                    registerSet.Xmm1l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm2)
                {
                    registerSet.Xmm2 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm2h)
                {
                    registerSet.Xmm2h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm2l)
                {
                    registerSet.Xmm2l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm3)
                {
                    registerSet.Xmm3 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm3h)
                {
                    registerSet.Xmm3h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm3l)
                {
                    registerSet.Xmm3l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm4)
                {
                    registerSet.Xmm4 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm4h)
                {
                    registerSet.Xmm4h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm4l)
                {
                    registerSet.Xmm4l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm5)
                {
                    registerSet.Xmm5 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm5h)
                {
                    registerSet.Xmm5h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm5l)
                {
                    registerSet.Xmm5l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm6)
                {
                    registerSet.Xmm6 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm6h)
                {
                    registerSet.Xmm6h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm6l)
                {
                    registerSet.Xmm6l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm7)
                {
                    registerSet.Xmm7 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm7h)
                {
                    registerSet.Xmm7h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm7l)
                {
                    registerSet.Xmm7l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm8)
                {
                    registerSet.Xmm8 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm8h)
                {
                    registerSet.Xmm8h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm8l)
                {
                    registerSet.Xmm8l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm9)
                {
                    registerSet.Xmm9 = bytes.Take(16).ToArray();
                }
                else if (register == Register.Xmm9h)
                {
                    registerSet.Xmm9h = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Xmm9l)
                {
                    registerSet.Xmm9l = BitConverter.ToUInt64(bytes, 0);
                }
                else if (register == Register.Ymm0)
                {
                    registerSet.Ymm0 = bytes;
                }
                else if (register == Register.Ymm0h)
                {
                    registerSet.Ymm0h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm0l)
                {
                    registerSet.Ymm0l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm1)
                {
                    registerSet.Ymm1 = bytes;
                }
                else if (register == Register.Ymm10)
                {
                    registerSet.Ymm10 = bytes;
                }
                else if (register == Register.Ymm10h)
                {
                    registerSet.Ymm10h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm10l)
                {
                    registerSet.Ymm10l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm11)
                {
                    registerSet.Ymm11 = bytes;
                }
                else if (register == Register.Ymm11h)
                {
                    registerSet.Ymm11h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm11l)
                {
                    registerSet.Ymm11l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm12)
                {
                    registerSet.Ymm12 = bytes;
                }
                else if (register == Register.Ymm12h)
                {
                    registerSet.Ymm12h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm12l)
                {
                    registerSet.Ymm12l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm13)
                {
                    registerSet.Ymm13 = bytes;
                }
                else if (register == Register.Ymm13h)
                {
                    registerSet.Ymm13h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm13l)
                {
                    registerSet.Ymm13l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm14)
                {
                    registerSet.Ymm14 = bytes;
                }
                else if (register == Register.Ymm14h)
                {
                    registerSet.Ymm14h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm14l)
                {
                    registerSet.Ymm14l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm15)
                {
                    registerSet.Ymm15 = bytes;
                }
                else if (register == Register.Ymm15h)
                {
                    registerSet.Ymm15h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm15l)
                {
                    registerSet.Ymm15l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm1h)
                {
                    registerSet.Ymm1h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm1l)
                {
                    registerSet.Ymm1l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm2)
                {
                    registerSet.Ymm2 = bytes;
                }
                else if (register == Register.Ymm2h)
                {
                    registerSet.Ymm2h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm2l)
                {
                    registerSet.Ymm2l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm3)
                {
                    registerSet.Ymm3 = bytes;
                }
                else if (register == Register.Ymm3h)
                {
                    registerSet.Ymm3h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm3l)
                {
                    registerSet.Ymm3l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm4)
                {
                    registerSet.Ymm4 = bytes;
                }
                else if (register == Register.Ymm4h)
                {
                    registerSet.Ymm4h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm4l)
                {
                    registerSet.Ymm4l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm5)
                {
                    registerSet.Ymm5 = bytes;
                }
                else if (register == Register.Ymm5h)
                {
                    registerSet.Ymm5h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm5l)
                {
                    registerSet.Ymm5l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm6)
                {
                    registerSet.Ymm6 = bytes;
                }
                else if (register == Register.Ymm6h)
                {
                    registerSet.Ymm6h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm6l)
                {
                    registerSet.Ymm6l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm7)
                {
                    registerSet.Ymm7 = bytes;
                }
                else if (register == Register.Ymm7h)
                {
                    registerSet.Ymm7h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm7l)
                {
                    registerSet.Ymm7l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm8)
                {
                    registerSet.Ymm8 = bytes;
                }
                else if (register == Register.Ymm8h)
                {
                    registerSet.Ymm8h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm8l)
                {
                    registerSet.Ymm8l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm9)
                {
                    registerSet.Ymm9 = bytes;
                }
                else if (register == Register.Ymm9h)
                {
                    registerSet.Ymm9h = bytes.Take(16).ToArray();
                }
                else if (register == Register.Ymm9l)
                {
                    registerSet.Ymm9l = bytes.Take(16).ToArray();
                }
                else if (register == Register.Zf)
                {
                    registerSet.Zf = Convert.ToBoolean(bytes[0]);
                }
            }

            return(registerSet);
        }
Beispiel #20
0
 /// <summary>
 ///     Clears the breakpoints.
 /// </summary>
 public void ClearBreakpoints()
 {
     DebugEngineProxy.Execute($"bc *");
 }
Beispiel #21
0
 /// <summary>
 ///     Gets the current register set.
 /// </summary>
 /// <param name="registers">The registers.</param>
 /// <returns>RegisterSet.</returns>
 public RegisterSet GetCurrentRegisterSet(IEnumerable <Register> registers)
 {
     return(GetCurrentRegisterSet(DebugEngineProxy.GetCurrentThreadId(), registers));
 }
Beispiel #22
0
 /// <summary>
 ///     Sets the position.
 /// </summary>
 /// <param name="position">The position.</param>
 public void SetPosition(Position position)
 {
     DebugEngineProxy.Execute($"!tt {position}");
 }