Permalinks: look up from index if cache empty

config/routes.php

@@ -8,6 +8,7 @@
 use Kirby\Panel\Plugins;
 use Kirby\Toolkit\Str;
 use Kirby\Uuid\Uuid;
+use Kirby\Uuid\Uuids;
 
 return function (App $kirby) {
 	$api   = $kirby->option('api.slug', 'api');
@@ -135,11 +136,17 @@
 			'method'  => 'ALL',
 			'env'     => 'site',
 			'action'  => function (string $type, string $id) use ($kirby) {
-				// try to resolve to model, but only from UUID cache;
-				// this ensures that only existing UUIDs can be queried
-				// and attackers can't force Kirby to go through the whole
-				// site index with a non-existing UUID
-				if ($model = Uuid::for($type . '://' . $id)?->model(true)) {
+				// try to resolve to model but if the UUID cache exists
+				// only allow lookup from the cache;
+				// only if the cache doesn't exist, use the index;
+				// this ensures that attackers can't force Kirby to go through
+				// the whole site index with a non-existing UUID
+				$lazy = Uuids::cache()->isEmpty() === false;
+
+				if ($model = Uuid::for($type . '://' . $id)?->model($lazy)) {
+					/**
+					 * @var \Kirby\Cms\Page|\Kirby\Cms\File $model
+					 */
 					return $kirby
 						->response()
 						->redirect($model->url());

src/Cache/ApcuCache.php

@@ -45,6 +45,21 @@
 		return apcu_clear_cache();
 	}
 
+	/**
+	 * Whether the cache has any entry,
+	 * irrespective whether the entries have expired or not
+	 */
+	public function isEmpty(): bool
+	{
+		if (empty($this->options['prefix']) === false) {
+			$iterator = new APCUIterator('!^' . preg_quote($this->options['prefix']) . '!');
+		} else {
+			$iterator = new APCUIterator();
+		}
+
+		return $iterator->getTotalCount() === 0;
+	}
+
 	/**
 	 * Removes an item from the cache and returns
 	 * whether the operation was successful

src/Cache/Cache.php

@@ -18,17 +18,12 @@
  */
 abstract class Cache
 {
-	/**
-	 * Stores all options for the driver
-	 */
-	protected array $options = [];
-
 	/**
 	 * Sets all parameters which are needed to connect to the cache storage
 	 */
-	public function __construct(array $options = [])
-	{
-		$this->options = $options;
+	public function __construct(
+		protected array $options = []
+	) {
 	}
 
 	/**
@@ -182,6 +177,12 @@ public function getOrSet(
 		return $result;
 	}
 
+	/**
+	 * Whether the cache has any entry,
+	 * irrespective whether the entries have expired or not
+	 */
+	abstract public function isEmpty(): bool;
+
 	/**
 	 * Adds the prefix to the key if given
 	 */

src/Cache/FileCache.php

@@ -30,8 +30,9 @@ class FileCache extends Cache
 	 *                       'prefix' (default: none)
 	 *                       'extension' (file extension for cache files, default: none)
 	 */
-	public function __construct(array $options)
-	{
+	public function __construct(
+		array $options
+	) {
 		parent::__construct([
 			'root'      => null,
 			'prefix'    => null,
@@ -51,20 +52,28 @@ public function __construct(array $options)
 	}
 
 	/**
-	 * Returns whether the cache is ready to
-	 * store values
+	 * Checks when the cache has been created;
+	 * returns the creation timestamp on success
+	 * and false if the item does not exist
 	 */
-	public function enabled(): bool
+	public function created(string $key): int|false
 	{
-		return is_writable($this->root) === true;
+		// use the modification timestamp
+		// as indicator when the cache has been created/overwritten
+		clearstatcache();
+
+		// get the file for this cache key
+		$file = $this->file($key);
+		return file_exists($file) ? filemtime($file) : false;
 	}
 
 	/**
-	 * Returns the full root including prefix
+	 * Returns whether the cache is ready to
+	 * store values
 	 */
-	public function root(): string
+	public function enabled(): bool
 	{
-		return $this->root;
+		return is_writable($this->root) === true;
 	}
 
 	/**
@@ -116,47 +125,28 @@ protected function file(string $key): string
 	}
 
 	/**
-	 * Writes an item to the cache for a given number of minutes and
-	 * returns whether the operation was successful
-	 *
-	 * <code>
-	 *   // put an item in the cache for 15 minutes
-	 *   $cache->set('value', 'my value', 15);
-	 * </code>
-	 */
-	public function set(string $key, $value, int $minutes = 0): bool
-	{
-		$file = $this->file($key);
-
-		return F::write($file, (new Value($value, $minutes))->toJson());
-	}
-
-	/**
-	 * Internal method to retrieve the raw cache value;
-	 * needs to return a Value object or null if not found
+	 * Flushes the entire cache and returns
+	 * whether the operation was successful
 	 */
-	public function retrieve(string $key): Value|null
+	public function flush(): bool
 	{
-		$file  = $this->file($key);
-		$value = F::read($file);
+		if (
+			Dir::remove($this->root) === true &&
+			Dir::make($this->root) === true
+		) {
+			return true;
+		}
 
-		return $value ? Value::fromJson($value) : null;
+		return false; // @codeCoverageIgnore
 	}
 
 	/**
-	 * Checks when the cache has been created;
-	 * returns the creation timestamp on success
-	 * and false if the item does not exist
+	 * Whether the cache has any entry,
+	 * irrespective whether the entries have expired or not
 	 */
-	public function created(string $key): int|false
+	public function isEmpty(): bool
 	{
-		// use the modification timestamp
-		// as indicator when the cache has been created/overwritten
-		clearstatcache();
-
-		// get the file for this cache key
-		$file = $this->file($key);
-		return file_exists($file) ? filemtime($file) : false;
+		return Dir::isEmpty($this->root);
 	}
 
 	/**
@@ -209,18 +199,38 @@ protected function removeEmptyDirectories(string $dir): void
 	}
 
 	/**
-	 * Flushes the entire cache and returns
-	 * whether the operation was successful
+	 * Internal method to retrieve the raw cache value;
+	 * needs to return a Value object or null if not found
 	 */
-	public function flush(): bool
+	public function retrieve(string $key): Value|null
 	{
-		if (
-			Dir::remove($this->root) === true &&
-			Dir::make($this->root) === true
-		) {
-			return true;
-		}
+		$file  = $this->file($key);
+		$value = F::read($file);
 
-		return false; // @codeCoverageIgnore
+		return $value ? Value::fromJson($value) : null;
+	}
+
+	/**
+	 * Returns the full root including prefix
+	 */
+	public function root(): string
+	{
+		return $this->root;
+	}
+
+	/**
+	 * Writes an item to the cache for a given number of minutes and
+	 * returns whether the operation was successful
+	 *
+	 * <code>
+	 *   // put an item in the cache for 15 minutes
+	 *   $cache->set('value', 'my value', 15);
+	 * </code>
+	 */
+	public function set(string $key, $value, int $minutes = 0): bool
+	{
+		$file = $this->file($key);
+
+		return F::write($file, (new Value($value, $minutes))->toJson());
 	}
 }

src/Cache/MemCached.php

@@ -32,8 +32,9 @@ class MemCached extends Cache
 	 *                       'port'   (default: 11211)
 	 *                       'prefix' (default: null)
 	 */
-	public function __construct(array $options = [])
-	{
+	public function __construct(
+		array $options = []
+	) {
 		parent::__construct([
 			'host'    => 'localhost',
 			'port'    => 11211,
@@ -58,30 +59,22 @@ public function enabled(): bool
 	}
 
 	/**
-	 * Writes an item to the cache for a given number of minutes and
-	 * returns whether the operation was successful
-	 *
-	 * <code>
-	 *   // put an item in the cache for 15 minutes
-	 *   $cache->set('value', 'my value', 15);
-	 * </code>
+	 * Flushes the entire cache and returns
+	 * whether the operation was successful;
+	 * WARNING: Memcached only supports flushing the whole cache at once!
 	 */
-	public function set(string $key, $value, int $minutes = 0): bool
+	public function flush(): bool
 	{
-		$key     = $this->key($key);
-		$value   = (new Value($value, $minutes))->toJson();
-		$expires = $this->expiration($minutes);
-		return $this->connection->set($key, $value, $expires);
+		return $this->connection->flush();
 	}
 
 	/**
-	 * Internal method to retrieve the raw cache value;
-	 * needs to return a Value object or null if not found
+	 * Whether the cache has any entry,
+	 * irrespective whether the entries have expired or not
 	 */
-	public function retrieve(string $key): Value|null
+	public function isEmpty(): bool
 	{
-		$value = $this->connection->get($this->key($key));
-		return Value::fromJson($value);
+		return count($this->connection->getAllKeys()) === 0;
 	}
 
 	/**
@@ -94,12 +87,29 @@ public function remove(string $key): bool
 	}
 
 	/**
-	 * Flushes the entire cache and returns
-	 * whether the operation was successful;
-	 * WARNING: Memcached only supports flushing the whole cache at once!
+	 * Internal method to retrieve the raw cache value;
+	 * needs to return a Value object or null if not found
 	 */
-	public function flush(): bool
+	public function retrieve(string $key): Value|null
 	{
-		return $this->connection->flush();
+		$value = $this->connection->get($this->key($key));
+		return Value::fromJson($value);
+	}
+
+	/**
+	 * Writes an item to the cache for a given number of minutes and
+	 * returns whether the operation was successful
+	 *
+	 * <code>
+	 *   // put an item in the cache for 15 minutes
+	 *   $cache->set('value', 'my value', 15);
+	 * </code>
+	 */
+	public function set(string $key, $value, int $minutes = 0): bool
+	{
+		$key     = $this->key($key);
+		$value   = (new Value($value, $minutes))->toJson();
+		$expires = $this->expiration($minutes);
+		return $this->connection->set($key, $value, $expires);
 	}
 }

src/Cache/MemoryCache.php

@@ -28,27 +28,22 @@ public function enabled(): bool
 	}
 
 	/**
-	 * Writes an item to the cache for a given number of minutes and
-	 * returns whether the operation was successful
-	 *
-	 * <code>
-	 *   // put an item in the cache for 15 minutes
-	 *   $cache->set('value', 'my value', 15);
-	 * </code>
+	 * Flushes the entire cache and returns
+	 * whether the operation was successful
 	 */
-	public function set(string $key, $value, int $minutes = 0): bool
+	public function flush(): bool
 	{
-		$this->store[$key] = new Value($value, $minutes);
+		$this->store = [];
 		return true;
 	}
 
 	/**
-	 * Internal method to retrieve the raw cache value;
-	 * needs to return a Value object or null if not found
+	 * Whether the cache has any entry,
+	 * irrespective whether the entries have expired or not
 	 */
-	public function retrieve(string $key): Value|null
+	public function isEmpty(): bool
 	{
-		return $this->store[$key] ?? null;
+		return count($this->store) === 0;
 	}
 
 	/**
@@ -66,12 +61,26 @@ public function remove(string $key): bool
 	}
 
 	/**
-	 * Flushes the entire cache and returns
-	 * whether the operation was successful
+	 * Internal method to retrieve the raw cache value;
+	 * needs to return a Value object or null if not found
 	 */
-	public function flush(): bool
+	public function retrieve(string $key): Value|null
 	{
-		$this->store = [];
+		return $this->store[$key] ?? null;
+	}
+
+	/**
+	 * Writes an item to the cache for a given number of minutes and
+	 * returns whether the operation was successful
+	 *
+	 * <code>
+	 *   // put an item in the cache for 15 minutes
+	 *   $cache->set('value', 'my value', 15);
+	 * </code>
+	 */
+	public function set(string $key, $value, int $minutes = 0): bool
+	{
+		$this->store[$key] = new Value($value, $minutes);
 		return true;
 	}
 }