452 lines
17 KiB
Python
452 lines
17 KiB
Python
"""Granted readers see linked originals only through the owner's stored connector."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
|
|
import app.sources as sources
|
|
from tests.support import ORIGIN, Actor, register
|
|
|
|
OWNER_TOKEN = "owner-paperless-token"
|
|
GRANTEE_TOKEN = "grantee-paperless-token"
|
|
OWNER_MAIL = "owner-postfach-geheim"
|
|
GRANTEE_MAIL = "grantee-postfach-geheim"
|
|
UNAVAILABLE = "Das Original ist über die Freigabe nicht abrufbar."
|
|
|
|
|
|
class RecordingIMAP:
|
|
logins: list[str] = []
|
|
fetches: list[int] = []
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
pass
|
|
|
|
def login(self, username, secret):
|
|
RecordingIMAP.logins.append(secret)
|
|
return "OK", [b"logged"]
|
|
|
|
def list(self):
|
|
return "OK", [b'(\\HasNoChildren) "/" "INBOX"']
|
|
|
|
def select(self, mailbox, readonly=False):
|
|
return "OK", [b"5"]
|
|
|
|
def uid(self, command, *args):
|
|
if command == "SEARCH":
|
|
return "OK", [b""]
|
|
uid = int(args[0])
|
|
spec = " ".join(str(part) for part in args[1:])
|
|
if "BODY.PEEK[]" in spec:
|
|
RecordingIMAP.fetches.append(uid)
|
|
raw = (
|
|
f"From: Ada Beispiel <ada@example.test>\r\n"
|
|
f"To: Kanzlei <kanzlei@example.test>\r\n"
|
|
f"Subject: Nachricht {uid}\r\n"
|
|
f"Date: Thu, 02 May 2024 08:00:00 +0000\r\n"
|
|
f"Message-ID: <{uid}@example.test>\r\n"
|
|
f"MIME-Version: 1.0\r\n"
|
|
f'Content-Type: multipart/mixed; boundary="grenze"\r\n'
|
|
f"\r\n"
|
|
f"--grenze\r\n"
|
|
f"Content-Type: text/plain; charset=utf-8\r\n"
|
|
f"\r\n"
|
|
f"Bitte die Einwendung pruefen.\r\n"
|
|
f"--grenze\r\n"
|
|
f"Content-Type: application/pdf\r\n"
|
|
f'Content-Disposition: attachment; filename="einwendung.pdf"\r\n'
|
|
f"\r\n"
|
|
f"%PDF\r\n"
|
|
f"--grenze--\r\n"
|
|
).encode()
|
|
return "OK", [(b"rfc822", raw)]
|
|
return "OK", [(b"body", b"From: Ada\r\n"), b")"]
|
|
|
|
def logout(self):
|
|
return "BYE", [b""]
|
|
|
|
|
|
def _reset_imap():
|
|
RecordingIMAP.logins = []
|
|
RecordingIMAP.fetches = []
|
|
|
|
|
|
def _paperless(actor: Actor, token: str, name: str) -> str:
|
|
return actor.request(
|
|
"POST",
|
|
"/api/v1/connectors",
|
|
json={"kind": "paperless", "name": name, "base_url": "https://paper.example.test", "token": token},
|
|
status=201,
|
|
)["id"]
|
|
|
|
|
|
def _mailbox(actor: Actor, password: str, name: str) -> str:
|
|
return actor.request(
|
|
"POST",
|
|
"/api/v1/connectors",
|
|
json={
|
|
"kind": "imap",
|
|
"name": name,
|
|
"host": "imap.example.test",
|
|
"port": 993,
|
|
"username": f"{name}@example.test",
|
|
"password": password,
|
|
"security": "ssl",
|
|
},
|
|
status=201,
|
|
)["id"]
|
|
|
|
|
|
def _raw(actor: Actor, path: str):
|
|
return actor.client.get(
|
|
path,
|
|
headers={
|
|
"Origin": ORIGIN,
|
|
"X-CSRF-Token": actor.csrf,
|
|
"X-Scope-Kind": actor.scope["kind"],
|
|
"X-Scope-Id": actor.scope["id"],
|
|
},
|
|
)
|
|
|
|
|
|
def _grant(actor: Actor, kind: str, resource_id: str, email: str, **flags):
|
|
body = {"email": email, "can_read": True, "can_edit": False, "can_share": False, "use_owner_sources": False}
|
|
body.update(flags)
|
|
return actor.request("POST", f"/api/v1/{kind}/{resource_id}/grants", json=body, status=201)
|
|
|
|
|
|
def _events(db):
|
|
return db.execute(
|
|
"""
|
|
SELECT action, result, detail
|
|
FROM domain_events
|
|
WHERE action = 'source_read_mediated'
|
|
ORDER BY occurred_at, id
|
|
"""
|
|
).fetchall()
|
|
|
|
|
|
def test_owner_alone_sets_source_access_and_a_delegate_cannot_change_it(client, db):
|
|
ada = Actor(client, "ada-flag@example.test", "Ada Flag")
|
|
ben = Actor(client, "ben-flag@example.test", "Ben Flag")
|
|
cleo = Actor(client, "cleo-flag@example.test", "Cleo Flag")
|
|
register(db, ada.email, ada.name)
|
|
register(db, ben.email, ben.name)
|
|
register(db, cleo.email, cleo.name)
|
|
ada.login()
|
|
case = ada.request("POST", "/api/v1/cases", json={"title": "Streit"}, status=201)
|
|
_grant(ada, "cases", case["id"], ben.email, can_share=True, use_owner_sources=True)
|
|
ada_view = ada.request("GET", f"/api/v1/cases/{case['id']}")
|
|
ben_grant = next(item for item in ada_view["grants"] if item["email"] == ben.email)
|
|
assert ben_grant["use_owner_sources"] is True
|
|
|
|
ben.login()
|
|
_grant(ben, "cases", case["id"], cleo.email, use_owner_sources=True)
|
|
ada.login()
|
|
after_delegate = ada.request("GET", f"/api/v1/cases/{case['id']}")
|
|
cleo_grant = next(item for item in after_delegate["grants"] if item["email"] == cleo.email)
|
|
assert cleo_grant["use_owner_sources"] is False
|
|
|
|
_grant(ada, "cases", case["id"], cleo.email, use_owner_sources=True)
|
|
ben.login()
|
|
_grant(ben, "cases", case["id"], cleo.email, can_share=True, use_owner_sources=False)
|
|
ada.login()
|
|
kept = ada.request("GET", f"/api/v1/cases/{case['id']}")
|
|
cleo_grant = next(item for item in kept["grants"] if item["email"] == cleo.email)
|
|
assert cleo_grant["can_share"] is True
|
|
assert cleo_grant["use_owner_sources"] is True
|
|
|
|
_grant(ada, "cases", case["id"], cleo.email, use_owner_sources=False)
|
|
cleared = ada.request("GET", f"/api/v1/cases/{case['id']}")
|
|
cleo_grant = next(item for item in cleared["grants"] if item["email"] == cleo.email)
|
|
assert cleo_grant["use_owner_sources"] is False
|
|
|
|
|
|
def test_grantee_reads_linked_originals_only_through_the_owner(client, db, monkeypatch):
|
|
calls = []
|
|
|
|
def fake_file(base, token, path, max_bytes=40 * 1024 * 1024):
|
|
calls.append({"token": token, "path": path})
|
|
if path.endswith("/preview/"):
|
|
return (b"%PDF-1.4\nverknuepft\n", "application/pdf", "vertrag.pdf")
|
|
return None
|
|
|
|
def fake_get(base, token, path, params):
|
|
calls.append({"token": token, "path": path, "query": params.get("query")})
|
|
if token == OWNER_TOKEN:
|
|
return {"count": 1, "results": [{"id": 15, "title": "Geheimes Archivdokument", "created": "2026-01-01"}]}
|
|
return {"count": 0, "results": []}
|
|
|
|
monkeypatch.setattr(sources, "_paperless_file", fake_file)
|
|
monkeypatch.setattr(sources, "_paperless_get", fake_get)
|
|
monkeypatch.setattr(sources, "_paperless_metadata", lambda *args, **kwargs: None)
|
|
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", RecordingIMAP)
|
|
_reset_imap()
|
|
|
|
ada = Actor(client, "ada-quelle@example.test", "Ada Quelle")
|
|
ben = Actor(client, "ben-quelle@example.test", "Ben Quelle")
|
|
register(db, ada.email, ada.name)
|
|
register(db, ben.email, ben.name)
|
|
ada.login()
|
|
paper = _paperless(ada, OWNER_TOKEN, "Ada Archiv")
|
|
mailbox = _mailbox(ada, OWNER_MAIL, "Ada Post")
|
|
case = ada.request("POST", "/api/v1/cases", json={"title": "Akte"}, status=201)
|
|
matter = ada.request("POST", "/api/v1/matters", json={"title": "Vorgang"}, status=201)
|
|
other = ada.request("POST", "/api/v1/matters", json={"title": "Fremder Vorgang"}, status=201)
|
|
document = ada.request(
|
|
"POST",
|
|
"/api/v1/external-refs",
|
|
json={
|
|
"title": "Vertrag",
|
|
"source": "paperless",
|
|
"external_id": "15",
|
|
"context": {"kind": "case", "id": case["id"]},
|
|
"detail": {"connector_id": paper, "correspondent": "Hausverwaltung"},
|
|
},
|
|
status=201,
|
|
)
|
|
letter = ada.request(
|
|
"POST",
|
|
"/api/v1/external-refs",
|
|
json={
|
|
"title": "Einwendung",
|
|
"source": "imap",
|
|
"external_id": "<2@example.test>",
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"detail": {
|
|
"connector_id": mailbox,
|
|
"mailbox": "INBOX",
|
|
"uid": 2,
|
|
"direction": "in",
|
|
"message_from": "Hausverwaltung",
|
|
},
|
|
},
|
|
status=201,
|
|
)
|
|
owner_file = _raw(ada, f"/api/v1/external-refs/{document['id']}/content?context_kind=case&context_id={case['id']}")
|
|
assert owner_file.status_code == 200
|
|
assert owner_file.content.startswith(b"%PDF")
|
|
assert calls[-1]["token"] == OWNER_TOKEN
|
|
assert "/api/documents/15/" in calls[-1]["path"]
|
|
owner_mail = ada.request(
|
|
"GET",
|
|
f"/api/v1/external-refs/{letter['id']}/mail",
|
|
params={"context_kind": "matter", "context_id": matter["id"]},
|
|
)
|
|
assert "Einwendung" in owner_mail["text"]
|
|
assert OWNER_MAIL in RecordingIMAP.logins
|
|
calls.clear()
|
|
_reset_imap()
|
|
|
|
ben.login()
|
|
_paperless(ben, GRANTEE_TOKEN, "Ben Archiv")
|
|
_mailbox(ben, GRANTEE_MAIL, "Ben Post")
|
|
ada.login()
|
|
_grant(ada, "cases", case["id"], ben.email)
|
|
_grant(ada, "matters", matter["id"], ben.email)
|
|
_grant(ada, "matters", other["id"], ben.email, use_owner_sources=True)
|
|
|
|
ben.login()
|
|
shown = ben.request("GET", f"/api/v1/matters/{matter['id']}")
|
|
visible = next(item for item in shown["bindings"] if item["element"]["title"] == "Einwendung")
|
|
detail = visible["element"]["external"]["detail"]
|
|
assert detail["direction"] == "in"
|
|
assert detail["message_from"] == "Hausverwaltung"
|
|
assert "connector_id" not in detail
|
|
assert "mailbox" not in detail
|
|
assert "uid" not in detail
|
|
assert "external_id" not in visible["element"]["external"]
|
|
dumped = json.dumps(shown)
|
|
assert OWNER_MAIL not in dumped
|
|
assert OWNER_TOKEN not in dumped
|
|
assert "imap.example.test" not in dumped
|
|
assert mailbox not in dumped
|
|
|
|
hidden = ben.request(
|
|
"GET",
|
|
f"/api/v1/external-refs/{document['id']}/content",
|
|
params={"context_kind": "case", "context_id": case["id"], "document": "999"},
|
|
status=422,
|
|
)
|
|
assert hidden["detail"] == UNAVAILABLE
|
|
assert calls == []
|
|
missed = ben.request(
|
|
"GET",
|
|
f"/api/v1/external-refs/{letter['id']}/mail",
|
|
params={"context_kind": "matter", "context_id": matter["id"], "uid": "9", "mailbox": "Geheim"},
|
|
status=422,
|
|
)
|
|
assert missed["detail"] == UNAVAILABLE
|
|
assert RecordingIMAP.logins == []
|
|
assert RecordingIMAP.fetches == []
|
|
|
|
ada.login()
|
|
_grant(ada, "cases", case["id"], ben.email, use_owner_sources=True)
|
|
_grant(ada, "matters", matter["id"], ben.email, use_owner_sources=True)
|
|
ben.login()
|
|
opened = _raw(
|
|
ben,
|
|
f"/api/v1/external-refs/{document['id']}/content?context_kind=case&context_id={case['id']}&document=999",
|
|
)
|
|
assert opened.status_code == 200
|
|
assert opened.content.startswith(b"%PDF")
|
|
assert opened.headers["x-content-type-options"] == "nosniff"
|
|
assert opened.headers["cache-control"] == "private, no-store"
|
|
assert opened.headers["referrer-policy"] == "no-referrer"
|
|
assert calls == [{"token": OWNER_TOKEN, "path": "/api/documents/15/preview/"}]
|
|
assert GRANTEE_TOKEN not in json.dumps(calls)
|
|
search = ben.request("GET", "/api/v1/sources/paperless/documents", params={"q": "Geheim"})
|
|
assert "Geheimes Archivdokument" not in json.dumps(search)
|
|
assert all(item["token"] != OWNER_TOKEN for item in calls if "query" in item)
|
|
|
|
mail = ben.request(
|
|
"GET",
|
|
f"/api/v1/external-refs/{letter['id']}/mail",
|
|
params={"context_kind": "matter", "context_id": matter["id"], "uid": "9", "connector_id": paper},
|
|
)
|
|
assert mail["text"] == "Bitte die Einwendung pruefen."
|
|
assert mail["attachments"][0]["filename"] == "einwendung.pdf"
|
|
assert RecordingIMAP.logins == [OWNER_MAIL]
|
|
assert RecordingIMAP.fetches == [2]
|
|
original = _raw(
|
|
ben,
|
|
f"/api/v1/external-refs/{letter['id']}/mail/original?context_kind=matter&context_id={matter['id']}",
|
|
)
|
|
assert original.status_code == 200
|
|
assert b"Message-ID: <2@example.test>" in original.content
|
|
attachment = _raw(
|
|
ben,
|
|
f"/api/v1/external-refs/{letter['id']}/mail/attachments/0?context_kind=matter&context_id={matter['id']}",
|
|
)
|
|
assert attachment.status_code == 200
|
|
assert attachment.content.startswith(b"%PDF")
|
|
assert attachment.headers["content-disposition"].startswith("inline;")
|
|
assert GRANTEE_MAIL not in RecordingIMAP.logins
|
|
page = ben.request("GET", f"/api/v1/matters/{matter['id']}/chronology")
|
|
chronology = json.dumps(page)
|
|
assert "source_read_mediated" in [item["action"] for item in page["items"]]
|
|
assert "Verknüpftes Original gelesen" in [item["label"] for item in page["items"]]
|
|
assert mailbox not in chronology
|
|
assert OWNER_MAIL not in chronology
|
|
|
|
quiet = len(RecordingIMAP.logins)
|
|
ben.request("GET", "/api/v1/sources/imap/mailboxes", params={"connector_id": mailbox}, status=404)
|
|
ben.request(
|
|
"GET",
|
|
f"/api/v1/external-refs/{letter['id']}/mail",
|
|
params={"context_kind": "matter", "context_id": other["id"]},
|
|
status=404,
|
|
)
|
|
ada.login()
|
|
ada.request(
|
|
"PUT",
|
|
"/api/v1/exceptions",
|
|
json={
|
|
"resource_kind": "element",
|
|
"resource_id": letter["id"],
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"remove_read": True,
|
|
},
|
|
)
|
|
grant_id = next(item["id"] for item in ada.request("GET", f"/api/v1/cases/{case['id']}")["grants"])
|
|
ben.login()
|
|
ben.request(
|
|
"GET",
|
|
f"/api/v1/external-refs/{letter['id']}/mail",
|
|
params={"context_kind": "matter", "context_id": matter["id"]},
|
|
status=404,
|
|
)
|
|
assert len(RecordingIMAP.logins) == quiet
|
|
ada.login()
|
|
ada.request("DELETE", f"/api/v1/grants/{grant_id}", status=204)
|
|
ben.login()
|
|
ben.request(
|
|
"GET",
|
|
f"/api/v1/external-refs/{document['id']}/content",
|
|
params={"context_kind": "case", "context_id": case["id"]},
|
|
status=404,
|
|
)
|
|
assert len(RecordingIMAP.logins) == quiet
|
|
assert [item["token"] for item in calls if "query" not in item] == [OWNER_TOKEN]
|
|
|
|
rows = _events(db)
|
|
blob = json.dumps(rows, default=str)
|
|
assert OWNER_TOKEN not in blob
|
|
assert OWNER_MAIL not in blob
|
|
assert "Bitte die Einwendung" not in blob
|
|
assert "imap.example.test" not in blob
|
|
assert any(row["result"] == "ok" and row["detail"]["source"] == "paperless" for row in rows)
|
|
assert any(row["result"] == "ok" and row["detail"]["connector_id"] == mailbox for row in rows)
|
|
|
|
|
|
def test_deleted_or_foreign_connector_is_not_used(client, db, monkeypatch):
|
|
calls = []
|
|
monkeypatch.setattr(
|
|
sources,
|
|
"_paperless_file",
|
|
lambda *args, **kwargs: calls.append("paperless") or (b"%PDF-1.4\n", "application/pdf", "x.pdf"),
|
|
)
|
|
monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", RecordingIMAP)
|
|
_reset_imap()
|
|
|
|
ada = Actor(client, "ada-weg@example.test", "Ada Weg")
|
|
ben = Actor(client, "ben-weg@example.test", "Ben Weg")
|
|
cleo = Actor(client, "cleo-weg@example.test", "Cleo Weg")
|
|
register(db, ada.email, ada.name)
|
|
register(db, ben.email, ben.name)
|
|
register(db, cleo.email, cleo.name)
|
|
ada.login()
|
|
paper = _paperless(ada, OWNER_TOKEN, "Ada Archiv")
|
|
ben.login()
|
|
foreign = _mailbox(ben, GRANTEE_MAIL, "Ben Post")
|
|
ada.login()
|
|
matter = ada.request("POST", "/api/v1/matters", json={"title": "Vorgang"}, status=201)
|
|
document = ada.request(
|
|
"POST",
|
|
"/api/v1/external-refs",
|
|
json={
|
|
"title": "Scan",
|
|
"source": "paperless",
|
|
"external_id": "15",
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"detail": {"connector_id": paper},
|
|
},
|
|
status=201,
|
|
)
|
|
foreign_mail = ada.request(
|
|
"POST",
|
|
"/api/v1/external-refs",
|
|
json={
|
|
"title": "Fremde Quelle",
|
|
"source": "imap",
|
|
"external_id": "<2@example.test>",
|
|
"context": {"kind": "matter", "id": matter["id"]},
|
|
"detail": {"connector_id": foreign, "mailbox": "INBOX", "uid": 2},
|
|
},
|
|
status=201,
|
|
)
|
|
_grant(ada, "matters", matter["id"], cleo.email, use_owner_sources=True)
|
|
ada.request("DELETE", f"/api/v1/connectors/{paper}", status=204)
|
|
cleo.login()
|
|
blocked = cleo.request(
|
|
"GET",
|
|
f"/api/v1/external-refs/{document['id']}/content",
|
|
params={"context_kind": "matter", "context_id": matter["id"]},
|
|
status=422,
|
|
)
|
|
assert blocked["detail"] == UNAVAILABLE
|
|
assert "paper.example.test" not in blocked["detail"]
|
|
assert calls == []
|
|
refused = cleo.request(
|
|
"GET",
|
|
f"/api/v1/external-refs/{foreign_mail['id']}/mail",
|
|
params={"context_kind": "matter", "context_id": matter["id"]},
|
|
status=422,
|
|
)
|
|
assert refused["detail"] == UNAVAILABLE
|
|
assert RecordingIMAP.logins == []
|
|
rows = _events(db)
|
|
assert rows
|
|
assert all(row["result"] == "unavailable" for row in rows)
|
|
assert OWNER_TOKEN not in json.dumps(rows, default=str)
|
|
assert GRANTEE_MAIL not in json.dumps(rows, default=str)
|