unstorage@1.17.3 security report

The builtinDrivers object maps driver names to module specifiers (e.g., 'unstorage/drivers/fs', 'unstorage/drivers/http'). These strings are later used in dynamic require() calls by the package's resolver logic (not shown in this file). While the driver names are not directly attacker-controlled in this file, the pattern of mapping user-provided driver names to dynamic imports is a common vector if the resolver does not validate the driver string. This is a design-level concern rather than a confirmed vulnerability in the provided code.

The GET handler for base keys calls storage.getKeys(key) and maps over all results without pagination or limits. For large storage backends, this could lead to memory exhaustion or excessive response sizes.

The H3 app is created with debug: true, which may leak sensitive error details, stack traces, or internal information to clients in production environments.

The driver accepts an accountKey option and passes it to the CosmosClient. This is expected behavior for authentication, not exfiltration. Credentials are not harvested from environment files or sent to external servers.

The getKeys and clear methods use static SQL queries with no user input, so no injection risk.

The driver accepts multiple credential types (account key, SAS URL, SAS key, connection string, DefaultAzureCredential) and stores them in options. While this is expected for a storage driver, improper handling could lead to credential leakage if options are logged or exposed.

The getItem and getItemRaw methods catch all errors and return null, potentially hiding failures that could indicate security issues or misconfigurations.

The code sets a global flag globalThis[kExperimentalWarning] to avoid repeated warnings. This is not malicious but modifies global state, which could be considered poor practice.

The table name is interpolated directly into SQL strings using template literal syntax (e.g., INSERT INTO {${opts.tableName}}). While the {...} syntax is likely transformed by the database driver into a safe identifier, if opts.tableName is attacker-controlled and the driver does not properly quote it, this could allow identifier injection. However, the values themselves use parameterized placeholders (${key}, ${value}), and the table name is typically controlled by the application developer, not end users.

The code logs a warning to the console once when the driver is first used. This is benign and not a security concern.

The code requires 'chokidar' and 'anymatch', which are external dependencies. If these packages are compromised or substituted, they could introduce malicious behavior. However, this is standard dependency usage, not an inherent flaw in this file.

The driver performs file system operations (read/write/delete) within the configured base directory. This is expected functionality for a file system driver and does not constitute malicious behavior.

The code includes explicit checks (PATH_TRAVERSE_RE) to prevent directory traversal via '..' segments in keys, which is a security measure.

URLs are built from user-provided repo, branch, dir, apiURL, and cdnURL options. If an attacker can control these options, they could redirect requests to arbitrary servers. However, this is inherent to the driver's configurable design and not a malicious pattern in itself.

The driver sends HTTP requests to GitHub's API and raw content endpoints, optionally including an Authorization token from the driver options. This is expected for a GitHub storage driver and does not constitute exfiltration; the token is only sent to the configured GitHub URLs.

The code executes SET @@boost_cached_queries = true; when opts.boostCache is set. This is a legitimate PlanetScale feature to enable query caching, but it demonstrates that the driver can execute arbitrary SQL statements at initialization. This is not inherently malicious but worth noting as it shows the driver executes SQL beyond standard CRUD operations.

The driver reads credentials (UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN) from environment variables. This is standard practice for configuring clients and not inherently malicious, but it should be noted that the code accesses process.env.

The driver creates a Redis client that communicates with an external Upstash Redis instance. This is expected behavior for a storage driver, but it does involve external network requests.

The code reads a token from an environment variable (e.g., BLOB_READ_WRITE_TOKEN) and uses it for API authentication. While this is standard for legitimate drivers, it could be a vector for credential harvesting if the package is malicious or compromised. The token is used to access Vercel Blob storage.

In getKeys, a RegExp is constructed using optsBase without escaping special characters. If optsBase contains regex metacharacters, it could cause unexpected behavior or errors. This is a minor robustness issue, not a direct security vulnerability.

The code uses globalThis.process?.getBuiltinModule?.('node:module') to obtain createRequire, a relatively new API. This allows constructing require functions at runtime, which can be a vector for loading modules in a non-standard way. Not inherently malicious, but worth monitoring.

The module exports a driver factory, but importing the file defines getCache/tryRequireVCFunctions. The tryRequireVCFunctions function lazily loads '@vercel/functions', which if malicious could execute arbitrary code on first cache access. The overall purpose (Vercel runtime cache driver) is consistent with a legitimate cache driver.

Accesses globalThis.process.getBuiltinModule('node:module') and Symbol.for('@vercel/request-context') on globalThis. This is used to obtain the runtime cache context from Vercel's serverless environment. It does not harvest environment variables or credentials, but relies on globals that could be manipulated by other code running in the same process.