Files
agent-radar 2ed3415fb7
Publish Claude Code Binaries / Stage and publish binaries (push) Canceled after 0s
Publish Tutti App Runtime / Build darwin-arm64 (push) Canceled after 0s
Publish Tutti App Runtime / Build darwin-amd64 (push) Canceled after 0s
Publish Tutti App Runtime / Build linux-amd64 (push) Canceled after 0s
Publish Tutti App Runtime / Build windows-amd64 (push) Canceled after 0s
Sync Tutti Agent Skills / sync (push) Canceled after 0s
Windows Agent Adapters / Test Windows agent adapters (push) Canceled after 0s
Windows Daemon Adapters / Test Windows daemon adapters (push) Canceled after 0s
Publish Tutti App Runtime / Publish runtime catalog (push) Canceled after 0s
源码快照 @ 2026-09-01 (source-only, 剔除非源码素材)
2026-09-01 20:17:27 +08:00

199 lines
5.6 KiB
Go

package agentextension
import (
"archive/zip"
"bytes"
"crypto/sha256"
"encoding/binary"
"encoding/hex"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"sort"
"strings"
)
const (
installationRecordName = "installation.json"
signedReleaseRecordName = ".tutti-signed-release.json"
signedReleaseArtifactName = ".tutti-signed-artifact.zip"
)
func internalPackageRecord(relative string) bool {
switch filepath.ToSlash(relative) {
case installationRecordName, signedReleaseRecordName, signedReleaseArtifactName:
return true
default:
return false
}
}
func packageContentSHA256(root string) (string, error) {
root = filepath.Clean(root)
info, err := os.Lstat(root)
if err != nil {
return "", err
}
if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
return "", errors.New("extension package root is not an ordinary directory")
}
files := make([]string, 0, maxFiles)
var total int64
err = filepath.WalkDir(root, func(path string, entry os.DirEntry, walkErr error) error {
if walkErr != nil {
return walkErr
}
if path == root {
return nil
}
relative, err := filepath.Rel(root, path)
if err != nil {
return err
}
if entry.Type()&os.ModeSymlink != 0 {
return fmt.Errorf("extension package contains symlink: %s", relative)
}
if entry.IsDir() {
return nil
}
if internalPackageRecord(relative) {
return nil
}
info, err := entry.Info()
if err != nil {
return err
}
if !info.Mode().IsRegular() {
return fmt.Errorf("extension package contains non-regular file: %s", relative)
}
if len(files) >= maxFiles {
return errors.New("extension package file count exceeds limit")
}
total += info.Size()
if total > maxArtifact {
return errors.New("extension package exceeds expanded size limit")
}
files = append(files, relative)
return nil
})
if err != nil {
return "", err
}
if len(files) == 0 {
return "", errors.New("extension package is empty")
}
sort.Strings(files)
hash := sha256.New()
var length [8]byte
for _, relative := range files {
canonical := filepath.ToSlash(relative)
binary.BigEndian.PutUint64(length[:], uint64(len(canonical)))
_, _ = hash.Write(length[:])
_, _ = io.WriteString(hash, canonical)
filePath := filepath.Join(root, relative)
pathInfo, err := os.Lstat(filePath)
if err != nil || pathInfo.Mode()&os.ModeSymlink != 0 || !pathInfo.Mode().IsRegular() {
return "", fmt.Errorf("extension package file identity is unsafe: %s", relative)
}
file, err := os.Open(filePath)
if err != nil {
return "", err
}
info, err := file.Stat()
if err != nil || !os.SameFile(pathInfo, info) {
file.Close()
return "", fmt.Errorf("extension package file identity changed: %s", relative)
}
binary.BigEndian.PutUint64(length[:], uint64(info.Size()))
_, _ = hash.Write(length[:])
_, copyErr := io.Copy(hash, file)
closeErr := file.Close()
if copyErr != nil {
return "", copyErr
}
if closeErr != nil {
return "", closeErr
}
}
return hex.EncodeToString(hash.Sum(nil)), nil
}
func validPackageContentSHA256(value string) bool {
value = strings.TrimSpace(value)
if len(value) != sha256.Size*2 {
return false
}
_, err := hex.DecodeString(value)
return err == nil && value == strings.ToLower(value)
}
func packageArchiveContentSHA256(data []byte) (string, error) {
reader, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
if err != nil {
return "", err
}
if len(reader.File) == 0 || len(reader.File) > maxFiles {
return "", errors.New("agent extension archive file count is invalid")
}
files := make(map[string][]byte, len(reader.File))
var total uint64
for _, archived := range reader.File {
name := filepath.Clean(filepath.FromSlash(archived.Name))
if name == "." || filepath.IsAbs(name) || name == ".." || strings.HasPrefix(name, ".."+string(filepath.Separator)) {
return "", errors.New("agent extension archive contains unsafe path")
}
if archived.Mode()&os.ModeSymlink != 0 {
return "", errors.New("agent extension archive contains symlink")
}
if archived.FileInfo().IsDir() {
continue
}
if internalPackageRecord(name) || archived.Mode()&0o111 != 0 || !allowedExtension(filepath.Ext(name)) {
return "", fmt.Errorf("agent extension archive contains forbidden file: %s", name)
}
canonical := filepath.ToSlash(name)
if _, exists := files[canonical]; exists {
return "", fmt.Errorf("agent extension archive contains duplicate file: %s", canonical)
}
total += archived.UncompressedSize64
if total > maxArtifact {
return "", errors.New("agent extension archive exceeds expanded size limit")
}
source, err := archived.Open()
if err != nil {
return "", err
}
content, readErr := io.ReadAll(io.LimitReader(source, int64(archived.UncompressedSize64)+1))
closeErr := source.Close()
if readErr != nil || closeErr != nil {
return "", errors.Join(readErr, closeErr)
}
if uint64(len(content)) != archived.UncompressedSize64 {
return "", errors.New("agent extension archive file size changed while reading")
}
files[canonical] = content
}
if len(files) == 0 {
return "", errors.New("extension package is empty")
}
names := make([]string, 0, len(files))
for name := range files {
names = append(names, name)
}
sort.Strings(names)
hash := sha256.New()
var length [8]byte
for _, name := range names {
binary.BigEndian.PutUint64(length[:], uint64(len(name)))
_, _ = hash.Write(length[:])
_, _ = io.WriteString(hash, name)
content := files[name]
binary.BigEndian.PutUint64(length[:], uint64(len(content)))
_, _ = hash.Write(length[:])
_, _ = hash.Write(content)
}
return hex.EncodeToString(hash.Sum(nil)), nil
}