Cache Class Reference

Static Public Member Functions
static	clear ()
static	get ($cacheKey)
static	getDuration ()
static	getStats ()
static	recordHit ()
static	recordMiss ()
static	set ($cacheKey, $data)
static	setDuration ($seconds)

Static Private Member Functions
static	generateCacheHMAC ($data, $cacheKey)
static	getCacheIntegrityKey ()
static	verifyCacheIntegrity ($fileContents, $cacheKey)

Static Private Attributes
static	$cacheIntegrityKey = null
static	$fileScanCache = null
static	$fileScanCacheDuration = 3600
static	$fileScanStats

Detailed Description

Cache class for managing file scan caching with integrity verification.

This class handles caching of file scan results with optional integrity checks to prevent tampering. It supports both in-memory and file-based caching with configurable cache duration.

Usage Example:

$cached = Cache::get('my_cache_key');
if ($cached === false) {
    $data = performExpensiveOperation();
    Cache::set('my_cache_key', $data);
}

Definition at line 27 of file class.cache.php.

Member Function Documentation

clear()

clear ( )

static

Clears all file scan caches.

Returns

void

Definition at line 271 of file class.cache.php.

    {
        global $bearsamppRoot;
 
        // Clear memory cache
        self::$fileScanCache = null;
 
        // Clear file caches
        if (isset($bearsamppRoot)) {
            $tmpPath = Path::getTmpPath();
            $cacheFiles = glob($tmpPath . '/filescan_cache_*.dat');
 
            if ($cacheFiles !== false) {
                foreach ($cacheFiles as $cacheFile) {
                    @unlink($cacheFile);
                }
                Log::info('Cleared ' . count($cacheFiles) . ' file scan cache files');
            }
        }
 
        // Reset stats
        self::$fileScanStats = [
            'hits' => 0,
            'misses' => 0,
            'invalidations' => 0
        ];
    }

References $bearsamppRoot, Path\getTmpPath(), and Log\info().

Here is the call graph for this function:

generateCacheHMAC()

generateCacheHMAC ( $data, $cacheKey )

staticprivate

Generates HMAC for cache data integrity verification.

Parameters

array	$data	The data to generate HMAC for
string	$cacheKey	The cache key

Returns

string The HMAC hash

Definition at line 229 of file class.cache.php.

    {
        $key = self::getCacheIntegrityKey();
        // Bind the HMAC to the cache key so a valid payload for key A cannot
        // be replayed under key B.
        $message = json_encode($data) . $cacheKey;
        return hash_hmac('sha256', $message, $key);
    }

References getCacheIntegrityKey().

Referenced by set(), and verifyCacheIntegrity().

Here is the call graph for this function:

Here is the caller graph for this function:

get()

get ( $cacheKey )

static

Gets cached file scan results if valid. Includes integrity verification to prevent cache tampering.

Parameters

string

$cacheKey

The cache key to retrieve.

Returns

array|false Returns cached results or false if cache is invalid/missing.

Definition at line 66 of file class.cache.php.

    {
        global $bearsamppRoot;
 
        // Check if we have in-memory cache first
        if (self::$fileScanCache !== null && isset(self::$fileScanCache[$cacheKey])) {
            $cache = self::$fileScanCache[$cacheKey];
 
            // Check if cache is still valid
            if (time() - $cache['timestamp'] < self::$fileScanCacheDuration) {
                return $cache['data'];
            } else {
                self::$fileScanStats['invalidations']++;
                unset(self::$fileScanCache[$cacheKey]);
            }
        }
 
        // Try to load from file cache
        if (!isset($bearsamppRoot)) {
            return false;
        }
 
        $cacheFile = Path::getTmpPath() . '/filescan_cache_' . $cacheKey . '.dat';
 
        if (file_exists($cacheFile)) {
            $fileContents = @file_get_contents($cacheFile);
 
            if ($fileContents === false) {
                return false;
            }
 
            // Verify HMAC over the raw file bytes BEFORE any parsing.
            // This prevents PHP object injection via magic methods (__wakeup /
            // __destruct) that would fire during unserialize() even when the
            // HMAC subsequently fails.
            if (!self::verifyCacheIntegrity($fileContents, $cacheKey)) {
                Log::warning('File scan cache integrity check failed for key: ' . $cacheKey . '. Possible tampering detected.');
                @unlink($cacheFile);
                return false;
            }
 
            // Integrity confirmed – now it is safe to decode.
            $cacheData = @json_decode($fileContents, true);
 
            if (is_array($cacheData)
                && isset($cacheData['timestamp']) && is_int($cacheData['timestamp'])
                && isset($cacheData['data'])      && is_array($cacheData['data'])
                && isset($cacheData['hmac'])      && is_string($cacheData['hmac'])
            ) {
                // Check if file cache is still valid
                if (time() - $cacheData['timestamp'] < self::$fileScanCacheDuration) {
                    // Store in memory cache for faster subsequent access
                    if (self::$fileScanCache === null) {
                        self::$fileScanCache = [];
                    }
                    self::$fileScanCache[$cacheKey] = $cacheData;
 
                    return $cacheData['data'];
                } else {
                    // Cache expired, delete file
                    self::$fileScanStats['invalidations']++;
                    @unlink($cacheFile);
                }
            } else {
                // Invalid cache structure, delete file
                Log::warning('Invalid cache structure detected for key: ' . $cacheKey);
                @unlink($cacheFile);
            }
        }
 
        return false;
    }

References $bearsamppRoot, Path\getTmpPath(), and Log\warning().

Referenced by Util\getFilesToScan().

Here is the call graph for this function:

Here is the caller graph for this function:

getCacheIntegrityKey()

getCacheIntegrityKey ( )

staticprivate

Generates or retrieves the cache integrity key. This key is unique per session to prevent cross-session cache tampering.

Returns

string The cache integrity key

Definition at line 182 of file class.cache.php.

    {
        if (self::$cacheIntegrityKey === null) {
            global $bearsamppRoot;
 
            // Try to load existing key from session file
            if (isset($bearsamppRoot)) {
                $keyFile = Path::getTmpPath() . '/cache_integrity.key';
 
                if (file_exists($keyFile)) {
                    $key = @file_get_contents($keyFile);
                    if ($key !== false && strlen($key) === 64) {
                        self::$cacheIntegrityKey = $key;
                        return self::$cacheIntegrityKey;
                    }
                }
 
                // Generate new key if none exists or invalid
                try {
                    self::$cacheIntegrityKey = bin2hex(random_bytes(32));
                    @file_put_contents($keyFile, self::$cacheIntegrityKey, LOCK_EX);
                } catch (Exception $e) {
                    Log::error('Failed to generate cache integrity key: ' . $e->getMessage());
                    // Fallback to a less secure but functional key
                    self::$cacheIntegrityKey = hash('sha256', uniqid('bearsampp_cache_', true));
                }
            } else {
                // Fallback if bearsamppRoot not available
                try {
                    self::$cacheIntegrityKey = bin2hex(random_bytes(32));
                } catch (Exception $e) {
                    self::$cacheIntegrityKey = hash('sha256', uniqid('bearsampp_cache_', true));
                }
            }
        }
 
        return self::$cacheIntegrityKey;
    }

References $bearsamppRoot, Log\error(), and Path\getTmpPath().

Referenced by generateCacheHMAC().

Here is the call graph for this function:

Here is the caller graph for this function:

getDuration()

getDuration ( )

static

Gets the current file scan cache duration.

Returns

int Cache duration in seconds

Definition at line 329 of file class.cache.php.

    {
        return self::$fileScanCacheDuration;
    }

getStats()

getStats ( )

static

Gets file scan cache statistics.

Returns

array Array containing hits, misses, and invalidations counts

Definition at line 304 of file class.cache.php.

    {
        return self::$fileScanStats;
    }

recordHit()

recordHit ( )

static

Records a cache hit for statistics tracking.

Returns

void

Definition at line 339 of file class.cache.php.

    {
        self::$fileScanStats['hits']++;
    }

Referenced by Util\getFilesToScan().

Here is the caller graph for this function:

recordMiss()

recordMiss ( )

static

Records a cache miss for statistics tracking.

Returns

void

Definition at line 349 of file class.cache.php.

    {
        self::$fileScanStats['misses']++;
    }

Referenced by Util\getFilesToScan().

Here is the caller graph for this function:

set()

set ( $cacheKey, $data )

static

Stores file scan results in cache with integrity protection.

Parameters

string	$cacheKey	The cache key to store under.
array	$data	The scan results to cache.

Returns

void

Definition at line 147 of file class.cache.php.

    {
        global $bearsamppRoot;
 
        // Generate HMAC for integrity verification
        $hmac = self::generateCacheHMAC($data, $cacheKey);
 
        $cacheData = [
            'timestamp' => time(),
            'data' => $data,
            'hmac' => $hmac
        ];
 
        // Store in memory cache
        if (self::$fileScanCache === null) {
            self::$fileScanCache = [];
        }
        self::$fileScanCache[$cacheKey] = $cacheData;
 
        // Store in file cache
        if (isset($bearsamppRoot)) {
            $cacheFile = Path::getTmpPath() . '/filescan_cache_' . $cacheKey . '.dat';
            // JSON is used instead of serialize() to eliminate the PHP object-injection
            // attack surface entirely – no magic methods can fire during json_decode().
            @file_put_contents($cacheFile, json_encode($cacheData), LOCK_EX);
            Log::debug('File scan results cached to: ' . $cacheFile);
        }
    }

References $bearsamppRoot, Log\debug(), generateCacheHMAC(), and Path\getTmpPath().

Referenced by Util\getFilesToScan().

Here is the call graph for this function:

Here is the caller graph for this function:

setDuration()

setDuration ( $seconds )

static

Sets the file scan cache duration.

Parameters

int

$seconds

Cache duration in seconds (default: 3600 = 1 hour).

Returns

void

Definition at line 316 of file class.cache.php.

    {
        if ($seconds > 0 && $seconds <= 86400) { // Max 24 hours
            self::$fileScanCacheDuration = $seconds;
            Log::debug('File scan cache duration set to ' . $seconds . ' seconds');
        }
    }

References Log\debug().

Here is the call graph for this function:

verifyCacheIntegrity()

verifyCacheIntegrity ( $fileContents, $cacheKey )

staticprivate

Verifies cache file integrity using HMAC.

Parameters

string	$fileContents	The JSON-encoded cache file contents
string	$cacheKey	The cache key

Returns

bool True if integrity check passes, false otherwise

Definition at line 246 of file class.cache.php.

    {
        // Decode with json_decode() – unlike unserialize(), this cannot
        // instantiate PHP objects or invoke any magic methods, so it is safe
        // to call before the HMAC is confirmed.
        $cacheData = @json_decode($fileContents, true);
 
        if (!is_array($cacheData)
            || !isset($cacheData['hmac']) || !is_string($cacheData['hmac'])
            || !isset($cacheData['data']) || !is_array($cacheData['data'])
        ) {
            return false;
        }
 
        $expectedHmac = self::generateCacheHMAC($cacheData['data'], $cacheKey);
 
        // Use hash_equals to prevent timing attacks
        return hash_equals($expectedHmac, $cacheData['hmac']);
    }

References generateCacheHMAC().

Here is the call graph for this function:

Field Documentation

$cacheIntegrityKey

$cacheIntegrityKey = null

staticprivate

Definition at line 56 of file class.cache.php.

$fileScanCache

$fileScanCache = null

staticprivate

Definition at line 33 of file class.cache.php.

$fileScanCacheDuration

$fileScanCacheDuration = 3600

staticprivate

Definition at line 39 of file class.cache.php.

$fileScanStats

$fileScanStats

staticprivate

Initial value:

                              = [
    'hits' => 0,
    'misses' => 0,
    'invalidations' => 0
]

Definition at line 45 of file class.cache.php.

---

The documentation for this class was generated from the following file:

• E:/Bearsampp-development/sandbox/core/classes/class.cache.php