Recent changes to LearnCore

LearnCore modified by vinicius.ras

vinicius.ras — Thu, 19 Jan 2017 19:52:43 -0000

--- v11
+++ v12
@@ -76,7 +76,7 @@
 To reference memory addresses in the target process' memory space, you can use the following specializations for the **[MemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_memory_address.html)** class:

 * **[AbsoluteMemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_absolute_memory_address.html)**: used to represent absolute/static/constant addresses.
-* **[ModuleOffsetMemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_module_offset_memory_address.html)**: used to represent addresses that are calculated as offsets from a given module of the process to which the **[RAMvaderTarget9(http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** is attached.
+* **[ModuleOffsetMemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_module_offset_memory_address.html)**: used to represent addresses that are calculated as offsets from a given module of the process to which the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** is attached.
 * **[InjectedCodeCaveMemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_injected_code_cave_memory_address.html)**: used to represent addresses of code caves that get injected by the **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** into a target process' memory space.
 * **[InjectedVariableMemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_injected_variable_memory_address.html)**: used to represent addresses of injection variables that get injected by the **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** into a target process' memory space.

LearnCore modified by vinicius.ras

vinicius.ras — Thu, 19 Jan 2017 19:44:12 -0000

--- v10
+++ v11
@@ -56,6 +56,7 @@
 You might check if a **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance is attached to a process by calling the "**[IsAttached()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#a75f84b09700d7c2cce4860eef06c726d)**" method, which returns a flag indicating if the instance is currently attached to a process. You might also retrieve the **Process** object, corresponding to the attached process, by calling "**[GetAttachedProcess()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#a257761fc8a4ff66d0cf5560edc967504)**". This last method might return a *null* value, if the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance is currently not attached to any Process.

 # Memory I/O operations #
+### Methods to read from / write to target process' memory space ###

 After attaching a **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance to a target Process, you can perform reading and writing operations to its memory. This is done by the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ab8d75cf10157b3d246735a018bce7545)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa5fc5ea1fa96d3616f339af10c6a75cf)**" methods. Both methods...:

@@ -66,12 +67,31 @@

 You should read the API documentation for the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ab8d75cf10157b3d246735a018bce7545)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa5fc5ea1fa96d3616f339af10c6a75cf)**" method overloads and know them well, as these are probably the most important methods of the library - they are the core of the library's main operations. Notice that for the reading methods, with the exception of the byte-array-based overload, you have to pass references to the variables which will receive the data. So, don't forget to add the *ref* keyword to those calls.

+### Memory addresses in target process' memory space ###
+
+When you start using the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ab8d75cf10157b3d246735a018bce7545)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa5fc5ea1fa96d3616f339af10c6a75cf)**" methods, you will realize that both methods receive a parameter of the **[MemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_memory_address.html)** type. This is an abstract class which represents a memory address in the target process' memory space.
+
+The **RAMvader** library provides specializations for that class which make it easier for you to reference addresses on the target process' memory space, including addresses that are "managed" by the **RAMvader** library, such as the addresses of injected variables and code caves. All you need is to use the right specialization of the **[MemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_memory_address.html)** class to reference the right address. The library will take care of complex things like calculating the address where a variable has been injected, calculating an address relative to a module on the target process' memory space, etc.
+
+To reference memory addresses in the target process' memory space, you can use the following specializations for the **[MemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_memory_address.html)** class:
+
+* **[AbsoluteMemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_absolute_memory_address.html)**: used to represent absolute/static/constant addresses.
+* **[ModuleOffsetMemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_module_offset_memory_address.html)**: used to represent addresses that are calculated as offsets from a given module of the process to which the **[RAMvaderTarget9(http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** is attached.
+* **[InjectedCodeCaveMemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_injected_code_cave_memory_address.html)**: used to represent addresses of code caves that get injected by the **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** into a target process' memory space.
+* **[InjectedVariableMemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_injected_variable_memory_address.html)**: used to represent addresses of injection variables that get injected by the **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** into a target process' memory space.
+
+All of these classes have implemented the **[MemoryAddress.GetRealAddress()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_memory_address.html#a3e2f7fa03ff4755a95d359e22e4e5081)** method with the corresponding logic that is used for calculating the address they correspond to in the target process' memory space. Notice that some of these specializations might throw exceptions if this method is called at a time where this logic is not ready to be performed.
+
+The **[ModuleOffsetMemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_module_offset_memory_address.html)** require a **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** object to be attached to a valid process in order to obtain the list of modules for that process and calculate the address. Both the **[InjectedCodeCaveMemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_injected_code_cave_memory_address.html)** and **[InjectedVariableMemoryAddress](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_injected_variable_memory_address.html)** classes can only call the **[MemoryAddress.GetRealAddress()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_memory_address.html#a3e2f7fa03ff4755a95d359e22e4e5081)** method if the **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** has already injected the variables/code caves into the target process' memory space, or **during** the injection process.
+
+### Examples of read/write operations on target process' memory space ###
+
 The following are examples of usage of reading and writing methods. For the sake of simplicity and code readability, we are not checking the bool values returned by these methods (we strongly recommend you to test them to see if the read/write operation has failed!). Also, consider the variables named **myTarget** as instances of the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** class, which are already attached to a target **Process**:

 ~~~~~~
 // Read a Single (a.k.a. "float") value from address 0xAABBCCDD
 // and store it in the variable "myVar".
-IntPtr targetAddr = new IntPtr( 0xAABBCCDD );
+MemoryAddress targetAddr = new AbsoluteMemoryAddress( 0xAABBCCDD );
 Single myVar;   // this variable will store the read value
 myTarget.ReadFromTarget( targetAddr, ref myVar );

@@ -79,13 +99,13 @@
 // Write an unsigned 64-bits integer with value 123 to 0xBABACA0
 UInt64 dataToWrite = 123;   // stores the data that will be written
                             // to the target Process' memory
-IntPtr targetAddr = new IntPtr( 0xBABACA0 );
+IntPtr targetAddr = new IntPtr( new AbsoluteMemoryAddress( 0xBABACA0 ) );
 myTarget.WriteToTarget( targetAddr, dataToWrite );

 // Read an 32-bit integer from the address 0xF000BA22
 // Then, multiply it by two, and store it back into this same address
-IntPtr targetAddr = new IntPtr( 0xF000BA22 );
+MemoryAddress targetAddr = new AbsoluteMemoryAddress( 0xF000BA22 );
 Int32 myVar;
 myTarget.ReadFromTarget( targetAddr, ref myVar );

@@ -95,10 +115,16 @@

 // Read a sequence of 7 bytes of memory from 0x71727374
 byte [] myBuffer = new byte[7];
-myTarget.ReadFromTarget( new IntPtr( 0x71727374 ), myBuffer );
+myTarget.ReadFromTarget( new AbsoluteMemoryAddress( 0x71727374 ), myBuffer );

 // Write 3 bytes of memory to 0x80808080
 byte [] myBuffer = new byte[] { 10, 20, 30 };
-myTarget.WriteToTarget( new IntPtr( 0x80808080 ), myBuffer );
+myTarget.WriteToTarget( new AbsoluteMemoryAddress( 0x80808080 ), myBuffer );
+
+
+// Write an integer to the address with an offset of +0xABC
+// from an imaginary game's main module
+int myIntVar = 123;
+myTarget.WriteToTarget( new ModuleOffsetMemoryAddress( myTarget, "CoolImaginaryMainModule.exe", 0xABC ), myBuffer );
 ~~~~~~

LearnCore modified by vinicius.ras

vinicius.ras — Thu, 19 Jan 2017 18:27:16 -0000

--- v9
+++ v10
@@ -57,7 +57,7 @@

 # Memory I/O operations #

-After attaching a **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance to a target Process, you can perform reading and writing operations to its memory. This is done by the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ab8d75cf10157b3d246735a018bce7545)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ae36611dec9a4e18aca42a876232e6f7f)**" methods. Both methods...:
+After attaching a **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance to a target Process, you can perform reading and writing operations to its memory. This is done by the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ab8d75cf10157b3d246735a018bce7545)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa5fc5ea1fa96d3616f339af10c6a75cf)**" methods. Both methods...:

 * ... have several overloads to work with many basic types of data supported by the library.
 * ... return a bool value, which indicate if the writing/reading operation has been performed with success.

LearnCore modified by vinicius.ras

vinicius.ras — Thu, 19 Jan 2017 18:24:57 -0000

--- v8
+++ v9
@@ -64,7 +64,7 @@
 * ... receive a first parameter of type **IntPtr** which indicate the address, on the target **Process**' memory space, where you want the method to operate.
 * ... have an overload specialized for writing/reading an array of bytes. In fact, all overloads convert other basic types to sequences of bytes and call this specific byte-array-based overload.

-You should read the API documentation for the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa19c33dac4b21ab9582a341bc766d474)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa5fc5ea1fa96d3616f339af10c6a75cf)**" method overloads and know them well, as these are probably the most important methods of the library - they are the core of the library's main operations. Notice that for the reading methods, with the exception of the byte-array-based overload, you have to pass references to the variables which will receive the data. So, don't forget to add the *ref* keyword to those calls.
+You should read the API documentation for the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ab8d75cf10157b3d246735a018bce7545)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa5fc5ea1fa96d3616f339af10c6a75cf)**" method overloads and know them well, as these are probably the most important methods of the library - they are the core of the library's main operations. Notice that for the reading methods, with the exception of the byte-array-based overload, you have to pass references to the variables which will receive the data. So, don't forget to add the *ref* keyword to those calls.

 The following are examples of usage of reading and writing methods. For the sake of simplicity and code readability, we are not checking the bool values returned by these methods (we strongly recommend you to test them to see if the read/write operation has failed!). Also, consider the variables named **myTarget** as instances of the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** class, which are already attached to a target **Process**:

LearnCore modified by vinicius.ras

vinicius.ras — Thu, 19 Jan 2017 18:24:07 -0000

--- v7
+++ v8
@@ -57,14 +57,14 @@

 # Memory I/O operations #

-After attaching a **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance to a target Process, you can perform reading and writing operations to its memory. This is done by the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa19c33dac4b21ab9582a341bc766d474)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ae36611dec9a4e18aca42a876232e6f7f)**" methods. Both methods...:
+After attaching a **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance to a target Process, you can perform reading and writing operations to its memory. This is done by the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ab8d75cf10157b3d246735a018bce7545)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ae36611dec9a4e18aca42a876232e6f7f)**" methods. Both methods...:

 * ... have several overloads to work with many basic types of data supported by the library.
 * ... return a bool value, which indicate if the writing/reading operation has been performed with success.
 * ... receive a first parameter of type **IntPtr** which indicate the address, on the target **Process**' memory space, where you want the method to operate.
 * ... have an overload specialized for writing/reading an array of bytes. In fact, all overloads convert other basic types to sequences of bytes and call this specific byte-array-based overload.

-You should read the API documentation for the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa19c33dac4b21ab9582a341bc766d474)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ae36611dec9a4e18aca42a876232e6f7f)**" method overloads and know them well, as these are probably the most important methods of the library - they are the core of the library's main operations. Notice that for the reading methods, with the exception of the byte-array-based overload, you have to pass references to the variables which will receive the data. So, don't forget to add the *ref* keyword to those calls.
+You should read the API documentation for the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa19c33dac4b21ab9582a341bc766d474)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa5fc5ea1fa96d3616f339af10c6a75cf)**" method overloads and know them well, as these are probably the most important methods of the library - they are the core of the library's main operations. Notice that for the reading methods, with the exception of the byte-array-based overload, you have to pass references to the variables which will receive the data. So, don't forget to add the *ref* keyword to those calls.

 The following are examples of usage of reading and writing methods. For the sake of simplicity and code readability, we are not checking the bool values returned by these methods (we strongly recommend you to test them to see if the read/write operation has failed!). Also, consider the variables named **myTarget** as instances of the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** class, which are already attached to a target **Process**:

LearnCore modified by vinicius.ras

vinicius.ras — Wed, 18 Jan 2017 20:49:51 -0000

--- v6
+++ v7
@@ -9,13 +9,13 @@

 ### The library's architecture ##

-The library classes are contained into the **[RAMvader](http://ramvader.sourceforge.net/API/namespace_r_a_mvader.html)** and **[RAMvader.CodeInjection](http://ramvader.sourceforge.net/API/namespace_r_a_mvader_1_1_code_injection.html)** namespaces. You will usually only need to use the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** and **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** classes, which will be explained in this document.
+The library classes are contained into the **[RAMvader](http://ramvader.sourceforge.net/API/namespace_r_a_mvader.html)** and **[RAMvader.CodeInjection](http://ramvader.sourceforge.net/API/namespace_r_a_mvader_1_1_code_injection.html)** namespaces. The main classes of the library are the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** and **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** classes, which will be explained in this document.

 The **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** class manages a "target", which is really just a process running into the user's local machine, whose memory you have interest in, for performing I/O operations. A single **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance may only handle up to **one** single Process at a time. If your application needs to perform memory operations in more than one single, "external" process at any time, you might instantiate more **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** objects as necessary (one for each process). Currently, **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** objects can be created by using their class' default constructor.

 The **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** contains several features that might be useful to inject binary code and data ("variables", both managed and unmanaged ones) into the target process' memory space. The **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** class is optional. When you use an **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** object, it needs to be associated with a **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** object, as the **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** uses it "under the hood" to perform its injection operations.

-The library has its own Exception-derived classes. All the exceptions thrown by the library's own code derive from the **[RAMvaderException](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_exception.html)** class. Notice, though, that calls to some methods related to the Windows API and to the **Process** class are made inside the library's code, and they might throw their own, standard exceptions to your client code in some cases. An effort will be made in future releases to document the thrown exceptions.
+The library has its own Exception-derived classes. The exceptions thrown by the library's code usually derive from the **[RAMvaderException](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_exception.html)** class. Notice, though, that calls to some methods related to the Windows API and to the **Process** class are made inside the library's code, and they might throw their own, standard exceptions to your client code in some cases. Please, check the API documentation for each method to know which exceptions a specific method throws.

 Now that you know the basic concepts behind the **RAMvader** library's architecture, let's see how we can actually write programs using the **RAMvader** library!

@@ -64,7 +64,7 @@
 * ... receive a first parameter of type **IntPtr** which indicate the address, on the target **Process**' memory space, where you want the method to operate.
 * ... have an overload specialized for writing/reading an array of bytes. In fact, all overloads convert other basic types to sequences of bytes and call this specific byte-array-based overload.

-Notice that for the reading methods, with the exception of the byte-array-based overload, you have to pass references to the variables which will receive the data. So, don't forget to add the *ref* keyword to those calls.
+You should read the API documentation for the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa19c33dac4b21ab9582a341bc766d474)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ae36611dec9a4e18aca42a876232e6f7f)**" method overloads and know them well, as these are probably the most important methods of the library - they are the core of the library's main operations. Notice that for the reading methods, with the exception of the byte-array-based overload, you have to pass references to the variables which will receive the data. So, don't forget to add the *ref* keyword to those calls.

 The following are examples of usage of reading and writing methods. For the sake of simplicity and code readability, we are not checking the bool values returned by these methods (we strongly recommend you to test them to see if the read/write operation has failed!). Also, consider the variables named **myTarget** as instances of the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** class, which are already attached to a target **Process**:

LearnCore modified by vinicius.ras

vinicius.ras — Thu, 19 May 2016 04:56:12 -0000

--- v5
+++ v6
@@ -1,7 +1,7 @@
 # Before you start... #
 ### Adding the library to your project

-To have access to the RAMvader namespace and its classes in your project, you should first choose one of the following options of deployment:
+To have access to the **[RAMvader namespace](http://ramvader.sourceforge.net/API/namespace_r_a_mvader.html)** and its classes in your project, you should first choose one of the following options of deployment:

 - ** (RECOMMENDED) Use the DLL **: you can download a precompiled copy of the Dynamic Linking Library (DLL) generated for the RAMvader project. The DLL can be obtained by downloading the binaries on RAMvader's Sourceforge project page. Then, open up your project and add a reference to the DLL you have downloaded. Doing this will enable you to use the RAMvader namespace and its classes. This is the recommended way to use the library, as you don't have to deal with any compilation issues, you can always ensure you're using a stable version of the library and you can easily update the DLL in future releases.
 - ** Compile the RAMvader project **: alternatively, you can download a copy of the RAMvader's library solution and compile it. It is only necessary to compile the "RAMvader" project which is in the solution. The compilation of this project will generate the Dynamic Linking Library (DLL) file which can be referenced into your own project for the RAMvader classes and namespaces to be used.

LearnCore modified by vinicius.ras

vinicius.ras — Thu, 19 May 2016 02:40:49 -0000

--- v4
+++ v5
@@ -9,19 +9,19 @@

 ### The library's architecture ##

-The library classes are contained into the **RAMvader** and **RAMvader.CodeInjection** namespaces. You will usually only need to use the **RAMvaderTarget** and **Injector** classes, which will be explained in this document.
+The library classes are contained into the **[RAMvader](http://ramvader.sourceforge.net/API/namespace_r_a_mvader.html)** and **[RAMvader.CodeInjection](http://ramvader.sourceforge.net/API/namespace_r_a_mvader_1_1_code_injection.html)** namespaces. You will usually only need to use the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** and **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** classes, which will be explained in this document.

-The **RAMvaderTarget** class manages a "target", which is really just a process running into the user's local machine, whose memory you have interest in, for performing I/O operations. A single **RAMvaderTarget** instance may only handle up to **one** single Process at a time. If your application needs to perform memory operations in more than one single, "external" process at any time, you might instantiate more **RAMvaderTarget** objects as necessary (one for each process). Currently, **RAMvaderTarget** objects can be created by using their class' default constructor.
+The **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** class manages a "target", which is really just a process running into the user's local machine, whose memory you have interest in, for performing I/O operations. A single **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance may only handle up to **one** single Process at a time. If your application needs to perform memory operations in more than one single, "external" process at any time, you might instantiate more **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** objects as necessary (one for each process). Currently, **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** objects can be created by using their class' default constructor.

-The **Injector** contains several features that might be useful to inject binary code and data ("variables", both managed and unmanaged ones) into the target process' memory space. The **Injector** class is optional. When you use an **Injector** object, it needs to be associated with a **RAMvaderTarget** object, as the **Injector** uses it "under the hood" to perform its injection operations.
+The **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** contains several features that might be useful to inject binary code and data ("variables", both managed and unmanaged ones) into the target process' memory space. The **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** class is optional. When you use an **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** object, it needs to be associated with a **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** object, as the **[Injector](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_code_injection_1_1_injector.html)** uses it "under the hood" to perform its injection operations.

-The library has its own Exception-derived classes. All the exceptions thrown by the library's own code derive from the **RAMvaderException** class. Notice, though, that calls to some methods related to the Windows API and to the Process class are made inside the library's code, and they might throw their own, standard exceptions to your client code in some cases. An effort will be made in future releases to document the thrown exceptions.
+The library has its own Exception-derived classes. All the exceptions thrown by the library's own code derive from the **[RAMvaderException](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_exception.html)** class. Notice, though, that calls to some methods related to the Windows API and to the **Process** class are made inside the library's code, and they might throw their own, standard exceptions to your client code in some cases. An effort will be made in future releases to document the thrown exceptions.

 Now that you know the basic concepts behind the **RAMvader** library's architecture, let's see how we can actually write programs using the **RAMvader** library!

 # Process attachment and detachment #

-The first thing you should do is to "attach" an instance of the **RAMvaderTarget** class to one of the processes running into the local machine. When you attach a **RAMvaderTarget**, you allow it to open the target process' memory for reading and writing operations. This method returns a bool value indicating if the operation was successful. The attachment method requires a **Process** (from the *System.Diagnostics* namespace) object to be provided, indicating the target process to which the **RAMvaderTarget** instance will be attached.
+The first thing you should do is to "attach" an instance of the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** class to one of the processes running into the local machine. When you attach a **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)**, you allow it to open the target process' memory for reading and writing operations. This method returns a bool value indicating if the operation was successful. The attachment method requires a **Process** (from the *System.Diagnostics* namespace) object to be provided, indicating the target process to which the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance will be attached.

 ~~~~~~
 using System.Diagnostics;
@@ -42,7 +42,7 @@
 - You can get a list of the running processes in your local machine by calling the standard [Process.GetProcesses()](http://msdn.microsoft.com/en-us/library/1f3ys1f9(v=vs.110).aspx) method.
 - Your application might not be able to attach to every process running into the local machine. Always ensure that your application is run with the necessary privileges and any necessary security configurations set up, before attempting to attach to a target process. As a general rule, the attachment will fail for any cases where a call to [WinAPI's OpenProcess() function](http://msdn.microsoft.com/en-us/library/windows/desktop/ms684320(v=vs.85).aspx) on the target process would fail.

-Finally, when you're all done playing with the other process' memory (you'll learn how to do that soon!), it is a good idea to detach the **RAMvaderTarget** object from it, to release any used resources. For programmers experienced with the WinAPI, detaching from the target process really means that the Handle to the process which has been opened will now be closed. For inexperienced programmers, just know that it is always a good idea to detach from the target process whenever you don't need it anymore, to free precious resources for the Operating System. Process detachment is done by calling the "**detachFromProcess()**" method, which returns a bool indicating if the operation was successful.
+Finally, when you're all done playing with the other process' memory (you'll learn how to do that soon!), it is a good idea to detach the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** object from it, to release any used resources. For programmers experienced with the WinAPI, detaching from the target process really means that the Handle to the process which has been opened will now be closed. For inexperienced programmers, just know that it is always a good idea to detach from the target process whenever you don't need it anymore, to free precious resources for the Operating System. Process detachment is done by calling the "**[DetachFromProcess()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#a6a92483b2a33f40d46b46afe0ce0671d)**" method, which returns a bool indicating if the operation was successful.

 ~~~~~~
 // Detach RAMvaderTarget from a
@@ -51,22 +51,22 @@
    Console.WriteLine( "Failed to detach!!" );
 ~~~~~~

-After detaching from a process, the **RAMvaderTarget** object cleans itself up. This means **you can *reuse* it to attach to another process safely**. That is, if you want, you do not need to instantiate a new **RAMvaderTarget** to open another process after detaching from a previous one: just attach it to a new process.
+After detaching from a process, the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** object cleans itself up. This means **you can *reuse* it to attach to another process safely**. That is, if you want, you do not need to instantiate a new **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** to open another process after detaching from a previous one: just attach it to a new process.

-You might check if a **RAMvaderTarget** instance is attached to a process by calling the "**IsAttachedToProcess()**", which returns a flag indicating if the instance is currently attached to a process. You might also retrieve the **Process** object, corresponding to the attached process, by calling "**GetAttachedProcess()**". This last method might return a *null* value, if the **RAMvaderTarget** instance is currently not attached to any Process.
+You might check if a **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance is attached to a process by calling the "**[IsAttached()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#a75f84b09700d7c2cce4860eef06c726d)**" method, which returns a flag indicating if the instance is currently attached to a process. You might also retrieve the **Process** object, corresponding to the attached process, by calling "**[GetAttachedProcess()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#a257761fc8a4ff66d0cf5560edc967504)**". This last method might return a *null* value, if the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance is currently not attached to any Process.

 # Memory I/O operations #

-After attaching a **RAMvaderTarget** instance to a target Process, you can perform reading and writing operations to its memory. This is done by the "***ReadFromTarget()***" and "***WriteToTarget()***" methods. Both methods...:
+After attaching a **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** instance to a target Process, you can perform reading and writing operations to its memory. This is done by the "**[ReadFromTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#aa19c33dac4b21ab9582a341bc766d474)**" and "**[WriteToTarget()](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html#ae36611dec9a4e18aca42a876232e6f7f)**" methods. Both methods...:

 * ... have several overloads to work with many basic types of data supported by the library.
 * ... return a bool value, which indicate if the writing/reading operation has been performed with success.
-* ... receive a first parameter of type IntPtr which indicate the address, on the target Process' memory space, where you want the method to operate.
+* ... receive a first parameter of type **IntPtr** which indicate the address, on the target **Process**' memory space, where you want the method to operate.
 * ... have an overload specialized for writing/reading an array of bytes. In fact, all overloads convert other basic types to sequences of bytes and call this specific byte-array-based overload.

 Notice that for the reading methods, with the exception of the byte-array-based overload, you have to pass references to the variables which will receive the data. So, don't forget to add the *ref* keyword to those calls.

-The following are examples of usage of reading and writing methods. For the sake of simplicity and code readability, we are not checking the bool values returned by these methods (we strongly recommend you to test them to see if the read/write operation has failed!). Also, consider the variables named **myTarget** as instances of the **RAMvaderTarget** class, which are already attached to a target **Process**:
+The following are examples of usage of reading and writing methods. For the sake of simplicity and code readability, we are not checking the bool values returned by these methods (we strongly recommend you to test them to see if the read/write operation has failed!). Also, consider the variables named **myTarget** as instances of the **[RAMvaderTarget](http://ramvader.sourceforge.net/API/class_r_a_mvader_1_1_r_a_mvader_target.html)** class, which are already attached to a target **Process**:

 ~~~~~~
 // Read a Single (a.k.a. "float") value from address 0xAABBCCDD

LearnCore modified by vinicius.ras

vinicius.ras — Tue, 17 May 2016 20:26:29 -0000

LearnCore modified by vinicius.ras

vinicius.ras — Tue, 17 May 2016 20:25:10 -0000

--- v2
+++ v3
@@ -1,5 +1,5 @@
 # Before you start... #
-## Adding the library to your project ##
+### Adding the library to your project

 To have access to the RAMvader namespace and its classes in your project, you should first choose one of the following options of deployment:

@@ -7,7 +7,7 @@
 - ** Compile the RAMvader project **: alternatively, you can download a copy of the RAMvader's library solution and compile it. It is only necessary to compile the "RAMvader" project which is in the solution. The compilation of this project will generate the Dynamic Linking Library (DLL) file which can be referenced into your own project for the RAMvader classes and namespaces to be used.
 - ** Include the source files in your project **: you can also copy all the files under the "RAMvader" project into your own project. This might be the easiest approach for inexperienced programmers, but is also the least recommended one: the source files and their structures might change a lot, turning future updates impractical.

-## The library's architecture ##
+### The library's architecture ##

 The library classes are contained into the **RAMvader** and **RAMvader.CodeInjection** namespaces. You will usually only need to use the **RAMvaderTarget** and **Injector** classes, which will be explained in this document.