Erlaube berechtigten Konten, verknüpfte Originale über die Zugänge des Owners zu lesen.
Deploy Development / deploy (push) Successful in 26s
Test Suite / pytest-backend (push) Successful in 1m51s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 9s

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
LarsandCursor committed 2026-10-18 21:47:30 +02:00
1 parent 562c0848b1
commit 75a3949f7c
14 files changed
+815 -93

No files matched your search

+62 -2
View File
@@ -11,6 +11,8 @@ from dataclasses import dataclass
from typing import Any
from uuid import UUID
from psycopg.types.json import Json
from app.core.errors import conflict, forbidden, not_found, unprocessable
SHARED_NOTICE = "Diese Änderung betrifft den gemeinsamen Inhalt der Notiz."
@@ -87,14 +89,17 @@ def audit(
resource_id: UUID,
context: Ctx | None = None,
occurred_on=None,
*,
result: str = "ok",
detail: dict | None = None,
) -> None:
conn.execute(
"""
INSERT INTO domain_events (
actor_subject_id, scope_id, action, resource_kind, resource_id,
context_kind, context_id, occurred_on
context_kind, context_id, occurred_on, result, detail
)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
""",
(
actor_id,
@@ -105,6 +110,8 @@ def audit(
context.kind if context else None,
context.id if context else None,
occurred_on,
result,
Json(detail) if detail is not None else None,
),
)
@@ -348,6 +355,59 @@ def _child_of(conn, matter_id: UUID, parent_id: UUID) -> bool:
return bool(matter and matter["parent_matter_id"] == parent_id)
def _rights_bearing_case(conn, case: dict) -> dict:
seen: set[UUID] = set()
current = case
while current["parent_case_id"] is not None and current["rights_mode"] == "inherit_parent":
if current["id"] in seen:
break
seen.add(current["id"])
parent = get_case(conn, current["parent_case_id"])
if parent is None:
break
current = parent
return current
def _source_grant(conn, actor: UUID, kind: str, resource_id: UUID) -> dict | None:
return conn.execute(
"""
SELECT can_read, use_owner_sources
FROM access_grants
WHERE NOT is_exception
AND grantee_subject_id = %s
AND resource_kind = %s
AND resource_id = %s
AND context_kind IS NULL
""",
(actor, kind, resource_id),
).fetchone()
def mediated_source_owner(conn, actor: UUID, element: dict, context: Ctx | None) -> UUID | None:
"""Owner whose stored connector may serve this reader. None unless the grant allows it."""
if context is None or not element_rights(conn, actor, element, context).read:
return None
if context.kind == "case":
resource = get_case(conn, context.id)
if resource is None:
return None
resource = _rights_bearing_case(conn, resource)
grant = _source_grant(conn, actor, "case", resource["id"])
elif context.kind == "matter":
resource = get_matter(conn, context.id)
if resource is None:
return None
grant = _source_grant(conn, actor, "matter", resource["id"])
else:
return None
if resource["owner_subject_id"] == actor:
return None
if grant is None or not grant["can_read"] or not grant["use_owner_sources"]:
return None
return resource["owner_subject_id"]
def element_rights_via_case_or_direct(conn, actor: UUID, element: dict, context: Ctx | None) -> Rights:
"""Rights for an element bound to a matter when the caller names a case path.
+22 -2
View File
@@ -643,7 +643,16 @@ def post_case_grant(
if account is None:
raise not_found()
grant = grant_access(
conn, principal.account_id, "case", case_id, account["id"], body.can_read, body.can_edit, body.can_share, None
conn,
principal.account_id,
"case",
case_id,
account["id"],
body.can_read,
body.can_edit,
body.can_share,
None,
body.use_owner_sources,
)
return _created(f"/api/v1/grants/{grant['id']}", {"id": str(grant["id"])})
@@ -908,7 +917,16 @@ def post_matter_grant(
if account is None:
raise not_found()
grant = grant_access(
conn, principal.account_id, "matter", matter_id, account["id"], body.can_read, body.can_edit, body.can_share, None
conn,
principal.account_id,
"matter",
matter_id,
account["id"],
body.can_read,
body.can_edit,
body.can_share,
None,
body.use_owner_sources,
)
return _created(f"/api/v1/grants/{grant['id']}", {"id": str(grant["id"])})
@@ -1785,6 +1803,8 @@ def _visible_events(conn, actor: UUID, rows: list[dict], page: Ctx) -> list[dict
names: dict = {}
items = []
for event in rows:
if event["result"] != "ok":
continue
title = _event_title(conn, actor, event, page)
if title is None:
continue
+1
View File
@@ -167,6 +167,7 @@ class GrantIn(APIModel):
can_read: bool = True
can_edit: bool = False
can_share: bool = False
use_owner_sources: bool = False
class ExceptionIn(APIModel):
+48 -67
View File
@@ -5,10 +5,10 @@ from __future__ import annotations
from uuid import UUID
from fastapi import APIRouter, Depends
from fastapi.responses import Response
from fastapi.responses import JSONResponse, Response
from psycopg import Connection
from app.access.policy import Ctx, element_rights, get_element, parse_query_context
from app.access.policy import element_rights, get_element, parse_query_context
from app.api.deps import Principal, get_conn, get_principal
from app.api.routes import _created, _ctx_model
from app.api.schemas import ConnectorIn, ExternalIn
@@ -23,13 +23,19 @@ from app.sources import (
imap_messages,
imap_preview,
list_connectors,
load_imap_original,
paperless_content,
paperless_documents,
probe,
read_linked_mail,
read_linked_paperless,
save_connector,
)
_PRIVATE = {
"Cache-Control": "private, no-store",
"Referrer-Policy": "no-referrer",
"X-Content-Type-Options": "nosniff",
}
router = APIRouter()
@@ -63,27 +69,17 @@ def view_paperless(
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
element = get_element(conn, element_id)
if element is None or element["kind"] != "external_ref":
raise not_found()
rights = element_rights(conn, principal.account_id, element, parse_query_context(context_kind, context_id))
if not rights.read:
raise not_found()
ref = conn.execute(
"SELECT source, external_id FROM external_references WHERE element_id = %s",
(element_id,),
).fetchone()
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
if ref is None or ref["source"] != "paperless":
raise unprocessable("Nur ein Paperless-Dokument lässt sich hier als Datei ansehen.")
data, media_type, filename = paperless_content(conn, principal.account_id, ref["external_id"])
safe_name = (filename or f"paperless-{ref['external_id']}.pdf").replace('"', "")
data, media_type, filename = read_linked_paperless(conn, principal.account_id, element, context, ref)
safe_name = (filename or "dokument.pdf").replace('"', "")
return Response(
content=data,
media_type=media_type,
headers={
**_PRIVATE,
"Content-Disposition": f'inline; filename="{safe_name}"',
"X-Content-Type-Options": "nosniff",
"Cache-Control": "private, no-store",
},
)
@@ -96,52 +92,48 @@ def view_mail(
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
ref = _mail_ref(conn, principal, element_id, context_kind, context_id)
parsed, _raw = _complete_mail(conn, principal, ref)
return {
"title": parsed.subject,
"message_from": parsed.sender,
"message_to": parsed.recipient,
"message_cc": parsed.copy,
"text": parsed.text,
"text_truncated": False,
"complete": True,
"attachments": [
{
"index": index,
"filename": item.filename,
"content_type": item.media_type,
"byte_size": len(item.data),
}
for index, item in enumerate(parsed.attachments)
],
}
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
parsed, _raw = _complete_mail(conn, principal, element, context, ref)
return JSONResponse(
content={
"title": parsed.subject,
"message_from": parsed.sender,
"message_to": parsed.recipient,
"message_cc": parsed.copy,
"text": parsed.text,
"text_truncated": False,
"complete": True,
"attachments": [
{
"index": index,
"filename": item.filename,
"content_type": item.media_type,
"byte_size": len(item.data),
}
for index, item in enumerate(parsed.attachments)
],
},
headers={"Cache-Control": "private, no-store", "Referrer-Policy": "no-referrer"},
)
def _mail_ref(conn, principal: Principal, element_id: UUID, context_kind: str | None, context_id: str | None):
def _opened_ref(conn, principal: Principal, element_id: UUID, context_kind: str | None, context_id: str | None):
element = get_element(conn, element_id)
if element is None or element["kind"] != "external_ref":
raise not_found()
rights = element_rights(conn, principal.account_id, element, parse_query_context(context_kind, context_id))
context = parse_query_context(context_kind, context_id)
rights = element_rights(conn, principal.account_id, element, context)
if not rights.read:
raise not_found()
ref = conn.execute(
"SELECT source, external_id, detail FROM external_references WHERE element_id = %s",
(element_id,),
).fetchone()
return ref
return element, context, ref
def _complete_mail(conn, principal: Principal, ref):
detail = (ref or {}).get("detail") or {}
if ref is None or ref["source"] != "imap":
raise unprocessable("Das ist keine E-Mail.")
connector_id = detail.get("connector_id")
mailbox = str(detail.get("mailbox") or "").strip()
uid = _mail_uid(detail.get("uid"))
if not connector_id or not mailbox or uid is None:
raise unprocessable("Für diese E-Mail fehlt die Zuordnung zu Fach und Nachricht.")
raw = load_imap_original(conn, principal.account_id, UUID(str(connector_id)), mailbox, uid, str(ref["external_id"]))
def _complete_mail(conn, principal: Principal, element, context, ref):
raw = read_linked_mail(conn, principal.account_id, element, context, ref)
parsed = parse_mail(raw)
if parsed.missing:
names = ", ".join(parsed.missing[:5])
@@ -149,16 +141,6 @@ def _complete_mail(conn, principal: Principal, ref):
return parsed, raw
def _mail_uid(value) -> int | None:
if isinstance(value, bool):
return None
if isinstance(value, int) and value >= 1:
return value
if isinstance(value, str) and value.isdigit() and int(value) >= 1:
return int(value)
return None
@router.get("/api/v1/external-refs/{element_id}/mail/original")
def download_mail(
element_id: UUID,
@@ -167,8 +149,8 @@ def download_mail(
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
ref = _mail_ref(conn, principal, element_id, context_kind, context_id)
_parsed, raw = _complete_mail(conn, principal, ref)
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
_parsed, raw = _complete_mail(conn, principal, element, context, ref)
return _mail_bytes(raw, "message/rfc822", "nachricht.eml")
@@ -181,8 +163,8 @@ def download_mail_attachment(
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
ref = _mail_ref(conn, principal, element_id, context_kind, context_id)
parsed, _raw = _complete_mail(conn, principal, ref)
element, context, ref = _opened_ref(conn, principal, element_id, context_kind, context_id)
parsed, _raw = _complete_mail(conn, principal, element, context, ref)
if index < 0 or index >= len(parsed.attachments):
raise not_found()
item = parsed.attachments[index]
@@ -197,9 +179,8 @@ def _mail_bytes(data: bytes, media_type: str, filename: str, inline: bool = Fals
content=data,
media_type=media_type,
headers={
**_PRIVATE,
"Content-Disposition": disposition,
"X-Content-Type-Options": "nosniff",
"Cache-Control": "private, no-store",
},
)
+25 -7
View File
@@ -701,7 +701,18 @@ def _actor_rights_for(conn, actor: UUID, kind: str, resource_id: UUID, context:
return rights
def grant_access(conn, actor: UUID, kind: str, resource_id: UUID, grantee_id: UUID, can_read: bool, can_edit: bool, can_share: bool, context: Ctx | None) -> dict:
def grant_access(
conn,
actor: UUID,
kind: str,
resource_id: UUID,
grantee_id: UUID,
can_read: bool,
can_edit: bool,
can_share: bool,
context: Ctx | None,
use_owner_sources: bool = False,
) -> dict:
if grantee_id == actor:
raise unprocessable("Die eigene Berechtigung wird nicht als Freigabe gespeichert.")
if not can_read:
@@ -731,33 +742,40 @@ def grant_access(conn, actor: UUID, kind: str, resource_id: UUID, grantee_id: UU
raise not_found()
existing = conn.execute(
"""
SELECT id FROM access_grants
SELECT id, use_owner_sources FROM access_grants
WHERE NOT is_exception AND grantee_subject_id = %s
AND resource_kind = %s AND resource_id = %s AND context_kind IS NULL
""",
(grantee_id, kind, resource_id),
).fetchone()
if owner:
source_access = bool(use_owner_sources)
elif existing is None:
source_access = False
else:
source_access = bool(existing["use_owner_sources"])
if existing is None:
row = conn.execute(
"""
INSERT INTO access_grants (
grantee_subject_id, resource_kind, resource_id,
can_read, can_edit, can_share, can_delete, is_exception, created_by
can_read, can_edit, can_share, can_delete, is_exception, created_by,
use_owner_sources
)
VALUES (%s, %s, %s, %s, %s, %s, false, false, %s)
VALUES (%s, %s, %s, %s, %s, %s, false, false, %s, %s)
RETURNING *
""",
(grantee_id, kind, resource_id, can_read, can_edit, can_share, actor),
(grantee_id, kind, resource_id, can_read, can_edit, can_share, actor, source_access),
).fetchone()
else:
row = conn.execute(
"""
UPDATE access_grants
SET can_read = %s, can_edit = %s, can_share = %s
SET can_read = %s, can_edit = %s, can_share = %s, use_owner_sources = %s
WHERE id = %s
RETURNING *
""",
(can_read, can_edit, can_share, existing["id"]),
(can_read, can_edit, can_share, source_access, existing["id"]),
).fetchone()
audit(conn, actor, resource["home_scope_id"], "grant_created", kind, resource_id, context)
return row
+40 -8
View File
@@ -126,7 +126,32 @@ def _preview_meta(kind: str, content_type: str | None, source: str | None) -> di
return {"available": False, "media": "none", "source": source}
def _element_body(conn, element: dict) -> dict:
_HIDDEN_SOURCE_FIELDS = frozenset({
"connector_id",
"mailbox",
"uid",
"host",
"username",
"port",
"password",
"secret",
"base_url",
"server",
"security",
"open_url",
})
def _connector_owner(conn, raw) -> UUID | None:
try:
connector_id = UUID(str(raw))
except (TypeError, ValueError):
return None
row = conn.execute("SELECT owner_id FROM connectors WHERE id = %s", (connector_id,)).fetchone()
return row["owner_id"] if row else None
def _element_body(conn, actor: UUID, element: dict) -> dict:
payload = {
"id": str(element["id"]),
"kind": element["kind"],
@@ -169,11 +194,15 @@ def _element_body(conn, element: dict) -> dict:
(element["id"],),
).fetchone()
if ref is not None:
payload["external"] = {
"source": ref["source"],
"external_id": ref["external_id"],
"detail": ref["detail"] or {},
}
detail = dict(ref["detail"] or {})
connector_owner = _connector_owner(conn, detail.get("connector_id"))
revealed = actor == element["owner_subject_id"] or (connector_owner is not None and actor == connector_owner)
if not revealed:
detail = {key: value for key, value in detail.items() if key not in _HIDDEN_SOURCE_FIELDS}
external = {"source": ref["source"], "detail": detail}
if revealed:
external["external_id"] = ref["external_id"]
payload["external"] = external
payload["preview"] = _preview_meta("external_ref", None, ref["source"])
return payload
@@ -280,7 +309,7 @@ def binding_payload(conn, actor: UUID, binding: dict, context: Ctx) -> dict | No
rights = element_rights(conn, actor, element, context)
if not rights.read:
return None
body = _element_body(conn, element)
body = _element_body(conn, actor, element)
container = Ctx(binding["context_kind"], binding["context_id"])
_attach_references(conn, actor, element, context, container, body)
payload = {
@@ -300,7 +329,8 @@ def binding_payload(conn, actor: UUID, binding: dict, context: Ctx) -> dict | No
def _grants(conn, kind: str, resource_id: UUID) -> list[dict]:
rows = conn.execute(
"""
SELECT g.id, g.grantee_subject_id, g.can_read, g.can_edit, g.can_share, a.email, a.display_name
SELECT g.id, g.grantee_subject_id, g.can_read, g.can_edit, g.can_share, g.use_owner_sources,
a.email, a.display_name
FROM access_grants g
JOIN auth_accounts a ON a.id = g.grantee_subject_id
WHERE NOT g.is_exception AND g.resource_kind = %s AND g.resource_id = %s AND g.context_kind IS NULL
@@ -317,6 +347,7 @@ def _grants(conn, kind: str, resource_id: UUID) -> list[dict]:
"can_read": row["can_read"],
"can_edit": row["can_edit"],
"can_share": row["can_share"],
"use_owner_sources": row["use_owner_sources"],
}
for row in rows
]
@@ -958,6 +989,7 @@ LABELS = {
"deadline_fulfilled": "Frist erfüllt",
"grant_created": "Freigabe erteilt",
"grant_revoked": "Freigabe entzogen",
"source_read_mediated": "Verknüpftes Original gelesen",
"correspondence_document": "Dokumentdatum",
"correspondence_sent": "Versand",
"correspondence_received": "Zugang",
+138
View File
@@ -18,6 +18,7 @@ from uuid import UUID
from psycopg.types.json import Json
from app.access.policy import Ctx, audit, mediated_source_owner
from app.core.errors import Problem, not_found, unprocessable
from app.core.settings import get_settings
from app.mailpack import MailIdentityError, choose_message, identities_match, header_message_id
@@ -207,6 +208,10 @@ def paperless_content(conn, owner_id: UUID, document_id: str) -> tuple[bytes, st
).fetchone()
if row is None:
raise unprocessable("Paperless ist für dieses Konto nicht verbunden.")
return _paperless_bytes(row, document_id)
def _paperless_bytes(row, document_id: str) -> tuple[bytes, str, str]:
base = row["settings"]["base_url"].rstrip("/")
token = row["secret"]
misses = 0
@@ -228,6 +233,139 @@ def paperless_content(conn, owner_id: UUID, document_id: str) -> tuple[bytes, st
raise unprocessable("Paperless stellt diese Datei nicht zum Ansehen bereit.")
ORIGINAL_UNAVAILABLE = "Das Original ist über die Freigabe nicht abrufbar."
def read_linked_paperless(conn, actor_id: UUID, element: dict, context: Ctx | None, ref) -> tuple[bytes, str, str]:
"""The stored document. A grantee never uses a connector of their own account."""
detail = (ref or {}).get("detail") or {}
external_id = str((ref or {}).get("external_id") or "")
stored = _uuid(detail.get("connector_id"))
stored_owner = _connector_owner(conn, stored)
if element["owner_subject_id"] == actor_id or stored_owner == actor_id:
return paperless_content(conn, actor_id, external_id)
owner_id = mediated_source_owner(conn, actor_id, element, context)
if owner_id is None or not external_id.isdigit() or len(external_id) > 12:
raise unprocessable(ORIGINAL_UNAVAILABLE)
row = _mediated_paperless(conn, owner_id, stored, element)
if row is None:
_audit_mediated(conn, actor_id, element, context, "paperless", stored, "unavailable")
raise unprocessable(ORIGINAL_UNAVAILABLE)
try:
data, media, name = _paperless_bytes(row, external_id)
except Problem:
_audit_mediated(conn, actor_id, element, context, "paperless", row["id"], "unavailable")
raise unprocessable(ORIGINAL_UNAVAILABLE) from None
_audit_mediated(conn, actor_id, element, context, "paperless", row["id"], "ok")
if external_id and external_id in (name or ""):
name = "dokument.pdf"
return data, media, name or "dokument.pdf"
def read_linked_mail(conn, actor_id: UUID, element: dict, context: Ctx | None, ref) -> bytes:
"""The stored message. Mailbox, UID and connector come only from the saved reference."""
detail = (ref or {}).get("detail") or {}
if ref is None or ref["source"] != "imap":
raise unprocessable("Das ist keine E-Mail.")
connector_id = _uuid(detail.get("connector_id"))
mailbox = str(detail.get("mailbox") or "").strip()
uid = _mail_uid(detail.get("uid"))
external_id = str(ref["external_id"])
stored_owner = _connector_owner(conn, connector_id)
if element["owner_subject_id"] == actor_id or stored_owner == actor_id:
if connector_id is None or not mailbox or uid is None:
raise unprocessable("Für diese E-Mail fehlt die Zuordnung zu Fach und Nachricht.")
return load_imap_original(conn, actor_id, connector_id, mailbox, uid, external_id)
owner_id = mediated_source_owner(conn, actor_id, element, context)
if owner_id is None or connector_id is None or not mailbox or uid is None:
raise unprocessable(ORIGINAL_UNAVAILABLE)
row = _connector_for(conn, connector_id, owner_id, "imap")
if row is None:
_audit_mediated(conn, actor_id, element, context, "imap", connector_id, "unavailable")
raise unprocessable(ORIGINAL_UNAVAILABLE)
try:
raw = load_imap_original(conn, owner_id, connector_id, mailbox, uid, external_id)
except Problem:
_audit_mediated(conn, actor_id, element, context, "imap", connector_id, "unavailable")
raise unprocessable(ORIGINAL_UNAVAILABLE) from None
_audit_mediated(conn, actor_id, element, context, "imap", connector_id, "ok")
return raw
def _uuid(value) -> UUID | None:
if isinstance(value, UUID):
return value
try:
return UUID(str(value))
except (TypeError, ValueError):
return None
def _mail_uid(value) -> int | None:
if isinstance(value, bool):
return None
if isinstance(value, int) and value >= 1:
return value
if isinstance(value, str) and value.isdigit() and int(value) >= 1:
return int(value)
return None
def _connector_owner(conn, connector_id: UUID | None) -> UUID | None:
if connector_id is None:
return None
row = conn.execute("SELECT owner_id FROM connectors WHERE id = %s", (connector_id,)).fetchone()
return row["owner_id"] if row else None
def _connector_for(conn, connector_id: UUID, owner_id: UUID, kind: str):
return conn.execute(
"""
SELECT id, owner_id, kind, settings, secret
FROM connectors
WHERE id = %s AND owner_id = %s AND kind = %s
""",
(connector_id, owner_id, kind),
).fetchone()
def _mediated_paperless(conn, owner_id: UUID, stored: UUID | None, element: dict):
if stored is not None:
return _connector_for(conn, stored, owner_id, "paperless")
if element["owner_subject_id"] != owner_id:
return None
return conn.execute(
"""
SELECT id, owner_id, kind, settings, secret
FROM connectors
WHERE owner_id = %s AND kind = 'paperless'
ORDER BY created_at DESC
LIMIT 1
""",
(owner_id,),
).fetchone()
def _audit_mediated(conn, actor_id: UUID, element: dict, context: Ctx | None, source: str, connector_id, outcome: str) -> None:
audit(
conn,
actor_id,
element["home_scope_id"],
"source_read_mediated",
"element",
element["id"],
context,
result="ok" if outcome == "ok" else "unavailable",
detail={
"source": source,
"connector_id": str(connector_id) if connector_id else None,
"outcome": outcome,
},
)
if outcome != "ok":
conn.commit()
def _paperless_file(
base: str,
token: str,
@@ -0,0 +1,8 @@
-- Owner kann an einer Freigabe erlauben, verknüpfte Originale über die eigenen Zugänge zu lesen.
-- Bestehende Freigaben bleiben ohne diesen Abruf.
ALTER TABLE access_grants
ADD COLUMN use_owner_sources boolean NOT NULL DEFAULT false;
ALTER TABLE domain_events
ADD COLUMN detail jsonb;
+451
View File
@@ -0,0 +1,451 @@
"""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)