Files
patrickandClaude Sonnet 5 090c1866f2
CI / Web-Barrierefreiheitspruefung (axe, Tastatur, Reflow, Textabstaende) (push) Canceled after 0s
CI / Core-Modul (Build/Vet/Test) (push) Canceled after 0s
CI / DMS Security-Test-Gate (AC5, Merge-Gate) (push) Canceled after 0s
CI / DMS-Modul (Lint/Build/Test/Coverage/Artefakt) (push) Canceled after 0s
CI / DMS-Modul Supply-Chain-Scan (govulncheck) (push) Canceled after 0s
CI / Web (dms-browser) (push) Canceled after 0s
CI / Web (pdf-viewer) (push) Canceled after 0s
CI / Web (shl) (push) Canceled after 0s
Supply-Chain-Scan (Go) / govulncheck (push) Canceled after 0s
QA-15 F-12/F-13: Tar-Slip und Zip-Eintragsnamen absichern, pdftoppm mit Zeitlimit
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-09-22 01:22:25 +02:00

238 lines
7.3 KiB
Go

package export
import (
"archive/zip"
"context"
"encoding/csv"
"encoding/json"
"fmt"
"io"
"path"
"strconv"
"strings"
"unicode/utf8"
"github.com/jackc/pgx/v5/pgxpool"
dmscrypto "gitea.perlbach24.de/scripte/nexarch/dms/internal/crypto"
"gitea.perlbach24.de/scripte/nexarch/dms/internal/jobqueue"
"gitea.perlbach24.de/scripte/nexarch/dms/internal/storage"
)
// PermissionChecker entscheidet, ob requestedBy EIN bestimmtes Dokument
// exportieren darf (Akzeptanzkriterium 3: nur berechtigte Dokumente landen
// im Archiv) — dasselbe Deferred-RBAC-Muster wie in den übrigen HTTP-/Job-
// Paketen (VER-02/DOC-15/VER-06/DOC-07).
type PermissionChecker interface {
CanAccessDocument(ctx context.Context, callerUserID, documentID string) (bool, error)
}
// Processor erzeugt EIN ZIP-Archiv für einen Export-Auftrag.
type Processor struct {
Pool *pgxpool.Pool
Storage *storage.Service
Crypto *dmscrypto.Service
TenantSlug string
Permissions PermissionChecker
}
// Handler ist der jobqueue.Handler für JobType.
func (p *Processor) Handler(ctx context.Context, job *jobqueue.Job) error {
var payload jobPayload
if err := json.Unmarshal(job.Payload, &payload); err != nil {
return fmt.Errorf("export: auftrag dekodieren: %w", err)
}
if err := markProcessing(ctx, p.Pool, payload.ExportID); err != nil {
return fmt.Errorf("export: verarbeitung markieren: %w", err)
}
if err := p.process(ctx, payload.ExportID); err != nil {
if markErr := markFailed(ctx, p.Pool, payload.ExportID, err); markErr != nil {
return fmt.Errorf("export: fehlschlag erfassen (ursprünglicher fehler: %v): %w", err, markErr)
}
return err
}
return nil
}
type manifestRow struct {
DocumentID string
Title string
ChecksumSHA256 string
SizeBytes int64
}
func (p *Processor) process(ctx context.Context, exportID string) error {
exp, err := Get(ctx, p.Pool, exportID)
if err != nil {
return fmt.Errorf("export: auftrag lesen: %w", err)
}
var allowedIDs, skippedIDs []string
for _, documentID := range exp.DocumentIDs {
allowed, err := p.Permissions.CanAccessDocument(ctx, exp.RequestedBy, documentID)
if err != nil {
return fmt.Errorf("export: berechtigung pruefen: %w", err)
}
if allowed {
allowedIDs = append(allowedIDs, documentID)
} else {
skippedIDs = append(skippedIDs, documentID)
}
}
// Streaming statt vollstaendigem Aufbau im Speicher (Pflichtpruefung 1:
// 1000 Dokumente ohne Speicherueberlauf) — ein io.Pipe verbindet den
// zip.Writer (schreibt synchron in der Verarbeitungs-Goroutine) direkt
// mit storage.Service.Put (liest in DIESER Goroutine), es entsteht nie
// ein vollstaendiges ZIP-Byte-Array im Speicher.
pr, pw := io.Pipe()
usedNames := map[string]int{}
manifest := make([]manifestRow, 0, len(allowedIDs))
writeErrCh := make(chan error, 1)
go func() {
zw := zip.NewWriter(pw)
err := func() error {
for _, documentID := range allowedIDs {
row, err := p.addDocumentToZip(ctx, zw, documentID, usedNames)
if err != nil {
return err
}
manifest = append(manifest, row)
}
return writeManifest(zw, manifest)
}()
if closeErr := zw.Close(); err == nil {
err = closeErr
}
writeErrCh <- err
_ = pw.CloseWithError(err)
}()
storageKey := "exports/" + exportID + ".zip"
if _, err := p.Storage.Put(ctx, storageKey, pr, -1, "application/zip"); err != nil {
<-writeErrCh
return fmt.Errorf("export: zip im storage ablegen: %w", err)
}
if err := <-writeErrCh; err != nil {
return fmt.Errorf("export: zip erzeugen: %w", err)
}
if err := markReady(ctx, p.Pool, exportID, storageKey, skippedIDs); err != nil {
return fmt.Errorf("export: bereit-zustand speichern: %w", err)
}
return nil
}
func (p *Processor) addDocumentToZip(ctx context.Context, zw *zip.Writer, documentID string, usedNames map[string]int) (manifestRow, error) {
var title, storageKey, checksumHex string
var sizeBytes int64
var wrappedDEK []byte
if err := p.Pool.QueryRow(ctx, `
SELECT d.title, fr.storage_key, fr.checksum_sha256, fr.size_bytes, fr.wrapped_dek
FROM documents d JOIN file_revisions fr ON fr.id = d.current_revision_id
WHERE d.id = $1
`, documentID).Scan(&title, &storageKey, &checksumHex, &sizeBytes, &wrappedDEK); err != nil {
return manifestRow{}, fmt.Errorf("export: dokument %s lesen: %w", documentID, err)
}
cipherReader, err := p.Storage.Get(ctx, storageKey)
if err != nil {
return manifestRow{}, fmt.Errorf("export: dokument %s aus storage laden: %w", documentID, err)
}
defer func() { _ = cipherReader.Close() }()
plainReader, err := p.Crypto.Open(ctx, p.TenantSlug, wrappedDEK, cipherReader)
if err != nil {
return manifestRow{}, fmt.Errorf("export: dokument %s entschluesseln: %w", documentID, err)
}
entryName := uniqueEntryName(title, usedNames)
w, err := zw.Create(entryName)
if err != nil {
return manifestRow{}, fmt.Errorf("export: zip-eintrag %s anlegen: %w", entryName, err)
}
if _, err := io.Copy(w, plainReader); err != nil {
return manifestRow{}, fmt.Errorf("export: dokument %s in zip schreiben: %w", documentID, err)
}
return manifestRow{DocumentID: documentID, Title: entryName, ChecksumSHA256: checksumHex, SizeBytes: sizeBytes}, nil
}
// uniqueEntryName haengt bei einem Namenskonflikt einen Zaehler an, damit
// gleichnamige Dokumente im selben Export nicht denselben Zip-Eintrag
// ueberschreiben.
func uniqueEntryName(title string, usedNames map[string]int) string {
base := sanitizeEntryName(title)
count := usedNames[base]
usedNames[base] = count + 1
if count == 0 {
return base
}
ext := path.Ext(base)
stem := strings.TrimSuffix(base, ext)
return fmt.Sprintf("%s (%d)%s", stem, count, ext)
}
// writeManifest fuegt die Metadaten-Beilage hinzu (Akzeptanzkriterium 2).
func writeManifest(zw *zip.Writer, rows []manifestRow) error {
w, err := zw.Create("manifest.csv")
if err != nil {
return fmt.Errorf("export: manifest anlegen: %w", err)
}
csvWriter := csv.NewWriter(w)
if err := csvWriter.Write([]string{"document_id", "dateiname", "sha256", "groesse_bytes"}); err != nil {
return err
}
for _, row := range rows {
if err := csvWriter.Write([]string{row.DocumentID, row.Title, row.ChecksumSHA256, strconv.FormatInt(row.SizeBytes, 10)}); err != nil {
return err
}
}
csvWriter.Flush()
return csvWriter.Error()
}
const maxEntryNameBytes = 200
// sanitizeEntryName macht aus einem Dokumenttitel einen sicheren Zip-Eintragsnamen
// (QA-15 F-12, Zip-Slip beim Entpacken durch den Empfaenger): nur der letzte
// Pfadbestandteil (an "/" und "\\" getrennt), keine Steuerzeichen, keine
// unter Windows verbotenen Zeichen, kein "." und "..", auf 200 Bytes gekuerzt
// (Endung bleibt erhalten). Ein leerer Rest ergibt "dokument".
func sanitizeEntryName(title string) string {
name := title
if i := strings.LastIndexAny(name, "/\\"); i >= 0 {
name = name[i+1:]
}
var b strings.Builder
for _, r := range name {
switch {
case r < 0x20 || r == 0x7f || r == 0xfffd:
continue
case strings.ContainsRune(`<>:"|?*`, r):
b.WriteRune('_')
default:
b.WriteRune(r)
}
}
name = strings.TrimSpace(b.String())
name = strings.TrimRight(name, ". ")
if name == "" || strings.Trim(name, ".") == "" {
return "dokument"
}
if len(name) > maxEntryNameBytes {
ext := path.Ext(name)
if len(ext) > 20 {
ext = ""
}
stem := name[:maxEntryNameBytes-len(ext)]
for !utf8.ValidString(stem) {
stem = stem[:len(stem)-1]
}
name = stem + ext
}
return name
}