public void Execute(IDebuggerSession session, string[] arguments, Logger output)
{
var process = session.GetProcesses().First();
if (process != _process)
{
_process = process;
_reader = new ProcessMemoryReader(process)
{
NegateBreakpoints = true
};
_disassembler = new X86Disassembler(_reader);
}
if (arguments.Length > 0)
{
_reader.Position = long.Parse(arguments[0], NumberStyles.HexNumber);
}
int count = 5;
if (arguments.Length > 1)
{
count = int.Parse(arguments[1]);
}
for (int i = 0; i < count; i++)
{
var instruction = _disassembler.ReadNextInstruction();
_printer.PrintInstruction(instruction, process.GetSoftwareBreakpointByAddress((IntPtr)instruction.Offset));
}
}
public void Execute(IDebuggerSession session, string[] arguments, Logger output)
{
foreach (var lib in session.GetProcesses().First().Libraries)
{
output.WriteLine("{0:X8}: {1}", lib.BaseOfLibrary.ToInt64(), (lib.Name ?? "<no name>"));
}
}
public void Execute(IDebuggerSession session, string[] arguments, Logger output)
{
foreach (var process in session.GetProcesses())
{
process.Break();
}
}
public void Execute(IDebuggerSession session, string[] arguments, Logger output)
{
if (arguments.Length < 2)
{
throw new ArgumentException("Not enough arguments.");
}
ulong address = ulong.Parse(arguments[1], NumberStyles.HexNumber, CultureInfo.InvariantCulture);
var debuggeeProcess = session.GetProcesses().First();
switch (arguments[0].ToLowerInvariant())
{
case "set":
debuggeeProcess.SetSoftwareBreakpoint((IntPtr)address);
break;
case "remove":
debuggeeProcess.RemoveSoftwareBreakpoint(
debuggeeProcess.GetSoftwareBreakpointByAddress((IntPtr)address));
break;
case "enable":
debuggeeProcess.GetSoftwareBreakpointByAddress((IntPtr)address).Enabled = true;
break;
case "disable":
debuggeeProcess.GetSoftwareBreakpointByAddress((IntPtr)address).Enabled = false;
break;
default:
throw new ArgumentOutOfRangeException("Invalid switch " + arguments[1]);
}
}
public void Execute(IDebuggerSession session, string[] arguments, Logger output)
{
output.WriteLine("Software Breakpoints:");
foreach (var breakpoint in session.GetProcesses().SelectMany(x => x.GetSoftwareBreakpoints()))
{
output.WriteLine("- {0:X8} : {1}", breakpoint.Address.ToInt64(),
breakpoint.Enabled ? "Enabled" : "Disabled");
}
output.WriteLine("Memory Breakpoints:");
foreach (var breakpoint in session.GetProcesses().SelectMany(x => x.GetMemoryBreakpoints()))
{
output.WriteLine("- {0:X8} : {1}", breakpoint.Address.ToInt64(),
breakpoint.Enabled ? "Enabled" : "Disabled");
}
}
public void Execute(IDebuggerSession session, string[] arguments, Logger output)
{
foreach (var thread in session.GetProcesses().First().Threads)
{
output.WriteLine("{0}: {1:X8}", thread.Id, thread.StartAddress.ToInt64());
}
}
public void Execute(IDebuggerSession session, string[] arguments, Logger output)
{
foreach (var process in session.GetProcesses())
{
process.Terminate();
}
session.StartProcess(new DebuggerProcessStartInfo
{
CommandLine = string.Join(" ", CommandLineArgs)
});
}
public void Execute(IDebuggerSession session, string[] arguments, Logger output)
{
var process = session.GetProcesses().First();
if (arguments.Length < 1)
{
throw new ArgumentException("Expected address.");
}
if (arguments.Length < 2)
{
throw new ArgumentException("Expected value size.");
}
if (arguments.Length < 3)
{
throw new ArgumentException("Expected at least one value to write.");
}
ulong address = ulong.Parse(arguments[0], NumberStyles.HexNumber, CultureInfo.InvariantCulture);
int size = 1;
switch (arguments[1].ToLowerInvariant())
{
case "b":
size = 1;
break;
case "w":
size = 2;
break;
case "dw":
size = 4;
break;
default:
throw new ArgumentOutOfRangeException("Invalid switch " + arguments[1]);
}
var buffer = new byte[(arguments.Length - 2) * size];
for (int i = 0; i < arguments.Length - 2; i++)
{
ulong currentValue = ulong.Parse(arguments[i + 2], NumberStyles.HexNumber, CultureInfo.InvariantCulture);
var bytes = BitConverter.GetBytes(currentValue);
Buffer.BlockCopy(bytes, 0, buffer, i * size, size);
}
process.WriteMemory((IntPtr)address, buffer, 0, buffer.Length);
}
public void Execute(IDebuggerSession session, string[] arguments, Logger output)
{
if (arguments.Length == 0)
{
throw new ArgumentException("Expected address.");
}
ulong address = ulong.Parse(arguments[0], NumberStyles.HexNumber, CultureInfo.InvariantCulture);
var size = X86OperandSize.Byte;
if (arguments.Length > 1)
{
switch (arguments[1].ToLowerInvariant())
{
case "b":
size = X86OperandSize.Byte;
break;
case "w":
size = X86OperandSize.Word;
break;
case "dw":
size = X86OperandSize.Dword;
break;
default:
throw new ArgumentOutOfRangeException("Invalid switch " + arguments[1]);
}
}
var process = session.GetProcesses().First();
DumpMemory(process, address, 5, size, output);
}