Files
Bedrock/internal/platform/canvas_ai_image_inputs.go
T

226 lines
7.4 KiB
Go

// 图片输入冻结与执行前装载:远程引用转为私有不可变资产,实际执行再次校验目标及资产权限。
package platform
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/base64"
"encoding/hex"
"errors"
"io"
"net"
"net/http"
"net/netip"
"net/url"
"strings"
"time"
"gitea.entroia.com/Zayden-Jung/Bedrock/internal/codex"
)
// canvasPublicIP 排除本地/私有/链路/保留测试网和已列元数据地址,IPv4 映射先 Unmap 再检查。
func canvasPublicIP(ip netip.Addr) bool {
ip = ip.Unmap()
if !ip.IsValid() || !ip.IsGlobalUnicast() || ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() {
return false
}
for _, cidr := range []string{"0.0.0.0/8", "100.64.0.0/10", "168.63.129.16/32", "192.0.0.0/24", "192.0.2.0/24", "198.18.0.0/15", "198.51.100.0/24", "203.0.113.0/24", "240.0.0.0/4", "2001:db8::/32"} {
if netip.MustParsePrefix(cidr).Contains(ip) {
return false
}
}
return true
}
// canvasImageURL 仅允许短 HTTPS URL 且无用户信息,具体 DNS/IP 约束由 fetchCanvasImage 执行。
func canvasImageURL(raw string) bool {
u, err := url.Parse(raw)
return err == nil && u.Scheme == "https" && u.Hostname() != "" && u.User == nil && len(raw) < 2048
}
// fetchCanvasImage 每次连接解析并校验完整 DNS 结果,再直连已验证字面 IP,避免二次解析重绑定。
// 重定向仍需 HTTPS 且每次重新验证目标,响应字节和请求时间都有上限。
func fetchCanvasImage(ctx context.Context, src string) ([]byte, error) {
if !canvasImageURL(src) {
return nil, errors.New("invalid_image_input")
}
transport := &http.Transport{DisableCompression: true, DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
host, port, err := net.SplitHostPort(address)
if err != nil {
return nil, err
}
addresses, err := net.DefaultResolver.LookupNetIP(ctx, "ip", host)
if err != nil {
return nil, err
}
// Reject the whole DNS answer if it contains a private address. Dial a
// validated literal so a second DNS resolution cannot rebind the hostname.
if len(addresses) == 0 {
return nil, errors.New("invalid_image_host")
}
for _, ip := range addresses {
if !canvasPublicIP(ip) {
return nil, errors.New("invalid_image_host")
}
}
dialer := net.Dialer{Timeout: 5 * time.Second}
for _, ip := range addresses {
connection, e := dialer.DialContext(ctx, network, net.JoinHostPort(ip.String(), port))
if e == nil {
return connection, nil
}
err = e
}
return nil, err
}}
defer transport.CloseIdleConnections()
client := &http.Client{Transport: transport, Timeout: 5 * time.Second, CheckRedirect: func(request *http.Request, via []*http.Request) error {
if len(via) > 3 || !canvasImageURL(request.URL.String()) {
return errors.New("invalid_image_redirect")
}
return nil
}}
request, err := http.NewRequestWithContext(ctx, "GET", src, nil)
if err != nil {
return nil, err
}
response, err := client.Do(request)
if err != nil {
return nil, err
}
defer response.Body.Close()
if response.StatusCode != 200 || response.ContentLength > assetLimit {
return nil, errors.New("invalid_image_input")
}
data, err := io.ReadAll(io.LimitReader(response.Body, assetLimit+1))
if err != nil || len(data) > assetLimit {
return nil, errors.New("invalid_image_input")
}
return data, nil
}
// freezeCanvasImage 已托管图片只重查可读性并保存 assetId;data/远程图完整检查后写不可变资产及来源画布绑定。
func (s *service) freezeCanvasImage(ctx context.Context, tx *sql.Tx, project, workspace, board, account string, content map[string]any) (map[string]any, error) {
id, _ := content["assetId"].(string)
src, _ := content["src"].(string)
prefix := s.assetURL(project, workspace, "")
if id == "" && strings.HasPrefix(src, prefix) {
id = strings.TrimPrefix(src, prefix)
}
if id != "" {
if !uuidSlugPattern.MatchString(id) {
return nil, errors.New("invalid_image_input")
}
allowed, err := assetReadable(queueRequest(ctx), tx, project, workspace, id, account)
if err != nil {
return nil, err
}
if !allowed {
return nil, errors.New("invalid_image_input")
}
return map[string]any{"assetId": id}, nil
}
var data []byte
var err error
if strings.HasPrefix(src, "data:image/") {
_, encoded, ok := strings.Cut(src, ",")
if !ok {
return nil, errors.New("invalid_image_input")
}
data, err = base64.StdEncoding.DecodeString(encoded)
} else {
data, err = fetchCanvasImage(ctx, src)
}
if err != nil || len(data) == 0 || len(data) > assetLimit {
return nil, errors.New("invalid_image_input")
}
mime, width, height, err := inspectAsset(data)
if err != nil {
return nil, errors.New("invalid_image_input")
}
digest := sha256.Sum256(data)
err = tx.QueryRowContext(ctx, `INSERT INTO canvas_assets(project,workspace_id,uploaded_by,mime_type,bytes,width,height,digest,idempotency_key) VALUES($1,$2,$3,$4,$5,$6,$7,$8,gen_random_uuid()) RETURNING id::text`, project, workspace, account, mime, data, width, height, hex.EncodeToString(digest[:])).Scan(&id)
if err != nil {
return nil, err
}
_, err = tx.ExecContext(ctx, `INSERT INTO canvas_asset_bindings(project,workspace_id,asset_id,board_id) VALUES($1,$2,$3,$4)`, project, workspace, id, board)
if err != nil {
return nil, err
}
return map[string]any{"assetId": id}, nil
}
// hydrateCanvasTask 汇集自身冻结图、静态前驱和本轮前驱输出资产,去重后加载原图到私有 IPC task。
// 执行前重新解析 canonical owner/代数并核对编辑及资产权限,最多四图和二十 MiB。
func (s *service) hydrateCanvasTask(ctx context.Context, run canvasQueueRun, step canvasAIStepPlan, results map[string]canvasStepResult, task *codex.CanvasTask) error {
ids := []string{}
if id, _ := step.FrozenContent["assetId"].(string); id != "" {
ids = append(ids, id)
}
for _, source := range step.StaticInputs {
if id, _ := source.Content["assetId"].(string); id != "" {
ids = append(ids, id)
}
}
for _, edge := range run.Plan.Edges {
if edge.Target == step.ID {
if id := results[edge.Source].AssetID; id != "" {
ids = append(ids, id)
}
}
}
seen := map[string]bool{}
total := 0
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
if err = lockCanvasAIWorkspace(ctx, tx, run.Project, run.Workspace); err != nil {
return err
}
board, ok, err := resolveCanvasAITarget(ctx, tx, run.Project, run.Workspace, step)
if err != nil {
return err
}
if !ok {
return errors.New("target_removed")
}
_, role, err := lockMaterial(ctx, tx, run.Project, run.Workspace, board, run.Account)
if err != nil {
return err
}
if role == "viewer" {
return errors.New("permission_revoked")
}
for _, id := range ids {
if seen[id] {
continue
}
seen[id] = true
if len(seen) > 4 {
return errors.New("context_too_large")
}
allowed, err := assetReadable(queueRequest(ctx), tx, run.Project, run.Workspace, id, run.Account)
if err != nil {
return err
}
if !allowed {
return errors.New("permission_revoked")
}
var image codex.CanvasImage
err = tx.QueryRowContext(ctx, `SELECT mime_type,bytes FROM canvas_assets WHERE project=$1 AND workspace_id=$2 AND id=$3`, run.Project, run.Workspace, id).Scan(&image.MIME, &image.Data)
if err != nil {
return err
}
total += len(image.Data)
if total > codex.CanvasImageBytesLimit {
return errors.New("context_too_large")
}
task.Images = append(task.Images, image)
}
return nil
}