Files
llama.cpp/tools/server/tests/unit/test_security.py
T
Aleksander Grygier 3a7660371d ui: move the web UI to ui/apps/chat and call it Llama Chat (#32032)
* ui: move tools/ui to ui/apps/chat

The chat app moves to its own root folder, ui/apps/chat, as the first step of splitting the UI into one library
(ui/lib) and the apps built on it (ui/apps). The code is unchanged; every path that pointed at tools/ui now points at
ui/apps/chat: CMake adds it from tools/, and the Dockerfiles, the Nix package, the workflows, the labeler, CODEOWNERS,
.editorconfig, the git hooks, the dev and demo scripts and the docs follow it.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: name Llama Chat's package @ggml-org/llama-chat

It was still called llama-ui, the name of the library that now sits beside it
in ui/lib (@ggml-org/llama-ui). The package stays private; the app's display name
and the llama-ui.zip build artifact are unchanged.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: call the built-in web UI Llama Chat in docs, help text and comments

The app in tools/ui is Llama Chat; Llama UI is the component library it is
built from. Prose that said "Web UI", "web UI" or "WebUI" for the app now
names it: the READMEs, SECURITY.md, the --ui help text, the CMake option
description, one server log line, code comments and the Storybook intro.

Names that others depend on are unchanged: the deprecated --webui flag
aliases, the LLAMA_*_WEBUI CMake and environment names, the webui_settings
field, the storage migration keys and the Nix attributes.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: name tools/ui as a former path of Llama Chat in the code-review skill

Changes under the old tools/ui path, as well as tools/server/webui, still
get the Llama Chat checklist.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: name Llama Chat's path in the security policy's exclusions

Llama Chat no longer lives under tools/server/, so the exclusion listed
under it now names ui/apps/chat. What is covered stays the same.

Assisted-by: Claude (Opus 5.5 Medium)
2026-11-16 17:23:36 +01:00

370 lines
13 KiB
Python

import pytest
from openai import OpenAI
from utils import *
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
server = ServerPreset.tinyllama2()
TEST_API_KEY = "sk-this-is-the-secret-key"
@pytest.fixture(autouse=True)
def create_server():
global server
server = ServerPreset.tinyllama2()
server.api_key = TEST_API_KEY
@pytest.mark.parametrize("endpoint", ["/health"])
def test_access_public_endpoint(endpoint: str):
global server
server.start()
res = server.make_request("GET", endpoint)
assert res.status_code == 200
assert "error" not in res.body
def test_access_static_assets_without_api_key():
"""Static Llama Chat assets should not require API key authentication (issue #21229)"""
global server
server.start()
for path in ["/", "/sw.js", "/manifest.webmanifest", "/_app/version.json"]:
res = server.make_request("GET", path)
assert res.status_code == 200, f"Expected 200 for {path}, got {res.status_code}"
@pytest.mark.parametrize("api_key", [None, "invalid-key"])
def test_incorrect_api_key(api_key: str):
global server
server.start()
res = server.make_request("POST", "/completions", data={
"prompt": "I believe the meaning of life is",
}, headers={
"Authorization": f"Bearer {api_key}" if api_key else None,
})
assert res.status_code == 401
assert "error" in res.body
assert res.body["error"]["type"] == "authentication_error"
def test_correct_api_key():
global server
server.start()
res = server.make_request("POST", "/completions", data={
"prompt": "I believe the meaning of life is",
}, headers={
"Authorization": f"Bearer {TEST_API_KEY}",
})
assert res.status_code == 200
assert "error" not in res.body
assert "content" in res.body
def test_correct_api_key_anthropic_header():
global server
server.start()
res = server.make_request("POST", "/completions", data={
"prompt": "I believe the meaning of life is",
}, headers={
"X-Api-Key": TEST_API_KEY,
})
assert res.status_code == 200
assert "error" not in res.body
assert "content" in res.body
def test_openai_library_correct_api_key():
global server
server.start()
client = OpenAI(api_key=TEST_API_KEY, base_url=f"http://{server.server_host}:{server.server_port}")
res = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "You are a chatbot."},
{"role": "user", "content": "What is the meaning of life?"},
],
)
assert len(res.choices) == 1
@pytest.mark.parametrize("origin,cors_header,cors_header_value", [
("localhost", "Access-Control-Allow-Origin", "localhost"),
("web.mydomain.fr", "Access-Control-Allow-Origin", "web.mydomain.fr"),
("origin", "Access-Control-Allow-Credentials", "true"),
("web.mydomain.fr", "Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS"),
("web.mydomain.fr", "Access-Control-Allow-Headers", "*"),
])
def test_cors_options(origin: str, cors_header: str, cors_header_value: str):
global server
server.start()
res = server.make_request("OPTIONS", "/completions", headers={
"Origin": origin,
"Access-Control-Request-Method": "POST",
"Access-Control-Request-Headers": "Authorization",
})
assert res.status_code == 200
assert cors_header in res.headers
assert res.headers[cors_header] == cors_header_value
@pytest.mark.parametrize("origin", [
"http://localhost",
"http://localhost:8080",
"http://127.0.0.1:3000",
"http://[::1]:3000",
"http://evil.com",
"http://localhost.evil.com",
])
def test_cors_origins_localhost_no_cross_origin_header(origin: str):
global server
server = ServerPreset.router()
server.cors_origins = "localhost"
server.start()
res = server.make_request("OPTIONS", "/completions", headers={
"Origin": origin,
"Access-Control-Request-Method": "POST",
"Access-Control-Request-Headers": "Authorization",
})
assert res.status_code == 200
assert "Access-Control-Allow-Origin" not in res.headers
@pytest.mark.parametrize("feature", ["server_tools", "ui_mcp_proxy"])
def test_cors_origins_defaults_to_localhost(feature: str):
global server
server = ServerPreset.router()
if feature == "server_tools":
server.server_tools = "all"
else:
server.ui_mcp_proxy = True
server.start()
res = server.make_request("GET", "/props", headers={"Origin": f"http://127.0.0.1:{server.server_port}"})
assert res.status_code == 200
res = server.make_request("GET", "/props", headers={"Origin": "http://localhost:5173"})
assert res.status_code == 403
def _raw_post(path: str, body: str, headers: dict) -> requests.Response:
# text/plain: "simple" request, no CORS preflight
return requests.post(server.make_url(path), data=body, headers={"Content-Type": "text/plain", **headers})
@pytest.mark.parametrize("headers,expected_status", [
({}, 200), # non-browser client
({"Origin": "http://127.0.0.1:{port}"}, 200), # same-origin
({"Origin": "http://localhost:3000"}, 403), # other localhost app
({"Origin": "http://evil.com"}, 403), # cross-origin simple request
({"Origin": "http://localhost.evil.com"}, 403),
({"Origin": "null"}, 403), # sandboxed iframe / file://
({"Sec-Fetch-Site": "cross-site", "Sec-Fetch-Mode": "no-cors"}, 403),
])
def test_cors_origins_localhost_blocks_simple_requests(headers: dict, expected_status: int):
global server
server.api_key = None
server.cors_origins = "localhost"
server.start()
headers = {k: v.format(port=server.server_port) for k, v in headers.items()}
res = _raw_post("/tokenize", '{"content": "hello"}', headers)
assert res.status_code == expected_status
def test_cors_origins_localhost_allows_same_origin():
global server
server.api_key = None
server.cors_origins = "localhost"
server.server_host = "0.0.0.0"
server.start()
lan_ip = get_lan_ip(server)
if lan_ip is None:
pytest.skip("no LAN address reachable from this host") # ty: ignore[too-many-positional-arguments]
# UI opened via LAN address: Origin matches Host
url = server.make_url("/tokenize", host=lan_ip)
res = requests.post(url, data='{"content": "hello"}', timeout=DEFAULT_REQUEST_TIMEOUT, headers={
"Content-Type": "text/plain",
"Origin": f"http://{lan_ip}:{server.server_port}",
})
assert res.status_code == 200
@pytest.mark.parametrize("host,headers,expected_status", [
("localhost", {}, 200),
("127.0.0.1", {}, 200),
("127.0.0.2", {}, 200),
("[::1]", {}, 200),
("0.0.0.0", {}, 200),
("evil.com", {"Origin": "http://evil.com:{port}"}, 403), # rebinding, Origin matches Host
("evil.com", {"Sec-Fetch-Site": "same-origin"}, 403), # rebinding, same-origin GET has no Origin
("127.0.0.1.evil.com", {}, 403),
("localhost.evil.com", {}, 403),
])
def test_cors_origins_localhost_blocks_dns_rebinding(host: str, headers: dict, expected_status: int):
global server
server.api_key = None
server.cors_origins = "localhost"
server.start()
port = server.server_port
headers = {k: v.format(port=port) for k, v in headers.items()}
res = _raw_post("/tokenize", '{"content": "hello"}', {"Host": f"{host}:{port}", **headers})
assert res.status_code == expected_status
def test_cors_origins_explicit_list_allows_its_hosts():
global server
server.api_key = None
server.cors_origins = "https://ia.example.com"
server.start()
# reverse proxy that keeps the Host of the public name
for host, expected_status in [
("ia.example.com", 200),
("evil.com", 403),
]:
res = _raw_post("/tokenize", '{"content": "hello"}', {"Host": host, "Origin": f"https://{host}"})
assert res.status_code == expected_status, host
def test_cors_origins_explicit_list_blocks_simple_requests():
global server
server.api_key = None
server.cors_origins = "https://a.example, https://b.example"
server.start()
for origin, expected_status in [
("https://a.example", 200),
("https://b.example", 200),
("https://c.example", 403),
]:
res = _raw_post("/tokenize", '{"content": "hello"}', {"Origin": origin})
assert res.status_code == expected_status, origin
def test_cors_origins_wildcard_keeps_allowing_all():
global server
server.api_key = None
server.cors_origins = "*"
server.start()
res = _raw_post("/tokenize", '{"content": "hello"}', {"Origin": "http://evil.com"})
assert res.status_code == 200
def test_cors_cross_site_navigation_to_ui_allowed():
global server
server.api_key = None
server.cors_origins = "localhost"
server.start()
nav = {"Sec-Fetch-Site": "cross-site", "Sec-Fetch-Mode": "navigate"}
# UI may not be built in tests, only check it is not refused
assert requests.get(server.make_url("/"), headers=nav).status_code != 403
assert requests.get(server.make_url("/props"), headers=nav).status_code == 403
def test_tools_drive_by_exec_is_blocked():
global server
server.api_key = None
server.server_tools = "exec_shell_command" # implies --cors-origins localhost
server.start()
body = '{"tool": "exec_shell_command", "params": {"command": "echo csrf-guard-test"}}'
res = _raw_post("/tools", body, {"Origin": "http://evil.com"})
assert res.status_code == 403
assert "csrf-guard-test" not in res.text
res = _raw_post("/tools", body, {"Origin": "http://localhost:5173"})
assert res.status_code == 403
res = _raw_post("/tools", body, {"Origin": f"http://127.0.0.1:{server.server_port}"})
assert res.status_code == 200
assert "csrf-guard-test" in res.text
@pytest.mark.parametrize("server_host,api_key,allow_unauth,should_start", [
("127.0.0.1", None, False, True),
("0.0.0.0", None, False, False),
("0.0.0.0", TEST_API_KEY, False, True),
("0.0.0.0", None, True, True),
])
def test_tools_refuse_unauthenticated_network_bind(server_host: str, api_key: str | None, allow_unauth: bool, should_start: bool):
global server
server = ServerPreset.router()
server.server_tools = "all"
server.server_host = server_host
server.api_key = api_key
server.allow_unauthenticated_tools = allow_unauth
if should_start:
server.start()
else:
with pytest.raises(RuntimeError):
server.start()
def test_cors_proxy_only_forwards_explicit_proxy_headers():
class CaptureHeadersHandler(BaseHTTPRequestHandler):
def do_GET(self):
self.server.captured_headers = dict(self.headers)
self.send_response(200)
self.end_headers()
self.wfile.write(b"ok")
def log_message(self, format, *args):
pass
target = ThreadingHTTPServer(("127.0.0.1", 0), CaptureHeadersHandler)
target.captured_headers = {}
target_thread = threading.Thread(target=target.serve_forever, daemon=True)
target_thread.start()
try:
server = ServerPreset.tinyllama2()
server.api_key = TEST_API_KEY
server.ui_mcp_proxy = True
server.debug_proxy_allow_private = True
server.start()
res = server.make_request("GET", f"/cors-proxy?url=http://127.0.0.1:{target.server_port}/capture", headers={
"Authorization": f"Bearer {TEST_API_KEY}",
"Proxy-Authorization": "Basic secret",
"X-Api-Key": TEST_API_KEY,
"Cookie": "session=secret",
"x-llama-server-proxy-header-accept": "application/json",
"x-llama-server-proxy-header-authorization": "Bearer explicit",
})
assert res.status_code == 200
captured = {key.lower(): value for key, value in target.captured_headers.items()}
assert captured["accept"] == "application/json"
assert captured["authorization"] == "Bearer explicit"
assert "proxy-authorization" not in captured
assert "x-api-key" not in captured
assert "cookie" not in captured
finally:
target.shutdown()
target.server_close()
@pytest.mark.parametrize(
"media_path, image_url, success",
[
(None, "file://mtmd/test-1.jpeg", False), # disabled media path, should fail
("../../../tools", "file://mtmd/test-1.jpeg", True),
("../../../tools", "file:////mtmd//test-1.jpeg", True), # should be the same file as above
("../../../tools", "file://mtmd/notfound.jpeg", False), # non-existent file
("../../../tools", "file://../mtmd/test-1.jpeg", False), # no directory traversal
]
)
def test_local_media_file(media_path, image_url, success,):
server = ServerPreset.tinygemma3()
server.media_path = media_path
server.start()
res = server.make_request("POST", "/chat/completions", data={
"max_tokens": 1,
"messages": [
{"role": "user", "content": [
{"type": "text", "text": "test"},
{"type": "image_url", "image_url": {
"url": image_url,
}},
]},
],
})
if success:
assert res.status_code == 200
else:
assert res.status_code == 400