Skill 安全检测

package main

import (
    "archive/zip"
    "bytes"
    "compress/flate"
    "crypto/sha256"
    "encoding/base64"
    "encoding/hex"
    "fmt"
    "io"
    "os"
    "path/filepath"
    "sort"
    "strings"
    "time"
)

// 固定时间戳：2000-01-01 00:00:00 UTC
var fixedModTime = time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)

func packSkillDir(skillDir string) ([]byte, error) {
    // 1. 收集所有文件的相对路径
    var files []string
    err := filepath.Walk(skillDir, func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        if info.IsDir() {
            return nil // 不写入目录条目
        }
        rel, err := filepath.Rel(skillDir, path)
        if err != nil {
            return err
        }
        // 统一使用 / 作为 ZIP 内路径分隔符
        files = append(files, filepath.ToSlash(rel))
        return nil
    })
    if err != nil {
        return nil, err
    }

    // 2. 按路径字节序排序（等价于 LC_ALL=C sort）
    sort.Strings(files)

    // 3. 写入 ZIP（压缩级别 6，固定时间戳，固定权限 0644）
    buf := new(bytes.Buffer)
    zw := zip.NewWriter(buf)
    // 显式注册压缩级别 6 的 deflate writer，确保跨 Go 版本输出稳定
    zw.RegisterCompressor(zip.Deflate, func(out io.Writer) (io.WriteCloser, error) {
        return flate.NewWriter(out, 6)
    })

    for _, rel := range files {
        header := &zip.FileHeader{
            Name:     rel,
            Method:   zip.Deflate,
            Modified: fixedModTime,
        }
        header.SetMode(0644)
        // 不写入 Extra Field / Comment
        header.Extra = nil
        header.Comment = ""

        w, err := zw.CreateHeader(header)
        if err != nil {
            return nil, err
        }
        f, err := os.Open(filepath.Join(skillDir, filepath.FromSlash(rel)))
        if err != nil {
            return nil, err
        }
        if _, err := io.Copy(w, f); err != nil {
            f.Close()
            return nil, err
        }
        f.Close()
    }
    if err := zw.Close(); err != nil {
        return nil, err
    }
    return buf.Bytes(), nil
}

func main() {
    if len(os.Args) < 2 {
        fmt.Println("Usage: skill_package_to_base64 <skill_dir>")
        os.Exit(1)
    }
    skillDir := strings.TrimRight(os.Args[1], string(os.PathSeparator))

    zipBytes, err := packSkillDir(skillDir)
    if err != nil {
        fmt.Fprintf(os.Stderr, "pack failed: %v\\n", err)
        os.Exit(1)
    }

    sum := sha256.Sum256(zipBytes)
    fmt.Println("ContentHash:", hex.EncodeToString(sum[:]))
    fmt.Println("FileData (Base64):")
    fmt.Println(base64.StdEncoding.EncodeToString(zipBytes))
}

python3 skill_package_to_base64.py /path/to/skill_dir

#!/usr/bin/env python3
# skill_package_to_base64.py
# 按规范打包 Skill 目录为 ZIP，并输出 Base64 与 ContentHash(SHA256)
import base64
import hashlib
import io
import os
import sys
import zipfile

# 固定时间戳：2000-01-01 00:00:00 UTC
FIXED_DATE_TIME = (2000, 1, 1, 0, 0, 0)
# 文件权限 0644
UNIX_FILE_MODE = 0o644


def collect_files(skill_dir: str):
    """递归收集 skill_dir 下所有文件的相对路径，按字节序排序。"""
    files = []
    for root, _dirs, filenames in os.walk(skill_dir):
        for name in filenames:
            abs_path = os.path.join(root, name)
            rel = os.path.relpath(abs_path, skill_dir)
            # 统一使用 / 作为 ZIP 内路径分隔符
            rel = rel.replace(os.sep, "/")
            files.append(rel)
    # 按路径字节序排序（等价于 LC_ALL=C sort）
    files.sort(key=lambda s: s.encode("utf-8"))
    return files


def pack_skill_dir(skill_dir: str) -> bytes:
    buf = io.BytesIO()
    # 压缩级别固定为 6（Python 3.7+ 支持 compresslevel）
    with zipfile.ZipFile(
        buf, mode="w", compression=zipfile.ZIP_DEFLATED, compresslevel=6
    ) as zf:
        for rel in collect_files(skill_dir):
            abs_path = os.path.join(skill_dir, rel.replace("/", os.sep))
            with open(abs_path, "rb") as f:
                data = f.read()

            zi = zipfile.ZipInfo(filename=rel, date_time=FIXED_DATE_TIME)
            zi.compress_type = zipfile.ZIP_DEFLATED
            # 文件权限 0644 写入 external_attr 高 16 位
            zi.external_attr = (UNIX_FILE_MODE & 0xFFFF) << 16
            # 不写入 Extra Field / Comment
            zi.extra = b""
            zi.comment = b""

            zf.writestr(zi, data)

    return buf.getvalue()


def main():
    if len(sys.argv) < 2:
        print("Usage: python3 skill_package_to_base64.py <skill_dir>", file=sys.stderr)
        sys.exit(1)

    skill_dir = sys.argv[1].rstrip(os.sep)
    if not os.path.isdir(skill_dir):
        print(f"Not a directory: {skill_dir}", file=sys.stderr)
        sys.exit(1)

    zip_bytes = pack_skill_dir(skill_dir)
    content_hash = hashlib.sha256(zip_bytes).hexdigest()

    print("ContentHash:", content_hash)
    print("FileData (Base64):")
    print(base64.b64encode(zip_bytes).decode("ascii"))


if __name__ == "__main__":
    main()