The Reloaded Buffers Library

Allocate Memory, & Knuckles

About

Reloaded.Memory.Buffers is a library for allocating memory between a given minimum and maximum memory address, for C# and Rust.

With the following properties:

• Memory Efficient: No wasted memory.
• Shared: Can be found and read/written to by multiple users.
• Static: Allocated data never moves, or is overwritten.
• Permanent: Allocated data lasts the lifetime of the process.
• Concurrent: Multiple users can access at the same time.
• Large Address Aware: On Windows, the library can correctly leverage all 4GB in 32-bit processes.
• Cross Platform: Supports Windows, OSX and Linux.

Note: Rust/C port also work with FreeBSD (untested), and has partial (limited) Android support.

Wiki & Documentation

For full documentation, please see the Wiki.

Example Use Cases

These are just examples:

• Hooks: Hooking libraries like Reloaded.Hooks can reduce amount of bytes stolen from functions.
• Libraries: Libraries like Reloaded.Assembler require memory be allocated in first 2GB for x64 FASM.

Usage

!!! info "The library provides a simple high level API to use."

!!! info "See Wiki for Rust usage"

Get A Buffer

Gets a buffer where you can allocate 4096 bytes in first 2GiB of address space.

var settings = new BufferSearchSettings()
{
    MinAddress = 0,
    MaxAddress = int.MaxValue,
    Size = 4096
};

// Make sure to dispose, so lock gets released.
using var item = Buffers.GetBuffer(settings);

// Write some data, get pointer back.
var ptr = item->Append(data); 

Get A Buffer (With Proximity)

Gets a buffer where 4096 bytes written will be within 2GiB of 0x140000000.

var settings = BufferSearchSettings.FromProximity(int.MaxValue, (nuint)0x140000000, 4096);

// Make sure to dispose, so lock gets released.
using var item = Buffers.GetBuffer(settings);

// Write some data, get pointer back.
var ptr = item->Append(data); 

Allocate Memory

Allows you to temporarily allocate memory within a specific address range and size constraints.

// Arrange
var settings = new BufferAllocatorSettings()
{
    MinAddress = 0,
    MaxAddress = int.MaxValue,
    Size = 4096
};

using var item = Buffers.AllocatePrivateMemory(settings);

// You have allocated memory in first 2GiB of address space.
// Disposing this memory (via `using` statement) will free it.
item.BaseAddress.Should().NotBeNull();
item.Size.Should().BeGreaterOrEqualTo(settings.Size);

You can specify another process with TargetProcess = someProcess in BufferAllocatorSettings, but this is only supported on Windows.

Crate Features (Rust)

• std: [Enabled by Default] Enables use of standard library.
• external_processes: Support external processes (windows only).
• no_format: Disables formatting code in errors, saving ~8kB of space.
• size_opt: Makes cold paths optimized for size instead of optimized for speed. [Requires 'nightly' Rust]
• c_exports Provides C exports for the library.

Community Feedback

If you have questions/bug reports/etc. feel free to Open an Issue.

Contributions are welcome and encouraged. Feel free to implement new features, make bug fixes or suggestions so long as they meet the quality standards set by the existing code in the repository.

For an idea as to how things are set up, see Reloaded Project Configurations.

Happy Hacking 💜