mirror of
https://github.com/1Panel-dev/1Panel.git
synced 2026-11-20 00:01:06 +00:00
* feat: add MCP error metadata handling and improve source policy resolution * fix: adjust height-diff for improved table layout
262 lines
8.8 KiB
Go
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
|
|
}
|