feat: complete Phase 9 - skill registry and signature verification

Author: Gemini CLI

README.md

@@ -83,7 +83,7 @@ Check the immutable log of actions:
 - [x] **Phase 6: Audit** - Hash-chained logging
 - [x] **Phase 7: Integration** - OpenClaw Protocol Adapter
 - [x] **Phase 8: Network Control** - Egress filtering proxy
-- [ ] **Phase 9: Registry** - Signed skill distribution
+- [x] **Phase 9: Registry** - Signed skill distribution
 
 ## 🤝 Contributing
 

cmd/aegisclaw/main.go

@@ -65,7 +65,7 @@ func runCmd() *cobra.Command {
 		Long:  "Launches the AegisClaw runtime with the configured agent and policies.",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			fmt.Println("🦅 AegisClaw runtime starting...")
-			
+
 			cfgDir, err := config.DefaultConfigDir()
 			if err != nil {
 				return err
@@ -79,15 +79,15 @@ func runCmd() *cobra.Command {
 
 			fmt.Printf("🧩 Loaded %d skills\n", len(manifests))
 			fmt.Println("🤖 Agent is ready. Type 'help' for commands or 'exit' to quit.")
-			
+
 			reader := bufio.NewReader(os.Stdin)
-			
+
 			// Simple REPL for now
 			for {
 				fmt.Print("> ")
 				input, _ := reader.ReadString('\n')
 				input = strings.TrimSpace(input)
-				
+
 				switch input {
 				case "exit", "quit":
 					fmt.Println("👋 Goodbye!")
@@ -112,7 +112,7 @@ func runCmd() *cobra.Command {
 					parts := strings.Fields(input)
 					if len(parts) > 0 {
 						skillName := parts[0]
-						
+
 						// Find matching manifest
 						var targetManifest *skill.Manifest
 						for _, m := range manifests {
@@ -129,7 +129,7 @@ func runCmd() *cobra.Command {
 							}
 							cmdName := parts[1]
 							args := parts[2:]
-							
+
 							if _, err := agent.ExecuteSkill(cmd.Context(), targetManifest, cmdName, args); err != nil {
 								fmt.Printf("❌ Execution failed: %v\n", err)
 							}
@@ -443,6 +443,72 @@ func skillsCmd() *cobra.Command {
 		},
 	})
 
+	cmd.AddCommand(&cobra.Command{
+		Use:   "search [QUERY]",
+		Short: "Search for skills in the registry",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			cfg, err := config.LoadDefault()
+			if err != nil {
+				return fmt.Errorf("failed to load configuration (run 'init' first): %w", err)
+			}
+
+			if cfg.Registry.URL == "" {
+				fmt.Println("⚠️  No registry URL configured. Please update ~/.aegisclaw/config.yaml")
+				return nil
+			}
+
+			fmt.Printf("🔍 Searching registry: %s\n", cfg.Registry.URL)
+			index, err := skill.SearchRegistry(cfg.Registry.URL)
+			if err != nil {
+				return err
+			}
+
+			query := ""
+			if len(args) > 0 {
+				query = strings.ToLower(args[0])
+			}
+
+			fmt.Printf("🧩 Available Skills in '%s':\n", index.RegistryName)
+			found := false
+			for _, s := range index.Skills {
+				if query == "" || strings.Contains(strings.ToLower(s.Name), query) || strings.Contains(strings.ToLower(s.Description), query) {
+					fmt.Printf("  • %-15s v%-8s %s\n", s.Name, s.Version, s.Description)
+					found = true
+				}
+			}
+
+			if !found {
+				fmt.Println("  (No skills matched your search)")
+			}
+
+			return nil
+		},
+	})
+
+	cmd.AddCommand(&cobra.Command{
+		Use:   "add [SKILL_NAME]",
+		Short: "Install a signed skill from the registry",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			skillName := args[0]
+
+			cfg, err := config.LoadDefault()
+			if err != nil {
+				return fmt.Errorf("failed to load configuration (run 'init' first): %w", err)
+			}
+
+			if cfg.Registry.URL == "" {
+				return fmt.Errorf("no registry URL configured")
+			}
+
+			cfgDir, _ := config.DefaultConfigDir()
+			skillsDir := filepath.Join(cfgDir, "skills")
+
+			fmt.Printf("📥 Installing skill '%s'...\n", skillName)
+			return skill.InstallSkill(skillName, skillsDir, cfg.Registry.URL, cfg.Registry.TrustKeys)
+		},
+	})
+
 	return cmd
 }
 func serveCmd() *cobra.Command {

internal/config/config.go

@@ -11,10 +11,17 @@ import (
 
 // Config represents the main AegisClaw configuration
 type Config struct {
-	Version  string          `yaml:"version"`
-	Agent    AgentConfig     `yaml:"agent"`
-	Security SecurityConfig  `yaml:"security"`
-	Network  NetworkConfig   `yaml:"network"`
+	Version  string         `yaml:"version"`
+	Agent    AgentConfig    `yaml:"agent"`
+	Security SecurityConfig `yaml:"security"`
+	Network  NetworkConfig  `yaml:"network"`
+	Registry RegistryConfig `yaml:"registry"`
+}
+
+// RegistryConfig contains skill registry settings
+type RegistryConfig struct {
+	URL       string   `yaml:"url"`
+	TrustKeys []string `yaml:"trust_keys"` // Public keys of trusted signers
 }
 
 // AgentConfig contains agent-specific settings

internal/skill/skill.go

@@ -1,7 +1,11 @@
 package skill
 
 import (
+	"crypto/ed25519"
+	"encoding/hex"
+	"encoding/json"
 	"fmt"
+	"net/http"
 	"os"
 	"path/filepath"
 
@@ -10,12 +14,27 @@ import (
 
 // Manifest represents a skill definition (skill.yaml)
 type Manifest struct {
-	Name        string            `yaml:"name"`
-	Version     string            `yaml:"version"`
-	Description string            `yaml:"description"`
-	Image       string            `yaml:"image"`
-	Scopes      []string          `yaml:"scopes"`
+	Name        string             `yaml:"name"`
+	Version     string             `yaml:"version"`
+	Description string             `yaml:"description"`
+	Image       string             `yaml:"image"`
+	Scopes      []string           `yaml:"scopes"`
 	Commands    map[string]Command `yaml:"commands"`
+	Signature   string             `yaml:"signature,omitempty"` // Ed25519 signature of the manifest content
+}
+
+// RegistrySkill represents a skill available in the registry
+type RegistrySkill struct {
+	Name        string `json:"name"`
+	Version     string `json:"version"`
+	Description string `json:"description"`
+	ManifestURL string `json:"manifest_url"`
+}
+
+// RegistryIndex represents the registry search index
+type RegistryIndex struct {
+	RegistryName string          `json:"registry_name"`
+	Skills       []RegistrySkill `json:"skills"`
 }
 
 // Command represents a runnable action within a skill
@@ -63,4 +82,120 @@ func ListSkills(dir string) ([]*Manifest, error) {
 		}
 	}
 	return manifests, nil
-}
+}
+
+// VerifySignature validates the manifest signature using a list of trusted public keys
+func (m *Manifest) VerifySignature(trustKeys []string) (bool, error) {
+	if m.Signature == "" {
+		return false, fmt.Errorf("manifest has no signature")
+	}
+
+	sigBytes, err := hex.DecodeString(m.Signature)
+	if err != nil {
+		return false, fmt.Errorf("invalid signature hex: %w", err)
+	}
+
+	// Create a copy without the signature for hashing/verification
+	mCopy := *m
+	mCopy.Signature = ""
+
+	// Canonical JSON serialization for hashing
+	data, err := json.Marshal(mCopy)
+	if err != nil {
+		return false, fmt.Errorf("failed to marshal manifest for verification: %w", err)
+	}
+
+	for _, keyStr := range trustKeys {
+		pubKeyBytes, err := hex.DecodeString(keyStr)
+		if err != nil {
+			continue // Skip invalid keys
+		}
+
+		if len(pubKeyBytes) != ed25519.PublicKeySize {
+			continue
+		}
+
+		pubKey := ed25519.PublicKey(pubKeyBytes)
+		if ed25519.Verify(pubKey, data, sigBytes) {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
+
+// SearchRegistry fetches the registry index
+func SearchRegistry(registryURL string) (*RegistryIndex, error) {
+	resp, err := http.Get(registryURL + "/index.json")
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch registry index: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("registry returned error: %s", resp.Status)
+	}
+
+	var index RegistryIndex
+	if err := json.NewDecoder(resp.Body).Decode(&index); err != nil {
+		return nil, fmt.Errorf("failed to decode registry index: %w", err)
+	}
+
+	return &index, nil
+}
+
+// InstallSkill downloads and installs a skill from the registry
+func InstallSkill(skillName, destDir, registryURL string, trustKeys []string) error {
+	index, err := SearchRegistry(registryURL)
+	if err != nil {
+		return err
+	}
+
+	var target *RegistrySkill
+	for _, s := range index.Skills {
+		if s.Name == skillName {
+			target = &s
+			break
+		}
+	}
+
+	if target == nil {
+		return fmt.Errorf("skill '%s' not found in registry", skillName)
+	}
+
+	// Fetch Manifest
+	resp, err := http.Get(target.ManifestURL)
+	if err != nil {
+		return fmt.Errorf("failed to fetch manifest: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var m Manifest
+	if err := yaml.NewDecoder(resp.Body).Decode(&m); err != nil {
+		return fmt.Errorf("failed to parse manifest from registry: %w", err)
+	}
+
+	// Verify Signature
+	valid, err := m.VerifySignature(trustKeys)
+	if err != nil {
+		return fmt.Errorf("signature verification error: %w", err)
+	}
+	if !valid {
+		return fmt.Errorf("SECURITY ALERT: Skill signature verification failed! Possible tampering detected")
+	}
+
+	// Create directory and save
+	skillPath := filepath.Join(destDir, skillName)
+	if err := os.MkdirAll(skillPath, 0700); err != nil {
+		return fmt.Errorf("failed to create skill directory: %w", err)
+	}
+
+	manifestPath := filepath.Join(skillPath, "skill.yaml")
+	data, _ := yaml.Marshal(m)
+	if err := os.WriteFile(manifestPath, data, 0600); err != nil {
+		return fmt.Errorf("failed to save skill manifest: %w", err)
+	}
+
+	fmt.Printf("✅ Successfully installed skill: %s v%s\n", m.Name, m.Version)
+	return nil
+}

internal/skill/skill_test.go

@@ -0,0 +1,59 @@
+package skill
+
+import (
+	"crypto/ed25519"
+	"encoding/hex"
+	"encoding/json"
+	"testing"
+)
+
+func TestSignatureVerification(t *testing.T) {
+	// 1. Generate keys
+	pub, priv, err := ed25519.GenerateKey(nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pubHex := hex.EncodeToString(pub)
+
+	// 2. Create manifest
+	m := Manifest{
+		Name:        "test-skill",
+		Version:     "1.0.0",
+		Description: "A test skill",
+		Image:       "alpine:latest",
+		Commands:    map[string]Command{"hello": {Args: []string{"echo", "hi"}}},
+	}
+
+	// 3. Sign manifest
+	data, _ := json.Marshal(m)
+	sig := ed25519.Sign(priv, data)
+	m.Signature = hex.EncodeToString(sig)
+
+	// 4. Verify (Success)
+	valid, err := m.VerifySignature([]string{pubHex})
+	if err != nil {
+		t.Errorf("VerifySignature returned error: %v", err)
+	}
+	if !valid {
+		t.Error("VerifySignature failed for valid signature")
+	}
+
+	// 5. Verify (Failure - Wrong Key)
+	_, priv2, _ := ed25519.GenerateKey(nil)
+	sig2 := ed25519.Sign(priv2, data)
+	m.Signature = hex.EncodeToString(sig2)
+
+	valid, _ = m.VerifySignature([]string{pubHex})
+	if valid {
+		t.Error("VerifySignature succeeded for wrong public key")
+	}
+
+	// 6. Verify (Failure - Tampered Content)
+	m.Signature = hex.EncodeToString(sig) // back to valid signature
+	m.Description = "Tampered description"
+
+	valid, _ = m.VerifySignature([]string{pubHex})
+	if valid {
+		t.Error("VerifySignature succeeded for tampered content")
+	}
+}