Golang 创建HTTP端点执行服务器命令的Webhook插件

下面我将介绍如何使用Golang创建一个安全的HTTP端点，用于通过Webhook执行服务器命令。这个实现包含安全验证、命令执行和日志记录等功能。

基本实现

package main

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

// WebhookRequest 定义Webhook请求结构
type WebhookRequest struct {
	Token   string `json:"token"`
	Command string `json:"command"`
}

// CommandResponse 定义命令执行响应结构
type CommandResponse struct {
	Success bool   `json:"success"`
	Output  string `json:"output"`
	Error   string `json:"error,omitempty"`
}

const (
	secretToken = "your-secret-token" // 替换为你的安全令牌
	port        = ":8080"             // 服务监听端口
)

func main() {
	http.HandleFunc("/webhook", webhookHandler)
	log.Printf("Starting webhook server on %s\n", port)
	log.Fatal(http.ListenAndServe(port, nil))
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	// 只接受POST请求
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	// 读取请求体
	body, err := io.ReadAll(r.Body)
	if err != nil {
		http.Error(w, "Error reading request body", http.StatusBadRequest)
		return
	}
	defer r.Body.Close()

	// 解析JSON请求
	var req WebhookRequest
	if err := json.Unmarshal(body, &req); err != nil {
		http.Error(w, "Error parsing JSON", http.StatusBadRequest)
		return
	}

	// 验证token
	if req.Token != secretToken {
		http.Error(w, "Unauthorized", http.StatusUnauthorized)
		return
	}

	// 执行命令
	response := executeCommand(req.Command)

	// 返回JSON响应
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(response)
}

func executeCommand(cmdStr string) CommandResponse {
	// 安全限制：不允许某些危险命令
	if strings.Contains(strings.ToLower(cmdStr), "rm ") || 
	   strings.Contains(strings.ToLower(cmdStr), "shutdown") {
		return CommandResponse{
			Success: false,
			Error:   "Dangerous command not allowed",
		}
	}

	// 分割命令和参数
	parts := strings.Fields(cmdStr)
	if len(parts) == 0 {
		return CommandResponse{
			Success: false,
			Error:   "Empty command",
		}
	}

	cmd := exec.Command(parts[0], parts[1:]...)
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr

	err := cmd.Run()

	response := CommandResponse{
		Output: stdout.String(),
	}

	if err != nil {
		response.Success = false
		response.Error = fmt.Sprintf("%s: %s", err.Error(), stderr.String())
	} else {
		response.Success = true
	}

	return response
}

安全增强版本

上面的基本实现已经可以工作，但为了生产环境使用，我们需要增加更多安全措施：

// 在main函数中添加路由和中间件
func main() {
	// 使用中间件链
	handler := chainMiddleware(
		loggingMiddleware,
		authMiddleware,
	)(http.HandlerFunc(webhookHandler))

	http.Handle("/webhook", handler)
	
	// 添加健康检查端点
	http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("OK"))
	})

	log.Printf("Starting secure webhook server on %s\n", port)
	log.Fatal(http.ListenAndServe(port, nil))
}

// 中间件链
func chainMiddleware(middlewares ...func(http.Handler) http.Handler) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		for i := len(middlewares) - 1; i >= 0; i-- {
			next = middlewares[i](next)
		}
		return next
	}
}

// 日志中间件
func loggingMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		log.Printf("Incoming request: %s %s", r.Method, r.URL.Path)
		next.ServeHTTP(w, r)
	})
}

// 认证中间件
func authMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		token := r.Header.Get("X-Auth-Token")
		if token != secretToken {
			http.Error(w, "Unauthorized", http.StatusUnauthorized)
			return
		}
		next.ServeHTTP(w, r)
	})
}

// 在executeCommand函数中添加命令白名单
var allowedCommands = map[string]bool{
	"ls":      true,
	"df":      true,
	"ps":      true,
	"date":    true,
	"uptime":  true,
	"whoami":  true,
	"uname":   true,
	"git":     true,
	"docker":  true, // 谨慎添加
}

func executeCommand(cmdStr string) CommandResponse {
	parts := strings.Fields(cmdStr)
	if len(parts) == 0 {
		return CommandResponse{
			Success: false,
			Error:   "Empty command",
		}
	}

	// 检查命令是否在白名单中
	if !allowedCommands[parts[0]] {
		return CommandResponse{
			Success: false,
			Error:   fmt.Sprintf("Command '%s' not allowed", parts[0]),
		}
	}

	// 限制命令执行时间
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	cmd := exec.CommandContext(ctx, parts[0], parts[1:]...)
	
	// 设置执行用户(可选，需要适当权限)
	// cmd.SysProcAttr = &syscall.SysProcAttr{
	//     Credential: &syscall.Credential{
	//         Uid: 1000, // 非root用户
	//         Gid: 1000,
	//     },
	// }
	
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr

	err := cmd.Run()

	response := CommandResponse{
		Output: stdout.String(),
	}

	if ctx.Err() == context.DeadlineExceeded {
		response.Success = false
		response.Error = "Command timed out"
	} else if err != nil {
		response.Success = false
		response.Error = fmt.Sprintf("%s: %s", err.Error(), stderr.String())
	} else {
		response.Success = true
	}

	return response
}

部署建议

1. 使用HTTPS：在生产环境中务必使用HTTPS

   // 在main函数中
   log.Fatal(http.ListenAndServeTLS(port, "server.crt", "server.key", nil))
   

2. 限制访问IP：通过中间件限制允许访问的IP地址

3. 速率限制：使用令牌桶算法限制请求频率

4. 日志记录：记录所有执行的命令和结果

5. 使用环境变量：不要将密钥硬编码在代码中

   secretToken := os.Getenv("WEBHOOK_TOKEN")
   if secretToken == "" {
       log.Fatal("WEBHOOK_TOKEN environment variable not set")
   }
   

这个实现提供了一个安全的基础，你可以根据具体需求进行扩展。在生产环境中使用时，请确保仔细审查安全措施，并根据你的具体需求进行调整。