fix backend audit findings (auth, upload, sync, data, ocr, contract)
CI / lint-backend (push) Failing after 1m39s
CI / lint-mobile (push) Canceled after 11m8s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
CI / lint-backend (push) Failing after 1m39s
CI / lint-mobile (push) Canceled after 11m8s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
This commit is contained in:
+187
-21
@@ -4,9 +4,11 @@ import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"mime/multipart"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
@@ -16,6 +18,10 @@ import (
|
||||
// ErrFileTooLarge signals an upload above MaxFileSize.
|
||||
var ErrFileTooLarge = errors.New("file too large")
|
||||
|
||||
// ErrInvalidUpload signals a rejected upload (display name or path component).
|
||||
// Handlers map it to 400 INVALID_REQUEST (never 500).
|
||||
var ErrInvalidUpload = errors.New("invalid upload name")
|
||||
|
||||
// FileDTO serializes exactly as mobile/api/types.ts FileDto.
|
||||
type FileDTO struct {
|
||||
ID string `json:"id"`
|
||||
@@ -53,6 +59,66 @@ func NewResources(repo *repository.Repository, uploadDir string, maxFileSize int
|
||||
}
|
||||
}
|
||||
|
||||
var (
|
||||
extensionPattern = regexp.MustCompile(`^[a-z0-9]{1,10}$`)
|
||||
idPattern = regexp.MustCompile(`^[0-9a-f]{32}$`)
|
||||
)
|
||||
|
||||
// allowedMimeTypes whitelists client-declared Content-Types (parameters
|
||||
// stripped, lowercased) ; anything absent falls back to
|
||||
// application/octet-stream (cf. FEEDBACK A16).
|
||||
var allowedMimeTypes = map[string]struct{}{
|
||||
"application/octet-stream": {},
|
||||
"application/pdf": {},
|
||||
"application/json": {},
|
||||
"application/zip": {},
|
||||
"text/plain": {},
|
||||
"text/csv": {},
|
||||
"text/markdown": {},
|
||||
"image/png": {},
|
||||
"image/jpeg": {},
|
||||
"image/gif": {},
|
||||
"image/webp": {},
|
||||
"audio/mpeg": {},
|
||||
"video/mp4": {},
|
||||
}
|
||||
|
||||
// sanitizeExtension normalise l'extension issue du filename client (cf.
|
||||
// FEEDBACK #5) : lowercase, [a-z0-9]{1,10}, sinon "" (pas de suffixe).
|
||||
func sanitizeExtension(filename string) string {
|
||||
ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(filename), "."))
|
||||
if !extensionPattern.MatchString(ext) {
|
||||
return ""
|
||||
}
|
||||
return ext
|
||||
}
|
||||
|
||||
// sanitizeFileName nettoie le nom stocké (cf. FEEDBACK A16) : TrimSpace,
|
||||
// cap 255, rejet vide / slash / backslash / retour ligne. Le nom n'est
|
||||
// qu'une métadonnée (jamais un composant de chemin), mais on le verrouille
|
||||
// quand même pour casser toute confusion downstream.
|
||||
func sanitizeFileName(name string) (string, error) {
|
||||
n := strings.TrimSpace(name)
|
||||
if n == "" || len(n) > 255 || strings.ContainsAny(n, "/\\\x00\n\r") {
|
||||
return "", ErrInvalidUpload
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
|
||||
func sanitizeMimeType(mime string) string {
|
||||
m := strings.ToLower(strings.TrimSpace(mime))
|
||||
if i := strings.IndexByte(m, ';'); i >= 0 {
|
||||
m = strings.TrimSpace(m[:i])
|
||||
}
|
||||
if m == "" || len(m) > 128 {
|
||||
return "application/octet-stream"
|
||||
}
|
||||
if _, ok := allowedMimeTypes[m]; !ok {
|
||||
return "application/octet-stream"
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
func (s *Resources) ListFiles(ownerID, folderID string, page, pageSize int, sort, order string) ([]FileDTO, int, error) {
|
||||
rows, total, err := s.Repo.ListFilesVisible(ownerID, folderID, pageSize, (page-1)*pageSize, sort, order)
|
||||
if err != nil {
|
||||
@@ -132,66 +198,166 @@ func (s *Resources) SearchFiles(ownerID, q string, page, pageSize int) ([]FileDT
|
||||
// rename, never a move, never a duplicate row. Unknown / foreign resource →
|
||||
// repo.ErrNotFound.
|
||||
func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, resourceID string) (FileDTO, error) {
|
||||
if file.Size > s.MaxFileSize {
|
||||
return FileDTO{}, ErrFileTooLarge
|
||||
// Garde anti-traversal : seuls des IDs 32-hex (ou générés) deviennent des
|
||||
// composants de chemin. ownerID vient de l'auth mais on ne lui fait pas
|
||||
// confiance aveuglément ; resourceID fourni par le client est déjà
|
||||
// pré-validé côté handler (404), ici on rejete en NotFound/400 pareil.
|
||||
if strings.ContainsAny(ownerID, "/\\\x00\n\r") || strings.Contains(ownerID, "..") {
|
||||
return FileDTO{}, ErrInvalidUpload
|
||||
}
|
||||
|
||||
targetExisting := resourceID != ""
|
||||
if targetExisting {
|
||||
if !idPattern.MatchString(resourceID) {
|
||||
return FileDTO{}, repository.ErrNotFound
|
||||
}
|
||||
if _, err := s.Repo.GetFile(ownerID, resourceID); err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
} else {
|
||||
resourceID = repository.NewID()
|
||||
var err error
|
||||
resourceID, err = repository.NewIDErr()
|
||||
if err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
}
|
||||
|
||||
extension := strings.TrimPrefix(filepath.Ext(file.Filename), ".")
|
||||
name, err := sanitizeFileName(file.Filename)
|
||||
if err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
extension := sanitizeExtension(file.Filename)
|
||||
destDir := filepath.Join(s.UploadDir, ownerID)
|
||||
if err := os.MkdirAll(destDir, 0o755); err != nil {
|
||||
if err := os.MkdirAll(destDir, 0o700); err != nil {
|
||||
return FileDTO{}, fmt.Errorf("create upload dir: %w", err)
|
||||
}
|
||||
// MkdirAll respecte umask et ne touche pas aux dirs préexistants : on
|
||||
// enforce 0700 explicitement (cf. FEEDBACK A4).
|
||||
if err := os.Chmod(destDir, 0o700); err != nil {
|
||||
return FileDTO{}, fmt.Errorf("chmod upload dir: %w", err)
|
||||
}
|
||||
|
||||
destPath := filepath.Join(destDir, resourceID+"."+extension)
|
||||
if err := copyMultipart(file, destPath); err != nil {
|
||||
destName := resourceID
|
||||
if extension != "" {
|
||||
destName = resourceID + "." + extension
|
||||
}
|
||||
destPath := filepath.Join(destDir, destName)
|
||||
|
||||
// Mémorise les anciens physiques pour cleanup post-succès (changement d'ext).
|
||||
// Note : Glob(id.*) ne matche pas le fichier sans extension, on traite le
|
||||
// chemin nu séparément (cf. FEEDBACK #6).
|
||||
oldMatches, _ := filepath.Glob(filepath.Join(destDir, resourceID+".*"))
|
||||
barePath := filepath.Join(destDir, resourceID)
|
||||
if barePath != destPath {
|
||||
if _, err := os.Stat(barePath); err == nil {
|
||||
oldMatches = append(oldMatches, barePath)
|
||||
}
|
||||
}
|
||||
|
||||
written, err := copyMultipartAtomic(file, destDir, destPath, s.MaxFileSize)
|
||||
if err != nil {
|
||||
return FileDTO{}, err
|
||||
}
|
||||
|
||||
mimeType := file.Header.Get("Content-Type")
|
||||
var err error
|
||||
mimeType := sanitizeMimeType(file.Header.Get("Content-Type"))
|
||||
var extPtr *string
|
||||
if extension != "" {
|
||||
extPtr = &extension
|
||||
}
|
||||
if targetExisting {
|
||||
err = s.Repo.UpdatePhysical(ownerID, resourceID, file.Size, &mimeType, &extension)
|
||||
err = s.Repo.UpdatePhysical(ownerID, resourceID, written, &mimeType, extPtr)
|
||||
} else {
|
||||
err = s.Repo.InsertFile(ownerID, resourceID, file.Filename, folderID, file.Size, &mimeType, &extension)
|
||||
err = s.Repo.InsertFile(ownerID, resourceID, name, folderID, written, &mimeType, extPtr)
|
||||
}
|
||||
if err != nil {
|
||||
_ = os.Remove(destPath)
|
||||
// Best-effort : supprime le nouveau fichier sauf s'il préexistait à l'identique.
|
||||
stillOld := false
|
||||
for _, m := range oldMatches {
|
||||
if m == destPath {
|
||||
stillOld = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !stillOld {
|
||||
_ = os.Remove(destPath)
|
||||
}
|
||||
return FileDTO{}, err
|
||||
}
|
||||
// Succès : supprime les anciens suffixes orphelins (stale bytes, cf. #6).
|
||||
for _, m := range oldMatches {
|
||||
if m != destPath && strings.HasPrefix(filepath.Base(m), resourceID+".") {
|
||||
_ = os.Remove(m)
|
||||
}
|
||||
}
|
||||
|
||||
row, err := s.Repo.GetFile(ownerID, resourceID)
|
||||
if err != nil {
|
||||
// Lecture post-insert en échec : au moins logguer (cf. FEEDBACK #6).
|
||||
// Sur création on tente en plus de retirer le fichier pour ne pas
|
||||
// laisser d'orphelin (le client retry → NAME_CONFLICT → re-upload
|
||||
// ciblé). Sur re-upload ciblé on ne touche à rien (données existantes).
|
||||
log.Printf("upload: GetFile(%s) failed after persist: %v", resourceID, err)
|
||||
if !targetExisting {
|
||||
_ = os.Remove(destPath)
|
||||
}
|
||||
return FileDTO{}, err
|
||||
}
|
||||
return toFileDTO(row), nil
|
||||
}
|
||||
|
||||
func copyMultipart(file *multipart.FileHeader, destPath string) error {
|
||||
// copyMultipartAtomic écrit vers un temp dans destDir (0600) avec limite
|
||||
// stricte maxSize+1 (header file.Size non fiable, cf. A2), fsync + rename
|
||||
// atomique (cf. A3). Retourne les octets réellement écrits.
|
||||
func copyMultipartAtomic(file *multipart.FileHeader, destDir, destPath string, maxSize int64) (int64, error) {
|
||||
src, err := file.Open()
|
||||
if err != nil {
|
||||
return fmt.Errorf("open multipart file: %w", err)
|
||||
return 0, fmt.Errorf("open multipart file: %w", err)
|
||||
}
|
||||
defer src.Close()
|
||||
|
||||
dst, err := os.Create(destPath)
|
||||
// Temp dans le même répertoire (même filesystem → rename atomique),
|
||||
// pattern .tmp-<base>-* (cf. FEEDBACK A3). Jamais d'overwrite direct.
|
||||
tmp, err := os.CreateTemp(destDir, ".tmp-"+filepath.Base(destPath)+".*")
|
||||
if err != nil {
|
||||
return fmt.Errorf("create file: %w", err)
|
||||
return 0, fmt.Errorf("create tmp file: %w", err)
|
||||
}
|
||||
tmpName := tmp.Name()
|
||||
// En cas d'échec avant rename, nettoyer le temp.
|
||||
success := false
|
||||
defer func() {
|
||||
if !success {
|
||||
_ = os.Remove(tmpName)
|
||||
}
|
||||
}()
|
||||
if err := tmp.Chmod(0o600); err != nil {
|
||||
tmp.Close()
|
||||
return 0, fmt.Errorf("chmod tmp file: %w", err)
|
||||
}
|
||||
defer dst.Close()
|
||||
|
||||
if _, err := io.Copy(dst, src); err != nil {
|
||||
return fmt.Errorf("copy upload: %w", err)
|
||||
limited := io.LimitReader(src, maxSize+1)
|
||||
written, err := io.Copy(tmp, limited)
|
||||
if err != nil {
|
||||
tmp.Close()
|
||||
return 0, fmt.Errorf("copy upload: %w", err)
|
||||
}
|
||||
return nil
|
||||
if written > maxSize {
|
||||
tmp.Close()
|
||||
return 0, ErrFileTooLarge
|
||||
}
|
||||
if err := tmp.Sync(); err != nil {
|
||||
tmp.Close()
|
||||
return 0, fmt.Errorf("fsync upload: %w", err)
|
||||
}
|
||||
if err := tmp.Close(); err != nil {
|
||||
return 0, fmt.Errorf("close upload: %w", err)
|
||||
}
|
||||
if err := os.Rename(tmpName, destPath); err != nil {
|
||||
return 0, fmt.Errorf("commit upload: %w", err)
|
||||
}
|
||||
if err := os.Chmod(destPath, 0o600); err != nil {
|
||||
return 0, fmt.Errorf("chmod upload: %w", err)
|
||||
}
|
||||
success = true
|
||||
return written, nil
|
||||
}
|
||||
|
||||
func toFileDTO(row repository.FileRow) FileDTO {
|
||||
|
||||
Reference in New Issue
Block a user