给 Claude 中转站验明正身：签名里的模型身份

package main

import (
	"encoding/base64"
	"fmt"
	"regexp"
	"strings"
)

// modelID 从签名中提取内部的模型标识明文
func modelID(signature string) string {
	raw, err := base64.StdEncoding.DecodeString(signature)
	if err != nil {
		return ""
	}
	re := regexp.MustCompile(`claude-[a-z0-9.\-]+`)
	return re.FindString(string(raw))
}

func main() {
	sig := "CAIS2QEKYggPGAIqQJBHPiLZ..." // 替换成你响应里的 signature
	mid := modelID(sig)
	if mid == "" {
		fmt.Println("没找到模型标识，响应可能没有 thinking 块，或者压根就是伪造的")
		return
	}
	fmt.Println("签名里写的模型:", mid)
	if strings.Contains(mid, "fable") {
		fmt.Println("跟请求的 claude-fable-5 对上了")
	} else {
		fmt.Println("警告：模型标识不匹配！")
	}
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
)

// verifySignature 把签名原样发给 OpenRouter（强制走 Anthropic 后端）验证
func verifySignature(signature string) (int, error) {
	payload := map[string]any{
		"model":      "anthropic/claude-fable-5",
		"max_tokens": 64,
		"provider":   map[string]any{"order": []string{"anthropic"}},
		"messages": []map[string]any{
			{"role": "user", "content": "2+2等于多少？"},
			{"role": "assistant", "content": []map[string]any{
				{"type": "thinking", "thinking": "", "signature": signature},
				{"type": "text", "text": "4"},
			}},
			{"role": "user", "content": "现在加3等于多少？"},
		},
	}
	body, err := json.Marshal(payload)
	if err != nil {
		return 0, err
	}
	req, err := http.NewRequest("POST", "https://openrouter.ai/api/v1/messages", bytes.NewReader(body))
	if err != nil {
		return 0, err
	}
	req.Header.Set("content-type", "application/json")
	req.Header.Set("x-api-key", os.Getenv("OPENROUTER_KEY"))
	req.Header.Set("anthropic-version", "2023-06-01")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return 0, err
	}
	defer resp.Body.Close()
	io.Copy(io.Discard, resp.Body)
	return resp.StatusCode, nil
}

func main() {
	code, err := verifySignature(os.Args[1])
	if err != nil {
		fmt.Println("请求失败:", err)
		return
	}
	if code == 200 {
		fmt.Println("签名有效：这个响应确实是官方 Claude 生成的")
	} else {
		fmt.Printf("签名无效：HTTP %d，响应大概率是伪造的\n", code)
	}
}

package main

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"regexp"
	"strings"
	"time"
)

var client = &http.Client{Timeout: 60 * time.Second}

// fetchSignature 从待测渠道获取一条带 thinking 的响应，返回签名
func fetchSignature(base, key, model string) (string, error) {
	payload := map[string]any{
		"model":      model,
		"max_tokens": 512,
		"messages":   []map[string]any{{"role": "user", "content": "1071和462的最大公约数是多少？请展示你的思考过程。"}},
	}
	body, _ := json.Marshal(payload)
	req, _ := http.NewRequest("POST", base+"/v1/messages", bytes.NewReader(body))
	req.Header.Set("content-type", "application/json")
	req.Header.Set("x-api-key", key)
	resp, err := client.Do(req)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()
	var d struct {
		Content []struct {
			Type      string `json:"type"`
			Signature string `json:"signature"`
		} `json:"content"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&d); err != nil {
		return "", err
	}
	for _, b := range d.Content {
		if b.Type == "thinking" && b.Signature != "" {
			return b.Signature, nil
		}
	}
	return "", fmt.Errorf("响应中没有 thinking 块")
}

// modelID 解码签名内的模型明文
func modelID(sig string) string {
	raw, err := base64.StdEncoding.DecodeString(sig)
	if err != nil {
		return ""
	}
	re := regexp.MustCompile(`claude-[a-z0-9.\-]+`)
	return re.FindString(string(raw))
}

// verifyOnOpenRouter 交叉验证签名真实性
func verifyOnOpenRouter(sig string) bool {
	payload := map[string]any{
		"model":      "anthropic/claude-fable-5",
		"max_tokens": 64,
		"provider":   map[string]any{"order": []string{"anthropic"}},
		"messages": []map[string]any{
			{"role": "user", "content": "2+2等于多少？"},
			{"role": "assistant", "content": []map[string]any{
				{"type": "thinking", "thinking": "", "signature": sig},
				{"type": "text", "text": "4"},
			}},
			{"role": "user", "content": "现在加3等于多少？"},
		},
	}
	body, _ := json.Marshal(payload)
	req, _ := http.NewRequest("POST", "https://openrouter.ai/api/v1/messages", bytes.NewReader(body))
	req.Header.Set("content-type", "application/json")
	req.Header.Set("x-api-key", os.Getenv("OPENROUTER_KEY"))
	req.Header.Set("anthropic-version", "2023-06-01")
	resp, err := client.Do(req)
	if err != nil {
		return false
	}
	defer resp.Body.Close()
	io.Copy(io.Discard, resp.Body)
	return resp.StatusCode == 200
}

func main() {
	base := os.Getenv("TARGET_BASE")   // 待测渠道地址，比如 http://1.2.3.4:3000
	key := os.Getenv("TARGET_KEY")     // 渠道的 API key
	model := os.Getenv("TARGET_MODEL") // 请求的模型名，比如 claude-fable-5

	// 每 2 小时自动跑一次，连续几天没异常，基本就可以放心用了
	ticker := time.NewTicker(2 * time.Hour)
	log.Println("巡检已启动，每 2 小时执行一次...")
	for range ticker.C {
		sig, err := fetchSignature(base, key, model)
		if err != nil {
			log.Println("获取签名失败:", err)
			continue
		}
		mid := modelID(sig)
		log.Printf("签名明文模型: %s\n", mid)
		if mid == "" || !strings.Contains(mid, strings.Split(model, "-")[1]) {
			log.Println("警告：签名明文与请求模型不符，疑似套壳！")
			continue
		}
		if verifyOnOpenRouter(sig) {
			log.Println("交叉验证通过：签名是官方的，模型也对得上")
		} else {
			log.Println("警告：交叉验证失败，签名疑似伪造！")
		}
	}
}