cs2-dumper

By default, cs2-dumper uses the memflow-native OS layer to read game memory. However, you can specify alternative memflow connectors (like pcileech or kvm) using the -c or --connector flag. If the connector requires arguments, use the -a or --connector-args flag.

Important Permissions: Certain connectors require elevated privileges:

• Linux: Run the executable with sudo (e.g., for the kvm connector).
• Windows: Run the executable as an Administrator (e.g., for pcileech or winio connectors).

Connectors can be managed using the memflowup tool.

cs2-dumper -c pcileech -a :device=FPGA -vv

To use cs2-dumper, you can either download a pre-compiled release or build it from source.

Prerequisites:

• If compiling from source, you must have Rust version 1.74.0 or newer installed.

Steps:

1. Download the latest release from the Releases page.
2. Ensure Counter-Strike 2 is running (being in the main menu is sufficient).
3. Run the cs2-dumper executable.

cargo test -- --nocapture

The following arguments are available for the cs2-dumper executable:

The schemas function is the primary entry point for extracting the game's type system (classes and enums) from a running process. It returns a SchemaMap, which is a mapping where keys are module names (e.g., client.dll) and values are tuples containing a list of Class objects and a list of Enum objects found within that module.

To use this, you must provide a type that implements the memflow::prelude::v1::Process and MemoryView traits.

The SchemaType struct is the primary representation of a type within the Source2 schema system. It contains metadata such as the type name, its scope, its category, and a union containing the actual type data.

To correctly parse a SchemaType, you must first check type_category and atomic_category to determine which field of the SchemaTypeUnion is valid.

pub struct SchemaType {
    pub name: Pointer64<ReprCString>,
    pub type_scope: Pointer64<SchemaSystemTypeScope>,
    pub type_category: SchemaTypeCategory,
    pub atomic_category: SchemaAtomicCategory,
    pub value: SchemaTypeUnion,
}

The SchemaTypeCategory enum defines the high-level classification of a Source2 schema type. This is used to determine how the SchemaTypeUnion should be interpreted.

pub enum SchemaTypeCategory {
    BuiltIn = 0,
    Ptr,
    Bitfield,
    FixedArray,
    Atomic,
    DeclaredClass,
    DeclaredEnum,
    None,
}

The SchemaNetworkValueUnion is a C-style union used to store different types of network values within the Source 2 schema. Depending on the context, the union can represent a string pointer, a numeric value, a generic pointer, a variable name, or a fixed-size character array.

#[repr(C)]
pub union SchemaNetworkValueUnion {
    pub name_ptr: Pointer64<ReprCString>,
    pub int_value: i32,
    pub float_value: f32,
    pub ptr_value: Pointer64<()>,
    pub var_value: SchemaVarName,
    pub name_value: [c_char; 32],
}

The SchemaAtomicCategory enum specifies the specific sub-type of an atomic schema element, providing details on how the underlying data is structured (e.g., whether it is a simple type T, a collection CollectionOfT, or a template-based type TTF).

pub enum SchemaAtomicCategory {
    Basic = 0,
    T,
    CollectionOfT,
    TF,
    TT,
    TTF,
    I,
    None,
}

The ClassMetadata enum provides specialized information extracted from the schema system for certain classes:

• Unknown { name: String }: A fallback for metadata that doesn't match known patterns.
• NetworkChangeCallback { name: String }: Indicates a callback for network changes.
• NetworkVarNames { name: String, type_name: String }: Provides the name and type of a network variable.

#[derive(Clone, Debug, Deserialize, Serialize)]
pub enum ClassMetadata {
    Unknown { name: String },
    NetworkChangeCallback { name: String },
    NetworkVarNames { name: String, type_name: String },
}