package server import ( "archive/tar" "archive/zip" "bufio" "bytes" "compress/gzip" "debug/pe" "encoding/base64" "encoding/csv" "encoding/json" "fmt" "io" "math" "mime" "mime/multipart" "mime/quotedprintable" "net/mail" "net/url" "path/filepath" "strconv" "strings" "unicode/utf8" ) type archiveEntryView struct { Name string `json:"name"` Size uint64 `json:"size"` IsDir bool `json:"is_dir"` IsImage bool `json:"is_image"` URL string `json:"url,omitempty"` } type metadataView struct { Name string Value string } func structuredContentView(view *contentView, body []byte, semanticPath string) { switch view.AdapterID { case "csv": parseCSVView(view, body) case "excalidraw": parseExcalidrawView(view, body) case "archive": if !strings.EqualFold(filepath.Ext(view.Filename), ".zip") { view.MetadataStatus = "pending" view.MetadataURL = metadataProjectionURL("archive", view.RevisionUUID, semanticPath) break } reader, err := zip.NewReader(bytes.NewReader(body), int64(len(body))) if err != nil { view.ParseError = err.Error() return } for _, file := range reader.File { if len(view.ArchiveEntries) >= maxArchiveMetadataEntries { view.ArchiveTruncated = true break } ext := strings.ToLower(filepath.Ext(file.Name)) query := url.Values{"path": {semanticPath}, "entry": {file.Name}, "rev": {view.RevisionUUID}} view.ArchiveEntries = append(view.ArchiveEntries, archiveEntryView{ Name: file.Name, Size: file.UncompressedSize64, IsDir: file.FileInfo().IsDir(), IsImage: ext == ".jpg" || ext == ".jpeg" || ext == ".png" || ext == ".gif" || ext == ".webp" || ext == ".avif", URL: "/v/archive?" + query.Encode(), }) } case "eml": message, err := mail.ReadMessage(bytes.NewReader(body)) if err != nil { view.ParseError = err.Error() return } for _, name := range []string{"From", "To", "Cc", "Date", "Subject", "Message-ID"} { if value := message.Header.Get(name); value != "" { if decoded, err := new(mime.WordDecoder).DecodeHeader(value); err == nil { value = decoded } view.Metadata = append(view.Metadata, metadataView{name, value}) } } view.Text = emailText(message.Header, message.Body) case "pe": file, err := pe.NewFile(bytes.NewReader(body)) if err != nil { view.ParseError = err.Error() return } defer file.Close() view.Metadata = append(view.Metadata, metadataView{"Machine", fmt.Sprintf("0x%04x", file.FileHeader.Machine)}, metadataView{"Sections", strconv.Itoa(int(file.FileHeader.NumberOfSections))}, metadataView{"Timestamp", strconv.FormatUint(uint64(file.FileHeader.TimeDateStamp), 10)}, metadataView{"Characteristics", fmt.Sprintf("0x%04x", file.FileHeader.Characteristics)}, ) for _, section := range file.Sections { view.Metadata = append(view.Metadata, metadataView{ "Section " + section.Name, fmt.Sprintf("virtual=%d raw=%d", section.VirtualSize, section.Size), }) } case "debian-package": parseDebianPackage(view, body) } } const ( maxExcalidrawBytes = 2 << 20 maxExcalidrawElements = 5000 maxExcalidrawPoints = 100000 maxExcalidrawText = 1 << 20 ) func parseExcalidrawView(view *contentView, body []byte) { if len(body) > maxExcalidrawBytes { view.ParseError = "Excalidraw scene exceeds the 2 MiB interactive limit" return } var scene struct { Type string `json:"type"` Elements []json.RawMessage `json:"elements"` } if err := json.Unmarshal(body, &scene); err != nil { view.ParseError = err.Error() return } if scene.Type != "excalidraw" { view.ParseError = "invalid Excalidraw scene type" return } if len(scene.Elements) > maxExcalidrawElements { view.ParseError = "Excalidraw scene exceeds the 5000 element limit" return } pointsTotal := 0 textTotal := 0 for _, raw := range scene.Elements { var element struct { Type string `json:"type"` X float64 `json:"x"` Y float64 `json:"y"` W float64 `json:"width"` H float64 `json:"height"` Points [][]float64 `json:"points"` Text string `json:"text"` } if err := json.Unmarshal(raw, &element); err != nil || element.Type == "" || math.IsNaN(element.X) || math.IsInf(element.X, 0) || math.IsNaN(element.Y) || math.IsInf(element.Y, 0) || math.IsNaN(element.W) || math.IsInf(element.W, 0) || math.IsNaN(element.H) || math.IsInf(element.H, 0) { view.ParseError = "invalid Excalidraw element" return } pointsTotal += len(element.Points) textTotal += len(element.Text) if pointsTotal > maxExcalidrawPoints || textTotal > maxExcalidrawText { view.ParseError = "Excalidraw scene complexity exceeds the interactive limit" return } for _, point := range element.Points { if len(point) < 2 || math.IsNaN(point[0]) || math.IsInf(point[0], 0) || math.IsNaN(point[1]) || math.IsInf(point[1], 0) { view.ParseError = "invalid Excalidraw point" return } } } view.ExcalidrawValid = true view.ExcalidrawElements = len(scene.Elements) } const ( maxCSVRows = 500 maxCSVColumns = 100 maxCSVCellBytes = 16 << 10 ) func parseCSVView(view *contentView, body []byte) { reader := csv.NewReader(bytes.NewReader(body)) reader.FieldsPerRecord = -1 for len(view.CSVRows) < maxCSVRows { record, err := reader.Read() if err == io.EOF { return } if err != nil { // A bounded initial window can end halfway through its final record. view.CSVTruncated = true if len(view.CSVRows) == 0 { view.ParseError = err.Error() } return } if len(record) > maxCSVColumns { record = record[:maxCSVColumns] view.CSVTruncated = true } for index, cell := range record { if len(cell) > maxCSVCellBytes { prefix := []byte(cell[:maxCSVCellBytes]) for len(prefix) > 0 && !utf8.Valid(prefix) { prefix = prefix[:len(prefix)-1] } record[index] = string(prefix) + "…" view.CSVTruncated = true } } view.CSVRows = append(view.CSVRows, record) } if _, err := reader.Read(); err != io.EOF { view.CSVTruncated = true } } func emailText(header mail.Header, body io.Reader) string { mediaType, params, _ := mime.ParseMediaType(header.Get("Content-Type")) if strings.HasPrefix(mediaType, "multipart/") && params["boundary"] != "" { reader := multipart.NewReader(body, params["boundary"]) for { part, err := reader.NextPart() if err != nil { break } partType, _, _ := mime.ParseMediaType(part.Header.Get("Content-Type")) if partType == "text/plain" || partType == "text/html" || partType == "" { return readMailBody(part.Header.Get("Content-Transfer-Encoding"), part) } } return "" } return readMailBody(header.Get("Content-Transfer-Encoding"), body) } func readMailBody(encoding string, body io.Reader) string { switch strings.ToLower(strings.TrimSpace(encoding)) { case "quoted-printable": body = quotedprintable.NewReader(body) case "base64": body = base64.NewDecoder(base64.StdEncoding, body) } payload, _ := io.ReadAll(io.LimitReader(body, 4<<20)) return string(payload) } func parseDebianPackage(view *contentView, body []byte) { reader := bufio.NewReader(bytes.NewReader(body)) magic := make([]byte, 8) if _, err := io.ReadFull(reader, magic); err != nil || string(magic) != "!\n" { view.ParseError = "invalid Debian ar archive" return } for { header := make([]byte, 60) if _, err := io.ReadFull(reader, header); err != nil { break } name := strings.TrimSpace(strings.TrimSuffix(string(header[:16]), "/")) size, err := strconv.ParseInt(strings.TrimSpace(string(header[48:58])), 10, 64) if err != nil || size < 0 { view.ParseError = "invalid ar member" return } payload := make([]byte, size) if _, err := io.ReadFull(reader, payload); err != nil { view.ParseError = err.Error() return } if size%2 != 0 { _, _ = reader.ReadByte() } view.Metadata = append(view.Metadata, metadataView{"Member", fmt.Sprintf("%s (%d bytes)", name, size)}) if name == "debian-binary" { view.Metadata = append(view.Metadata, metadataView{"Debian format", strings.TrimSpace(string(payload))}) } if name == "control.tar.gz" { parseDebControl(view, payload) } } } func parseDebControl(view *contentView, payload []byte) { gz, err := gzip.NewReader(bytes.NewReader(payload)) if err != nil { return } defer gz.Close() tr := tar.NewReader(gz) for { header, err := tr.Next() if err != nil { return } if strings.TrimPrefix(header.Name, "./") != "control" { continue } control, _ := io.ReadAll(io.LimitReader(tr, 1<<20)) view.Text = string(control) message, err := mail.ReadMessage(bytes.NewReader(append(control, '\n', '\n'))) if err == nil { for name, values := range message.Header { view.Metadata = append(view.Metadata, metadataView{name, strings.Join(values, ", ")}) } } return } } func archiveEntryContentType(name string, data []byte) string { if byExtension := mime.TypeByExtension(strings.ToLower(filepath.Ext(name))); byExtension != "" { return byExtension } return "application/octet-stream" }