Recent changes to Home

Home modified by vinicius.ras

vinicius.ras — Thu, 19 May 2016 05:14:28 -0000

--- v5
+++ v6
@@ -13,6 +13,9 @@
 * [The Injector](LearnInjector): inject binary code and data into other process' memory space!
 * [Advanced topics](LearnEndiannessPointersErrorHandling): endianness, pointers and error handling.

+**[API reference](http://ramvader.sourceforge.net/API/)** is also available online for the **RAMvader** library.
+*NOTE: you can download it as well for offline usage in the [project's files page](https://sourceforge.net/projects/ramvader/files/).*
+
 # About the library's source code... #

 ### Visual Studio support ###
@@ -26,5 +29,3 @@
 - **RAMvader**: the main project, whose main purpose is to generate a Dynamic Linking Library (DLL), which can be referenced by other projects. This project contains all the source code needed to provide the core functionality for the **RAMvader** library.
 - **RAMvaderGUI**: a secondary project, built on top of Microsoft's Windows Presentation Foundation (WPF), which consists in a small application that allows the user to perform read and write operations on other processes running in the user's machine. The user can select any process running in his/her machine and them read or alter the process' memory. Read and write operations are performed by using the **RAMvader** library.
 - **RAMvaderTestTarget**: this project consists of a small program written in C++. As its name implies, it is supposed to be used as a "test target" for the **RAMvader** library. That is, this application is specially crafted so that it is easy to watch its memory values and alter them through the use of the **RAMvader** library. In fact, the application simply displays a list of differently-typed variables, along with their memory addresses and current values, so that the user can easily watch and modify the application's variables. This application is used for testing the functionalities of the **RAMvader** library, which can be easily done by using the RAMvaderGUI application.
-
-You can also access the **RAMvader** library API reference by [clicking here](http://ramvader.sourceforge.net/API/).

Home modified by vinicius.ras

vinicius.ras — Thu, 19 May 2016 04:51:54 -0000

--- v4
+++ v5
@@ -2,9 +2,9 @@

 ## Description ##

-RAMvader is a small C#-written library which uses p/Invoke on Windows-based systems to provide functionalities to ease the access to other processes' memory space. It basically allows your software to read data from and/or write data to another process' memory space.
+**RAMvader** is a small C#-written library which uses p/Invoke on Windows-based systems to provide functionalities to ease the access to other processes' memory space. It basically allows your software to read data from and/or write data to another process' memory space.

-The main, initial purpose of RAMvader is to provide a library that can be used in the development of game trainers, but it might also fit other purposes, such as antivirus/security software, machine learning, benchmarking, and others.
+The main, initial purpose of **RAMvader** is to provide a library that can be used in the development of game trainers, but it might also fit other purposes, such as antivirus/security software, machine learning, benchmarking, and others.

 # How to use the library? #
 Please, use the following links to access our guides on how to use the **RAMvader** library:
@@ -23,8 +23,8 @@

 The library comes as a set of three projects, grouped into a Visual Studio Express solution.

-- **RAMvader**: the main project, whose main purpose is to generate a Dynamic Linking Library, which can be referenced by other projects. This project contains all the source code needed to provide the core functionality for the RAMvader library.
-- **RAMvaderGUI**: a secondary project, built on top of Microsoft's Windows Presentation Foundation (WPF), which consists in a small application that allows the user to perform read and write operations on other processes running in the user's machine. The user can select any process running in his/her machine and them read or alter the process' memory. Read and write operations are performed by using the RAMvader library.
-- **RAMvaderTestTarget**: this project consists of a small program written in C++. As its name implies, it is supposed to be used as a "test target" for the RAMvader library. That is, this application is specially crafted so that it is easy to watch its memory values and alter them through the use of the RAMvader library. In fact, the application simply displays a list of differently-typed variables, along with their memory addresses and current values, so that the user can easily watch and modify the application's variables. This application is used for testing the functionalities of the RAMvader library, which can be easily done by using the RAMvaderGUI application.
+- **RAMvader**: the main project, whose main purpose is to generate a Dynamic Linking Library (DLL), which can be referenced by other projects. This project contains all the source code needed to provide the core functionality for the **RAMvader** library.
+- **RAMvaderGUI**: a secondary project, built on top of Microsoft's Windows Presentation Foundation (WPF), which consists in a small application that allows the user to perform read and write operations on other processes running in the user's machine. The user can select any process running in his/her machine and them read or alter the process' memory. Read and write operations are performed by using the **RAMvader** library.
+- **RAMvaderTestTarget**: this project consists of a small program written in C++. As its name implies, it is supposed to be used as a "test target" for the **RAMvader** library. That is, this application is specially crafted so that it is easy to watch its memory values and alter them through the use of the **RAMvader** library. In fact, the application simply displays a list of differently-typed variables, along with their memory addresses and current values, so that the user can easily watch and modify the application's variables. This application is used for testing the functionalities of the **RAMvader** library, which can be easily done by using the RAMvaderGUI application.

 You can also access the **RAMvader** library API reference by [clicking here](http://ramvader.sourceforge.net/API/).

Home modified by vinicius.ras

vinicius.ras — Thu, 19 May 2016 03:07:41 -0000

--- v3
+++ v4
@@ -6,7 +6,14 @@

 The main, initial purpose of RAMvader is to provide a library that can be used in the development of game trainers, but it might also fit other purposes, such as antivirus/security software, machine learning, benchmarking, and others.

-## About the library's source code... ##
+# How to use the library? #
+Please, use the following links to access our guides on how to use the **RAMvader** library:
+
+* [First Steps](LearnCore): learn the library's basics!
+* [The Injector](LearnInjector): inject binary code and data into other process' memory space!
+* [Advanced topics](LearnEndiannessPointersErrorHandling): endianness, pointers and error handling.
+
+# About the library's source code... #

 ### Visual Studio support ###

@@ -20,11 +27,4 @@
 - **RAMvaderGUI**: a secondary project, built on top of Microsoft's Windows Presentation Foundation (WPF), which consists in a small application that allows the user to perform read and write operations on other processes running in the user's machine. The user can select any process running in his/her machine and them read or alter the process' memory. Read and write operations are performed by using the RAMvader library.
 - **RAMvaderTestTarget**: this project consists of a small program written in C++. As its name implies, it is supposed to be used as a "test target" for the RAMvader library. That is, this application is specially crafted so that it is easy to watch its memory values and alter them through the use of the RAMvader library. In fact, the application simply displays a list of differently-typed variables, along with their memory addresses and current values, so that the user can easily watch and modify the application's variables. This application is used for testing the functionalities of the RAMvader library, which can be easily done by using the RAMvaderGUI application.

-# How to use the library? #
-Please, use the following links to access our guides on how to use the **RAMvader** library:
-
-* [First Steps](LearnCore): learn the library's basics!
-* [The Injector](LearnInjector): inject binary code and data into other process' memory space!
-* [Advanced topics](LearnEndiannessPointersErrorHandling): endianness, pointers and error handling.
-
 You can also access the **RAMvader** library API reference by [clicking here](http://ramvader.sourceforge.net/API/).

Home modified by vinicius.ras

vinicius.ras — Thu, 19 May 2016 01:56:23 -0000

--- v2
+++ v3
@@ -26,3 +26,5 @@
 * [First Steps](LearnCore): learn the library's basics!
 * [The Injector](LearnInjector): inject binary code and data into other process' memory space!
 * [Advanced topics](LearnEndiannessPointersErrorHandling): endianness, pointers and error handling.
+
+You can also access the **RAMvader** library API reference by [clicking here](http://ramvader.sourceforge.net/API/).

Home modified by vinicius.ras

vinicius.ras — Tue, 17 May 2016 20:18:34 -0000

--- v1
+++ v2
@@ -1,8 +1,28 @@
-Welcome to your wiki!
+# The RAMvader Library #

-This is the default page, edit it as you see fit. To add a new page simply reference it within brackets, e.g.: [SamplePage].
+## Description ##

-The wiki uses [Markdown](/p/ramvader/wiki/markdown_syntax/) syntax.
+RAMvader is a small C#-written library which uses p/Invoke on Windows-based systems to provide functionalities to ease the access to other processes' memory space. It basically allows your software to read data from and/or write data to another process' memory space.

-[[members limit=20]]
-[[download_button]]
+The main, initial purpose of RAMvader is to provide a library that can be used in the development of game trainers, but it might also fit other purposes, such as antivirus/security software, machine learning, benchmarking, and others.
+
+## About the library's source code... ##
+
+### Visual Studio support ###
+
+The project is developed in Microsoft's Visual Studio, and that is currently the only supported development environment, although we will try to answer as many questions or issues related to the project as we can.
+
+### The Visual Studio Express solution ###
+
+The library comes as a set of three projects, grouped into a Visual Studio Express solution.
+
+- **RAMvader**: the main project, whose main purpose is to generate a Dynamic Linking Library, which can be referenced by other projects. This project contains all the source code needed to provide the core functionality for the RAMvader library.
+- **RAMvaderGUI**: a secondary project, built on top of Microsoft's Windows Presentation Foundation (WPF), which consists in a small application that allows the user to perform read and write operations on other processes running in the user's machine. The user can select any process running in his/her machine and them read or alter the process' memory. Read and write operations are performed by using the RAMvader library.
+- **RAMvaderTestTarget**: this project consists of a small program written in C++. As its name implies, it is supposed to be used as a "test target" for the RAMvader library. That is, this application is specially crafted so that it is easy to watch its memory values and alter them through the use of the RAMvader library. In fact, the application simply displays a list of differently-typed variables, along with their memory addresses and current values, so that the user can easily watch and modify the application's variables. This application is used for testing the functionalities of the RAMvader library, which can be easily done by using the RAMvaderGUI application.
+
+# How to use the library? #
+Please, use the following links to access our guides on how to use the **RAMvader** library:
+
+* [First Steps](LearnCore): learn the library's basics!
+* [The Injector](LearnInjector): inject binary code and data into other process' memory space!
+* [Advanced topics](LearnEndiannessPointersErrorHandling): endianness, pointers and error handling.

Discussion for Home page

vinicius.ras — Fri, 19 Sep 2014 02:10:43 -0000

The RAMvader Library

Library description

RAMvader is a small C#-written library which uses p/Invoke on Windows-based systems to provide functionalities to ease the access to other processes' memory space. It basically allows your software to read data from and/or write data to another process' memory space.

The main, initial purpose of RAMvader is to provide a library that can be used in the development of game trainers, but it might also fit other purposes.

Visual Studio support

The project is developed in Microsoft's Visual Studio, and that is currently the only supported development environment. Although we will try to answer any questions or issues we can related to the project, the issues with other development environments are not supported, a

The Visual Studio Express solution

The library comes as a set of three projects, grouped into a Visual Studio Express solution.

RAMvader: the main project, whose main purpose is to generate a Dynamic Linking Library, which can be referenced by other projects. This project contains all the source code needed to provide the core functionality for the RAMvader library.
RAMvaderGUI: a secondary project, built on top of Microsoft's Windows Presentation Foundation, which consists into a small application that allows the user to perform read and write operations on other processes running in the user's machine. There read and write operations are performed by using the RAMvader library.
RAMvaderTestTarget: this project consists of a small program written in C++. As its name implies, it is supposed to be used as a "test target" for the RAMvader library. That is, this application is specially crafted so that it is easy to watch its memory values and alter them through the use of the RAMvader library. In fact, the application simply displays a list of differently-typed variables, along with their memory addresses and current values, so that the user can easily watch and modify the application's variables. This application is used for testing the functionalities of the RAMvader library, which can be easily done by using the RAMvaderGUI application.

RAMvader usage

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:

(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.
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.

Using the library

General guidelines

The library classes are contained into the RAMvader namespace. You will usually only need to use the RAMvaderTarget class. This 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 library has its own Exception-derived classes. All the exceptions thrown by the library's own code derive from the RAMvaderException classes. 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.

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 object to be provided, indicating the target process to which the RAMvaderTarget instance will be attached.

using System;
using RAMvader;

...

// Attach a RAMvaderTarget to process with PID 112233
Process targetProc = Process.GetProcessById( 112233 );

RAMvaderTarget myTarget = new RAMvaderTarget();
if ( myTarget.attachToProcess( targetProc ) == false )
   Console.WriteLine( "Error attaching to process!" );

There are some points to highlight for the attachment process:

You can get a list of the running processes in your local machine by calling the standard Process.GetProcesses() 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 on the target process would fail.

Finally, when you're all done playing with the other process' memory, it is a good idea to "close" the process, by detaching the RAMvaderTarget object from it. 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.

// Detach RAMvaderTarget from a
// previously attached process
if ( myTarget.detachFromProcess() == false )
   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.

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.

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 "writeToTarget()" and "readFromTarget()" methods. Both methods...:

... have several overloads to work with many basic types of data supported by the library.
... have a bool return 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.

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 testing the values returned for these methods. Also, consider the variables named myTarget as instances of the RAMvaderTarget 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 );
Single myVar;   // this variable will store the read value
myTarget.readFromTarget( targetAddr, ref myVar );

// 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 );
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 );
Int32 myVar;
myTarget.readFromTarget( targetAddr, ref myVar );

myVar *= 2;
myTarget.writeToTarget( targetAddr, myVar );

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

// Write 3 bytes of memory to 0x80808080
byte [] myBuffer = new byte[] { 10, 20, 30 };
myTarget.writeToTarget( new IntPtr( 0x80808080 ), myBuffer );

Home modified by vinicius.ras

vinicius.ras — Fri, 24 Jan 2014 19:55:35 -0000

Welcome to your wiki!

This is the default page, edit it as you see fit. To add a new page simply reference it within brackets, e.g.: [SamplePage].

The wiki uses Markdown syntax.

Project Members:

vinicius.ras (admin)