Added basic debugger.

Author: KN4CK3R

Debugger/HardwareBreakpoint.cs

@@ -0,0 +1,78 @@
+using System;
+using ReClassNET.Memory;
+
+namespace ReClassNET.Debugger
+{
+	public enum HardwareBreakpointRegister
+	{
+		InvalidRegister,
+
+		Dr0,
+		Dr1,
+		Dr2,
+		Dr3
+	}
+
+	public enum HardwareBreakpointType
+	{
+		Access,
+		ReadWrite,
+		Write,
+	}
+
+	public enum HardwareBreakpointSize
+	{
+		Size1,
+		Size2,
+		Size4,
+		Size8
+	}
+
+	public sealed class HardwareBreakpoint : IBreakpoint
+	{
+		public IntPtr Address { get; }
+		public HardwareBreakpointRegister Register { get; }
+		public HardwareBreakpointType Type { get; }
+		public HardwareBreakpointSize Size { get; }
+
+		public HardwareBreakpoint(IntPtr address, HardwareBreakpointRegister register, HardwareBreakpointType type, HardwareBreakpointSize size)
+		{
+			if (register == HardwareBreakpointRegister.InvalidRegister)
+			{
+				throw new InvalidOperationException();
+			}
+
+			Address = address;
+			Register = register;
+			Type = type;
+			Size = size;
+		}
+
+		public bool Set(RemoteProcess process)
+		{
+			return process.NativeHelper.DebuggerSetHardwareBreakpoint(process.UnderlayingProcess.Id, this, true);
+		}
+
+		public void Remove(RemoteProcess process)
+		{
+			process.NativeHelper.DebuggerSetHardwareBreakpoint(process.UnderlayingProcess.Id, this, false);
+		}
+
+		public override bool Equals(object obj)
+		{
+			var hwbp = obj as HardwareBreakpoint;
+			if (hwbp == null)
+			{
+				return false;
+			}
+
+			// Two hardware breakpoints are equal if the address and type are equal.
+			return Address == hwbp.Address && Type == hwbp.Type;
+		}
+
+		public override int GetHashCode()
+		{
+			return (Address.GetHashCode() * 17) ^ Type.GetHashCode();
+		}
+	}
+}

Debugger/IBreakpoint.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Diagnostics.Contracts;
+using ReClassNET.Memory;
+
+namespace ReClassNET.Debugger
+{
+	public interface IBreakpoint
+	{
+		IntPtr Address { get; }
+
+		bool Set(RemoteProcess process);
+		void Remove(RemoteProcess process);
+	}
+
+	[ContractClassFor(typeof(IBreakpoint))]
+	internal abstract class IBreakpointContract : IBreakpoint
+	{
+		public IntPtr Address
+		{
+			get
+			{
+				throw new NotImplementedException();
+			}
+		}
+
+		public void Remove(RemoteProcess process)
+		{
+			Contract.Requires(process != null);
+
+			throw new NotImplementedException();
+		}
+
+		public bool Set(RemoteProcess process)
+		{
+			Contract.Requires(process != null);
+
+			throw new NotImplementedException();
+		}
+	}
+}

Debugger/RemoteDebugger.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using ReClassNET.Memory;
+using ReClassNET.Native;
+
+namespace ReClassNET.Debugger
+{
+	public class RemoteDebugger
+	{
+		private readonly object sync = new object();
+
+		private readonly RemoteProcess process;
+
+		private readonly HashSet<IBreakpoint> breakpoints = new HashSet<IBreakpoint>();
+
+		public bool IsAttached { get; private set; }
+
+		public RemoteDebugger(RemoteProcess process)
+		{
+			Contract.Requires(process != null);
+
+			this.process = process;
+		}
+
+		public bool Attach()
+		{
+			if (!process.IsValid)
+			{
+				return false;
+			}
+
+			lock (sync)
+			{
+				if (IsAttached)
+				{
+					throw new InvalidOperationException();
+				}
+
+				IsAttached = process.NativeHelper.DebuggerAttachToProcess(process.UnderlayingProcess.Id);
+
+				return IsAttached;
+			}
+		}
+
+		public void Detach()
+		{
+			lock (sync)
+			{
+				if (!IsAttached)
+				{
+					return;
+				}
+
+				foreach (var bp in breakpoints)
+				{
+					bp.Remove(process);
+				}
+				breakpoints.Clear();
+
+				process.NativeHelper.DebuggerDetachFromProcess(process.UnderlayingProcess.Id);
+
+				IsAttached = false;
+			}
+		}
+
+		public bool WaitForDebugEvent(ref DebugEvent e)
+		{
+			return process.NativeHelper.DebuggerWaitForDebugEvent(ref e);
+		}
+
+		public void ContinueEvent(ref DebugEvent e)
+		{
+			process.NativeHelper.DebuggerContinueEvent(ref e);
+		}
+
+		public bool SetBreakpoint(IBreakpoint bp)
+		{
+			Contract.Requires(bp != null);
+
+			lock (sync)
+			{
+				if (!breakpoints.Add(bp))
+				{
+					return false;
+				}
+
+				bp.Set(process);
+			}
+
+			return true;
+		}
+
+		public void RemoveBreakpoint(IBreakpoint bp)
+		{
+			Contract.Requires(bp != null);
+
+			lock (sync)
+			{
+				if (breakpoints.Remove(bp))
+				{
+					bp.Remove(process);
+				}
+			}
+		}
+	}
+}

Debugger/SoftwareBreakpoint.cs

@@ -0,0 +1,50 @@
+using System;
+using ReClassNET.Memory;
+
+namespace ReClassNET.Debugger
+{
+	public sealed class SoftwareBreakpoint : IBreakpoint
+	{
+		public IntPtr Address { get; }
+
+		private byte orig;
+
+		public SoftwareBreakpoint(IntPtr address)
+		{
+			Address = address;
+		}
+
+		public bool Set(RemoteProcess process)
+		{
+			var temp = new byte[1];
+			if (!process.ReadRemoteMemoryIntoBuffer(Address, ref temp))
+			{
+				return false;
+			}
+			orig = temp[0];
+
+			return process.WriteRemoteMemory(Address, new byte[] { 0xCC });
+		}
+
+		public void Remove(RemoteProcess process)
+		{
+			process.WriteRemoteMemory(Address, new byte[] { orig });
+		}
+
+		public override bool Equals(object obj)
+		{
+			var bp = obj as SoftwareBreakpoint;
+			if (bp == null)
+			{
+				return false;
+			}
+
+			return Address == bp.Address;
+		}
+
+		public override int GetHashCode()
+		{
+			return Address.GetHashCode();
+		}
+	}
+}

Memory/RemoteProcess.cs

@@ -8,25 +8,22 @@
 using System.Threading;
 using System.Threading.Tasks;
 using ReClassNET.AddressParser;
+using ReClassNET.Debugger;
 using ReClassNET.Native;
 using ReClassNET.Symbols;
 using ReClassNET.Util;
 
 namespace ReClassNET.Memory
 {
+	public delegate void UnderlayingProcessChangedEvent(RemoteProcess sender);
+
 	public class RemoteProcess : IDisposable
 	{
 		private readonly object processSync = new object();
 
 		private readonly NativeHelper nativeHelper;
-		public NativeHelper NativeHelper => nativeHelper;
 
-		private ProcessInfo process;
-		private IntPtr handle;
-		public ProcessInfo UnderlayingProcess => process;
-
-		public delegate void RemoteProcessChangedEvent(RemoteProcess sender);
-		public event RemoteProcessChangedEvent ProcessChanged;
+		private readonly RemoteDebugger debugger;
 
 		private readonly Dictionary<IntPtr, string> rttiCache = new Dictionary<IntPtr, string>();
 
@@ -35,6 +32,18 @@ public class RemoteProcess : IDisposable
 		private readonly List<Section> sections = new List<Section>();
 
 		private readonly SymbolStore symbols = new SymbolStore();
+
+		private ProcessInfo process;
+		private IntPtr handle;
+
+		public event UnderlayingProcessChangedEvent ProcessChanged;
+
+		public NativeHelper NativeHelper => nativeHelper;
+
+		public RemoteDebugger Debugger => debugger;
+
+		public ProcessInfo UnderlayingProcess => process;
+
 		public SymbolStore Symbols => symbols;
 
 		public bool IsValid => process != null && nativeHelper.IsProcessValid(handle);
@@ -44,13 +53,17 @@ public RemoteProcess(NativeHelper nativeHelper)
 			Contract.Requires(nativeHelper != null);
 
 			this.nativeHelper = nativeHelper;
+
+			debugger = new RemoteDebugger(this);
 		}
 
 		public void Dispose()
 		{
 			Close();
 		}
 
+		/// <summary>Opens the given process to gather informations from.</summary>
+		/// <param name="info">The process information.</param>
 		public void Open(ProcessInfo info)
 		{
 			Contract.Requires(info != null);
@@ -72,13 +85,14 @@ public void Open(ProcessInfo info)
 			}
 		}
 
+		/// <summary>Closes the underlaying process. If the debugger is attached, it will automaticly detached.</summary>
 		public void Close()
 		{
 			if (process != null)
 			{
 				lock (processSync)
 				{
-					//detach debugger, remove breakpoints
+					debugger.Detach();
 
 					nativeHelper.CloseRemoteProcess(handle);