- CHANGELOG.md:v2.8.0 条目(中英双语); - README.md:版本行 2.7.1→2.8.0 + 愿景第 6 条(知识可证明); - doc/releases/v2.8.0.md:双语发版说明(亮点/用法/已知限制); - skills/marqdo-dev/index.mq.md:新增 prove 任务(路径/目录模式/ require_lean/json;参数用 + 行声明升参,check 与 narrative-ratio 通过); - 设计文档 §12.5 标记已合入;发版链接统一指向 doc/releases/v2.8.0.md。
274 lines
6.5 KiB
Go
Executable File
274 lines
6.5 KiB
Go
Executable File
// Package upload ports media validation and offline save (W-G6).
|
|
package upload
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/marqdo/marqdo/plugins/web/internal/storage"
|
|
)
|
|
|
|
// Validate checks size / MIME / extension against optional allowlist table.
|
|
func Validate(filename, contentType string, size, maxBytes uint64, types any) map[string]any {
|
|
if size > maxBytes {
|
|
return map[string]any{
|
|
"ok": false,
|
|
"error": fmt.Sprintf("file too large: %d > %d", size, maxBytes),
|
|
}
|
|
}
|
|
name := strings.TrimSpace(filename)
|
|
if name == "" {
|
|
return map[string]any{"ok": false, "error": "empty filename"}
|
|
}
|
|
if strings.Contains(name, "..") || strings.Contains(name, "/") || strings.Contains(name, `\`) {
|
|
return map[string]any{"ok": false, "error": "unsafe filename"}
|
|
}
|
|
ct := strings.ToLower(strings.TrimSpace(contentType))
|
|
if i := strings.IndexByte(ct, ';'); i >= 0 {
|
|
ct = strings.TrimSpace(ct[:i])
|
|
}
|
|
ext := ""
|
|
if i := strings.LastIndexByte(name, '.'); i >= 0 && i < len(name)-1 {
|
|
ext = strings.ToLower(name[i+1:])
|
|
}
|
|
if types != nil && !typesAllow(types, ct, ext) {
|
|
return map[string]any{
|
|
"ok": false,
|
|
"error": fmt.Sprintf("type not allowed: content_type=%s ext=%s", ct, ext),
|
|
}
|
|
}
|
|
outCT := ct
|
|
if outCT == "" {
|
|
outCT = "application/octet-stream"
|
|
}
|
|
return map[string]any{
|
|
"ok": true,
|
|
"filename": name,
|
|
"content_type": outCT,
|
|
"size": float64(size),
|
|
"ext": ext,
|
|
}
|
|
}
|
|
|
|
func typesAllow(types any, contentType, ext string) bool {
|
|
if types == nil {
|
|
return true
|
|
}
|
|
switch t := types.(type) {
|
|
case string:
|
|
s := strings.TrimSpace(t)
|
|
if s == "" {
|
|
return true
|
|
}
|
|
for _, p := range strings.Split(s, ",") {
|
|
p = strings.ToLower(strings.TrimSpace(p))
|
|
if p != "" && p == contentType {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
case []any:
|
|
if len(t) == 0 {
|
|
return true
|
|
}
|
|
for _, row := range t {
|
|
if rowAllows(row, contentType, ext) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
case map[string]any:
|
|
colMime := first(t, "类型", "type", "mime")
|
|
colExt := first(t, "扩展名", "ext", "extension")
|
|
if ma, ok := colMime.([]any); ok {
|
|
var exts []string
|
|
switch ev := colExt.(type) {
|
|
case []any:
|
|
for _, x := range ev {
|
|
exts = append(exts, strings.ToLower(cellStr(x)))
|
|
}
|
|
case string:
|
|
exts = []string{strings.ToLower(ev)}
|
|
}
|
|
if len(ma) == 0 {
|
|
return true
|
|
}
|
|
for i, mimeV := range ma {
|
|
mime := strings.ToLower(strings.TrimSpace(cellStr(mimeV)))
|
|
rowExt := ""
|
|
if i < len(exts) {
|
|
rowExt = exts[i]
|
|
}
|
|
mimeOK := mime == "" || mime == contentType
|
|
extOK := rowExt == "" || extMatches(rowExt, ext)
|
|
if mimeOK && extOK {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
if colMime != nil || colExt != nil {
|
|
return rowAllows(t, contentType, ext)
|
|
}
|
|
if len(t) == 0 {
|
|
return true
|
|
}
|
|
for mime, extsV := range t {
|
|
exts := extList(extsV)
|
|
mimeOK := strings.TrimSpace(mime) == "" || strings.EqualFold(mime, contentType)
|
|
extOK := exts == "" || extMatches(exts, ext)
|
|
if mimeOK && extOK {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
default:
|
|
return true
|
|
}
|
|
}
|
|
|
|
func rowAllows(row any, contentType, ext string) bool {
|
|
switch t := row.(type) {
|
|
case string:
|
|
return strings.EqualFold(strings.TrimSpace(t), contentType)
|
|
case map[string]any:
|
|
mime := strings.ToLower(strings.TrimSpace(firstStr(t, "类型", "type", "mime")))
|
|
exts := strings.ToLower(strings.TrimSpace(firstStr(t, "扩展名", "ext", "extension")))
|
|
mimeOK := mime == "" || mime == contentType
|
|
extOK := exts == "" || extMatches(exts, ext)
|
|
return mimeOK && extOK
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func extMatches(exts, ext string) bool {
|
|
for _, e := range strings.Split(exts, ",") {
|
|
e = strings.TrimSpace(strings.TrimPrefix(e, "."))
|
|
if e == ext {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func extList(v any) string {
|
|
switch t := v.(type) {
|
|
case string:
|
|
return strings.ToLower(strings.TrimSpace(t))
|
|
case []any:
|
|
parts := make([]string, 0, len(t))
|
|
for _, x := range t {
|
|
if s, ok := x.(string); ok {
|
|
parts = append(parts, s)
|
|
}
|
|
}
|
|
return strings.ToLower(strings.Join(parts, ","))
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func first(m map[string]any, keys ...string) any {
|
|
for _, k := range keys {
|
|
if v, ok := m[k]; ok {
|
|
return v
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func firstStr(m map[string]any, keys ...string) string {
|
|
return cellStr(first(m, keys...))
|
|
}
|
|
|
|
func cellStr(v any) string {
|
|
switch t := v.(type) {
|
|
case nil:
|
|
return ""
|
|
case string:
|
|
return t
|
|
case float64:
|
|
if t == float64(int64(t)) {
|
|
return fmt.Sprintf("%d", int64(t))
|
|
}
|
|
return fmt.Sprintf("%v", t)
|
|
case bool:
|
|
if t {
|
|
return "true"
|
|
}
|
|
return "false"
|
|
default:
|
|
return fmt.Sprint(t)
|
|
}
|
|
}
|
|
|
|
// MakeKey builds prefix + timestamp-random + sanitized basename.
|
|
func MakeKey(prefix, filename string) (string, error) {
|
|
base := filename
|
|
if i := strings.LastIndexAny(filename, `/\`); i >= 0 {
|
|
base = filename[i+1:]
|
|
}
|
|
base = strings.TrimSpace(base)
|
|
if base == "" {
|
|
return "", fmt.Errorf("empty filename")
|
|
}
|
|
var safe strings.Builder
|
|
for _, c := range base {
|
|
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') ||
|
|
c == '.' || c == '-' || c == '_' {
|
|
safe.WriteRune(c)
|
|
} else {
|
|
safe.WriteRune('_')
|
|
}
|
|
}
|
|
s := safe.String()
|
|
if strings.Contains(s, "..") {
|
|
return "", fmt.Errorf("unsafe filename")
|
|
}
|
|
pref := strings.ReplaceAll(strings.TrimPrefix(strings.TrimSpace(prefix), "/"), `\`, "/")
|
|
if pref != "" && !strings.HasSuffix(pref, "/") {
|
|
pref += "/"
|
|
}
|
|
if strings.Contains(pref, "..") {
|
|
return "", fmt.Errorf("prefix must not contain `..`")
|
|
}
|
|
rnd := make([]byte, 4)
|
|
if _, err := rand.Read(rnd); err != nil {
|
|
return "", err
|
|
}
|
|
return fmt.Sprintf("%s%d-%s-%s", pref, time.Now().Unix(), hex.EncodeToString(rnd), s), nil
|
|
}
|
|
|
|
// Save reads local path bytes into storage under key (or auto key).
|
|
func Save(storageURL string, key *string, path string, contentType, prefix *string) (map[string]any, error) {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read `%s`: %w", path, err)
|
|
}
|
|
filename := filepath.Base(path)
|
|
ct := "application/octet-stream"
|
|
if contentType != nil && strings.TrimSpace(*contentType) != "" {
|
|
ct = strings.TrimSpace(*contentType)
|
|
}
|
|
objectKey := ""
|
|
if key != nil && strings.TrimSpace(*key) != "" {
|
|
objectKey = *key
|
|
} else {
|
|
p := "uploads/"
|
|
if prefix != nil && strings.TrimSpace(*prefix) != "" {
|
|
p = *prefix
|
|
}
|
|
objectKey, err = MakeKey(p, filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return storage.PutBytes(storageURL, objectKey, data, ct)
|
|
}
|