Files
1Panel/core/app/service/mcp_enrollment.go
蘭 e29679768b feat: add MCP error metadata handling and improve source policy resolution (#14270)
* feat: add MCP error metadata handling and improve source policy resolution

* fix: adjust height-diff for improved table layout
2026-11-02 22:17:12 +08:00

262 lines
8.8 KiB
Go

package service
import (
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"crypto/sha256"
"crypto/subtle"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"strings"
"github.com/1Panel-dev/1Panel/core/app/auth"
"github.com/1Panel-dev/1Panel/core/app/dto"
"github.com/1Panel-dev/1Panel/core/app/model"
"github.com/1Panel-dev/1Panel/core/app/repo"
paneli18n "github.com/1Panel-dev/1Panel/core/i18n"
contract "github.com/1Panel-dev/1Panel/core/utils/mcp"
"github.com/google/uuid"
goi18n "github.com/nicksnyder/go-i18n/v2/i18n"
"gorm.io/gorm"
)
const mcpSecretVersion = 1
func (s *MCPService) secretAEAD() (cipher.AEAD, error) {
unavailable := contract.Fail("MCP_SECRET_KEY_UNAVAILABLE", 503, "MCP credential encryption is unavailable")
if s.SecretKey == nil {
return nil, unavailable
}
master, err := s.SecretKey()
if err != nil || master == "" {
return nil, unavailable
}
derived := sha256.Sum256([]byte("1panel:mcp-token:v1:" + master))
block, err := aes.NewCipher(derived[:])
if err != nil {
return nil, unavailable
}
return cipher.NewGCM(block)
}
func (s *MCPService) sealCredentialToken(key *model.MCPCredential, token string) error {
aead, err := s.secretAEAD()
if err != nil {
return err
}
nonce := make([]byte, aead.NonceSize())
if _, err = rand.Read(nonce); err != nil {
return contract.Fail("MCP_SECRET_KEY_UNAVAILABLE", 503, "MCP credential encryption is unavailable")
}
key.SecretCiphertext = base64.RawStdEncoding.EncodeToString(aead.Seal(nonce, nonce, []byte(token), []byte("mcp-token:v1:"+key.ID)))
key.SecretVersion = mcpSecretVersion
return nil
}
func (s *MCPService) openCredentialToken(key model.MCPCredential) (string, error) {
invalid := contract.Fail("MCP_SECRET_INVALID", 409, "The stored MCP token cannot be decrypted; rotate the credential")
if key.SecretVersion != mcpSecretVersion {
return "", invalid
}
aead, err := s.secretAEAD()
if err != nil {
return "", err
}
data, err := base64.RawStdEncoding.DecodeString(key.SecretCiphertext)
if err != nil || len(data) < aead.NonceSize()+aead.Overhead() || len(data) > 256 {
return "", invalid
}
plain, err := aead.Open(nil, data[:aead.NonceSize()], data[aead.NonceSize():], []byte("mcp-token:v1:"+key.ID))
if err != nil {
return "", invalid
}
token := string(plain)
if len(token) != 68 || !strings.HasPrefix(token, "mcp_") || subtle.ConstantTimeCompare([]byte(tokenDigest(token)), []byte(key.TokenHash)) != 1 {
return "", invalid
}
if _, err := hex.DecodeString(token[4:]); err != nil {
return "", invalid
}
return token, nil
}
func (s *MCPService) enrollmentKey(owner auth.APIKeyOwner, req dto.MCPCredentialMutation) (model.MCPCredential, error) {
var key model.MCPCredential
if _, err := uuid.Parse(req.ID); err != nil || req.Revision == 0 {
return key, contract.Invalid()
}
if err := s.authorize(owner, "mcp_access_manage"); err != nil {
return key, err
}
var err error
key, err = (repo.MCPRepo{DB: s.DB}).Credential(owner.Type, owner.ID, req.ID)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return key, contract.Forbidden()
}
return key, err
}
if key.Revision != req.Revision {
return key, contract.Conflict("credential_revision_changed", "Credential changed; refresh and retry")
}
if err := s.enrollmentActive(key, false); err != nil {
return key, err
}
return key, nil
}
func (s *MCPService) enrollmentActive(key model.MCPCredential, allowDisabled bool) error {
active := key.Status == "Enable" || allowDisabled && key.Status == "Disable"
if !active || key.RevokedAt != nil || key.ExpiresAt != nil && !s.Now().Before(*key.ExpiresAt) {
return contract.Fail("MCP_CREDENTIAL_INACTIVE", 409, "The credential is inactive or expired")
}
return nil
}
func (s *MCPService) Reveal(owner auth.APIKeyOwner, req dto.MCPCredentialMutation) (result *dto.MCPCredentialSecret, resultErr error) {
defer func() {
if err := s.auditEnrollment(s.DB, owner, "reveal", req, resultErr); err != nil {
result, resultErr = nil, err
}
}()
mcpMutationMu.Lock()
defer mcpMutationMu.Unlock()
key, err := s.enrollmentKey(owner, req)
if err != nil {
return nil, err
}
token, err := s.openCredentialToken(key)
if err != nil {
return nil, err
}
return &dto.MCPCredentialSecret{ID: key.ID, Token: token}, nil
}
func (s *MCPService) Rotate(owner auth.APIKeyOwner, req dto.MCPCredentialMutation) (result *dto.MCPCredentialCreated, resultErr error) {
defer func() {
if resultErr != nil {
if err := s.auditEnrollment(s.DB, owner, "rotate", req, resultErr); err != nil {
result, resultErr = nil, err
}
}
}()
if err := s.authorize(owner, "mcp_access_manage"); err != nil {
return nil, err
}
var token string
var item dto.MCPCredentialItem
catalog, _ := s.catalog()
err := s.mutate(owner, req, func(tx *gorm.DB, key *model.MCPCredential) error {
if err := s.authorize(owner, "mcp_access_manage"); err != nil {
return err
}
if err := s.enrollmentActive(*key, true); err != nil {
return err
}
secret := make([]byte, 32)
if _, err := rand.Read(secret); err != nil {
return contract.Fail("MCP_SECRET_KEY_UNAVAILABLE", 503, "MCP credential encryption is unavailable")
}
token = "mcp_" + hex.EncodeToString(secret)
key.TokenHash = tokenDigest(token)
key.KeyHint = token[:8] + "…" + token[len(token)-4:]
if err := s.sealCredentialToken(key, token); err != nil {
return err
}
view := *s
view.DB = tx
var err error
item, err = view.credentialItem(*key, catalogIndex(catalog))
item.Revision = key.Revision + 1
if err != nil {
return err
}
return s.auditEnrollment(tx, owner, "rotate", dto.MCPCredentialMutation{ID: key.ID, Revision: item.Revision}, nil)
})
if err != nil {
return nil, err
}
return &dto.MCPCredentialCreated{Item: item, Token: token}, nil
}
func mcpDocumentJSON(value any) string {
data, _ := json.MarshalIndent(value, "", " ")
return strings.ReplaceAll(string(data), "`", "\\u0060")
}
func mcpEnrollmentConfig(client, id, endpoint, token string) (string, string) {
name := "1panel_" + strings.ReplaceAll(id, "-", "")
if client == "codex" {
urlJSON := mcpDocumentJSON(endpoint)
authJSON := mcpDocumentJSON("Bearer " + token)
return "toml", fmt.Sprintf("[mcp_servers.%s]\nurl = %s\nhttp_headers = { Authorization = %s }", name, urlJSON, authJSON)
}
return "json", mcpDocumentJSON(map[string]any{"mcpServers": map[string]any{name: map[string]any{
"type": "http", "url": endpoint, "headers": map[string]string{"Authorization": "Bearer " + token},
}}})
}
func mcpEnrollmentDocument(locale, client, syntax, config, endpoint string) (string, error) {
localizer, err := paneli18n.NewMCPDocumentLocalizer(locale)
if err != nil {
return "", contract.Fail("MCP_DOCUMENT_UNAVAILABLE", 500, "MCP connection document is unavailable")
}
clientKey := map[string]string{
"codex": "MCPDocumentClientCodex", "claude": "MCPDocumentClientClaude", "generic": "MCPDocumentClientGeneric",
}[client]
keys := []string{
"MCPDocumentTitle", "MCPDocumentIntro", "MCPDocumentTaskTitle", "MCPDocumentTask", clientKey,
"MCPDocumentSteps", "MCPDocumentConfigTitle", "MCPDocumentNotes",
}
if strings.HasPrefix(strings.ToLower(endpoint), "http://") {
keys = append(keys, "MCPDocumentHTTPWarning")
}
texts := make([]string, len(keys))
for index, key := range keys {
texts[index], err = localizer.Localize(&goi18n.LocalizeConfig{MessageID: key})
if err != nil || texts[index] == "" {
return "", contract.Fail("MCP_DOCUMENT_UNAVAILABLE", 500, "MCP connection document is unavailable")
}
}
content := fmt.Sprintf("# %s\n\n%s\n\n## %s\n\n%s\n\n%s\n\n%s\n\n## %s\n\n```%s\n%s\n```\n\n%s\n",
texts[0], texts[1], texts[2], texts[3], texts[4], texts[5], texts[6], syntax, config, texts[7])
if len(texts) > 8 {
content += "\n" + texts[8] + "\n"
}
return content, nil
}
func (s *MCPService) ExportMarkdown(owner auth.APIKeyOwner, req dto.MCPEnrollmentExport, endpoint, locale string) (result *dto.MCPEnrollmentDocument, resultErr error) {
defer func() {
if err := s.auditEnrollment(s.DB, owner, "export", req.MCPCredentialMutation, resultErr); err != nil {
result, resultErr = nil, err
}
}()
if req.Client != "generic" && req.Client != "codex" && req.Client != "claude" {
return nil, contract.Invalid()
}
if !validMCPExternalEndpoint(endpoint) {
return nil, contract.Fail("MCP_ENDPOINT_UNAVAILABLE", 409, "Configure an MCP external endpoint before exporting")
}
mcpMutationMu.Lock()
defer mcpMutationMu.Unlock()
key, err := s.enrollmentKey(owner, req.MCPCredentialMutation)
if err != nil {
return nil, err
}
token, err := s.openCredentialToken(key)
if err != nil {
return nil, err
}
language, config := mcpEnrollmentConfig(req.Client, key.ID, endpoint, token)
content, err := mcpEnrollmentDocument(locale, req.Client, language, config, endpoint)
if err != nil {
return nil, err
}
return &dto.MCPEnrollmentDocument{Filename: "1panel-mcp-" + key.ID + "-" + req.Client + ".md", Content: content}, nil
}