How webMAN MOD Manages Firmware Version Checking and Spoofing for PS3 Compatibility

webMAN MOD detects the real PS3 firmware version by scanning LV2 memory signatures and stores it in the global c_firmware variable, while the nospoof configuration flag controls whether to report the actual version or spoof a pre-4.53 firmware for older homebrew compatibility.

The webMAN MOD plugin, maintained in the aldostools/webman-mod repository, implements a robust dual-layer approach to firmware identification that bypasses OS-level spoofing. This system ensures accurate version detection for applying system-specific patches while providing optional compatibility modes for legacy applications.

Firmware Version Detection Architecture

The detect_firmware() Function

The primary detection routine resides in include/init/firmware.h within the detect_firmware() function (lines 95-110). This static function implements early-exit logic to avoid redundant detection:

static void detect_firmware(void)
{
    if((c_firmware > 3.40f) || SYSCALL_TABLE || syscalls_removed) return;
    dex_mode = 0;
    // ...
    for(u8 lv2_offset = 1; lv2_offset < 0x10; lv2_offset++)
    {
        if(SYSCALL_TABLE) break;
        LV2_OFFSET_ON_LV1 = (u64)lv2_offset * 0x1000000ULL;
        // Memory signature validation follows...
    }
}

If no cached value exists in c_firmware, the function iterates through LV1-LV2 offset tables to locate the correct memory layout for the running system.

Signature-Based Memory Peeking

Rather than trusting the OS version report, webMAN MOD validates firmware by directly reading raw LV2 memory through the peek() function. In include/init/firmware.h (lines 121-132), the code checks for CEX (retail), DEX (debug), and DEH (debug-hacker) markers at known offsets:

if(peek(0x2ED808) == CEX) {
    SYSCALL_TABLE = SYSCALL_TABLE_480;
    c_firmware = (peek(0x2FCB58) == FW490) ? 4.90f : 4.80f;
}
else if(peek(0x2ED818) == CEX) {
    SYSCALL_TABLE = SYSCALL_TABLE_482;
    c_firmware = (peek(0x2FCB68) == FW492) ? 4.92f :
                 (peek(0x2FCB68) == FW491) ? 4.91f :
                 // Additional version branching...
                 get_firmware_version();
}

The code checks byte signatures at addresses like 0x2ED808 and reads build strings (FW490, FW492) from secondary addresses (0x2FCB58, 0x2FCB68) to determine the exact version as a float (e.g., 4.92f).

LV2 System Call Fallback

When no known signatures match, webMAN MOD falls back to get_firmware_version() in include/init/firmware.h (lines 65-70), which queries the SC_GET_PLATFORM_INFO system call:

static float get_firmware_version(void)
{
    lv2_get_platform_info(&info);
    char FW[8]; sprintf(FW, "%02X", info.firmware_version);
    return (float)(FW[0] & 0x0F) + val(FW + 2)*0.00001f;
}

This converts the hexadecimal firmware version to a float representation, ensuring consistent numeric comparisons throughout the plugin.

Global Firmware Storage and Configuration

The c_firmware Variable

The detected version persists in the global variable c_firmware declared in main.c (line 240):

static float c_firmware = 0.0f;

This variable serves as the single source of truth for all version-specific decisions, from syscall table selection to compatibility warnings. The detect_firmware() function populates this variable during initialization (called from main.c around line 680).

The nospoof Configuration Flag

User control over spoofing behavior resides in the nospoof field defined in include/init/wm_config.h (line 64):

u8 nospoof; // [326] 0=spoof fw version < 4.53, 1=don't spoof fw version (default)

When set to 0, webMAN MOD presents a spoofed version below 4.53 to applications that refuse to run on newer firmware. When set to 1 (the default), it reports the accurate version stored in c_firmware.

Spoofing Control and Safety Mechanisms

Automatic Enforcement for Firmware 4.53+

To maintain system stability, webMAN MOD automatically disables spoofing when running on firmware 4.53 or higher. This enforcement occurs in include/setup.h (lines 277-279):

if(c_firmware >= 4.53f) webman_config->nospoof = 1;

This safety measure prevents older homebrew from inadvertently disabling critical security patches or system calls present in newer firmware versions.

Runtime Compatibility Checks

Throughout the codebase, webMAN MOD guards version-specific features by checking both c_firmware and nospoof. For example, in include/www/www_start.h (line 115):

if(webman_config->nospoof || (c_firmware >= 4.53f))
    // skip version-spoofing specific code

This pattern appears in mount handling, fan control, and combo shortcuts, ensuring that features requiring real firmware version data behave correctly regardless of spoofing settings.

Practical Implementation Examples

Querying Firmware in Homebrew

Developers integrating with webMAN MOD can access the detected firmware directly:

#include "include/init/firmware.h"

extern float c_firmware;

void check_compatibility(void) {
    if(c_firmware >= 4.80f) {
        // Enable features requiring 4.80+
    } else {
        // Fall back to legacy implementation
    }
}

This global variable reflects the real hardware version unless the nospoof flag is actively spoofing a lower version for compatibility.

Configuring Spoofing Behavior

Users control spoofing through the configuration file:

# In webMAN MOD configuration (webman_config.txt):

# Set nospoof=0 to enable spoofing (report version < 4.53)

# Set nospoof=1 to disable spoofing (default, report real version)

nospoof=1

When nospoof=0 and the console runs firmware below 4.53, webMAN MOD presents a compatible version to legacy applications. On firmware 4.53+, the setting automatically reverts to 1 regardless of user preference to maintain system stability.

Summary

• Detection: webMAN MOD identifies the real PS3 firmware by scanning LV2 memory signatures in include/init/firmware.h, falling back to the SC_GET_PLATFORM_INFO syscall when no signatures match.
• Storage: The detected version persists as a float in the global c_firmware variable declared in main.c.
• Spoofing Control: The nospoof configuration flag in include/init/wm_config.h determines whether to report the real version or spoof a pre-4.53 firmware for older homebrew.
• Safety Enforcement: include/setup.h automatically forces nospoof = 1 on firmware 4.53 and newer to prevent instability.
• Runtime Guards: Throughout the codebase (e.g., include/www/www_start.h), version-specific features check both c_firmware and nospoof to ensure correct behavior.

Frequently Asked Questions

How does webMAN MOD detect firmware if the OS is already spoofed?

WebMAN MOD bypasses the OS version report by directly reading raw LV2 memory through the peek() function. In include/init/firmware.h, the detect_firmware() routine checks for known byte signatures at specific offsets (such as 0x2ED808 for CEX markers) to determine the actual firmware version regardless of what the system interface displays. If no signatures match, it falls back to the SC_GET_PLATFORM_INFO system call.

What is the purpose of the nospoof flag in webMAN MOD?

The nospoof flag, defined in include/init/wm_config.h, controls whether webMAN MOD reports the actual firmware version stored in c_firmware or spoofs a version below 4.53 for compatibility with older homebrew. When set to 0, the plugin presents a spoofed version to applications that refuse to run on newer firmware; when set to 1 (the default), it reports the accurate version detected from LV2 memory.

Why does webMAN MOD force nospoof on firmware 4.53 and higher?

To maintain system stability, webMAN MOD automatically disables spoofing when running on firmware 4.53 or higher. This enforcement occurs in include/setup.h (lines 277-279), where the code sets webman_config->nospoof = 1 if c_firmware >= 4.53f. Newer firmware versions contain critical security patches and system calls that older homebrew might inadvertently disable if the system reports a spoofed version, potentially causing instability or bricking risks.

Can homebrew applications read the firmware version directly from webMAN MOD?

Yes, homebrew applications linked against webMAN MOD headers can access the global c_firmware variable declared in main.c (line 240). This float contains the detected firmware version (e.g., 4.92f) and reflects the real hardware version unless the nospoof flag is actively spoofing a lower version. Developers can use this variable to gate features requiring specific firmware capabilities without implementing their own detection routines.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}