本文介绍如何使用aes算法对shell命令进行加密并保存到文件，再在运行时解密并安全执行，涵盖加密/解密实现、文件读写、exec.command调用等核心步骤，并附可直接运行的完整示例代码。
本文介绍如何使用aes算法对shell命令进行加密并保存到文件，再在运行时解密并安全执行，涵盖加密/解密实现、文件读写、exec.command调用等核心步骤，并附可直接运行的完整示例代码。
在Go中实现“加密命令 → 存储文件 → 解密 → 执行”这一流程，需协同使用 crypto/aes、crypto/cipher（如CBC模式）、encoding/hex 或 base64 编码，以及 os/exec 包。以下为结构清晰、生产可用的完整实现方案。
✅ 核心步骤概览
- 使用AES-256-CBC对明文命令（如
"ls -la"）加密，密钥和IV需安全保管（示例中硬编码仅用于演示，实际应通过环境变量或密钥管理服务注入）； - 将密文（含IV前缀）序列化为十六进制或Base64字符串，写入文件；
- 运行时读取文件，解密还原为原始命令字符串；
- 使用
exec.CommandContext安全执行（推荐带超时控制），避免直接exec.Command引发的阻塞或注入风险。
? 示例：AES-256-CBC 加密与解密（含文件I/O）
package main
import (
"bufio"
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"encoding/hex"
"fmt"
"io"
"os"
"os/exec"
"strings"
"time"
)
const (
keyFile = "cmd.enc"
)
// encryptCommand AES-256-CBC 加密命令字符串
func encryptCommand(cmd string, key []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, fmt.Errorf("failed to create cipher: %w", err)
}
if len(cmd)%aes.BlockSize != 0 {
padding := aes.BlockSize - len(cmd)%aes.BlockSize
cmd += strings.Repeat("\x00", padding) // 简单PKCS#7填充可自行增强
}
ciphertext := make([]byte, aes.BlockSize+len(cmd))
iv := ciphertext[:aes.BlockSize]
if _, err := io.ReadFull(rand.Reader, iv); err != nil {
return nil, err
}
stream := cipher.NewCBCEncrypter(block, iv)
stream.CryptBlocks(ciphertext[aes.BlockSize:], []byte(cmd))
return ciphertext, nil
}
// decryptCommand 解密并去除填充
func decryptCommand(data []byte, key []byte) (string, error) {
block, err := aes.NewCipher(key)
if err != nil {
return "", fmt.Errorf("failed to create cipher: %w", err)
}
if len(data) < aes.BlockSize {
return "", fmt.Errorf("ciphertext too short")
}
iv := data[:aes.BlockSize]
data = data[aes.BlockSize:]
if len(data)%aes.BlockSize != 0 {
return "", fmt.Errorf("ciphertext is not a multiple of the block size")
}
stream := cipher.NewCBCDecrypter(block, iv)
stream.CryptBlocks(data, data)
// 去除末尾\x00填充（生产环境建议用标准PKCS#7去填充）
s := strings.TrimRight(string(data), "\x00")
return s, nil
}
// saveEncryptedCommand 保存加密后命令到文件（hex编码）
func saveEncryptedCommand(data []byte, filename string) error {
f, err := os.Create(filename)
if err != nil {
return err
}
defer f.Close()
_, err = f.WriteString(hex.EncodeToString(data))
return err
}
// loadAndDecryptCommand 从文件读取并解密
func loadAndDecryptCommand(filename string, key []byte) (string, error) {
data, err := os.ReadFile(filename)
if err != nil {
return "", err
}
decoded, err := hex.DecodeString(strings.TrimSpace(string(data)))
if err != nil {
return "", fmt.Errorf("invalid hex in %s: %w", filename, err)
}
return decryptCommand(decoded, key)
}
func main() {
// ? 示例密钥（32字节 = AES-256）—— 实际请勿硬编码！
key := []byte("this-is-32-byte-long-secret-key!") // 必须恰好32字节
// ? 步骤1：加密命令并保存
cmdToEncrypt := "echo 'Hello from decrypted command!' && date"
ciphertext, err := encryptCommand(cmdToEncrypt, key)
if err != nil {
panic(err)
}
if err := saveEncryptedCommand(ciphertext, keyFile); err != nil {
panic(err)
}
fmt.Printf("✅ Encrypted command saved to %s\n", keyFile)
// ▶️ 步骤2：读取、解密并执行
decryptedCmd, err := loadAndDecryptCommand(keyFile, key)
if err != nil {
panic(fmt.Sprintf("decryption failed: %v", err))
}
fmt.Printf("? Decrypted command: %q\n", decryptedCmd)
// ⚠️ 安全执行：拆分命令与参数（避免shell注入）
parts := strings.Fields(decryptedCmd)
if len(parts) == 0 {
fmt.Println("⚠️ Empty command, nothing to execute.")
return
}
// 使用 exec.CommandContext + timeout 防止挂起
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
cmd := exec.CommandContext(ctx, parts[0], parts[1:]...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
if ctx.Err() == context.DeadlineExceeded {
fmt.Println("❌ Command timed out")
} else {
fmt.Printf("❌ Execution failed: %v\n", err)
}
} else {
fmt.Println("✅ Command executed successfully")
}
}⚠️ 重要注意事项
-
密钥安全：示例中密钥硬编码，绝对不可用于生产环境。应通过
os.Getenv("ENCRYPTION_KEY")、HashiCorp Vault 或 KMS 获取，并确保密钥长度严格为 16（AES-128）、24（AES-192）或 32（AES-256）字节。 -
填充与编码：本例使用简单
\x00填充，推荐升级为 PKCS#7 并使用golang.org/x/crypto/pkcs7；文件存储推荐 Base64（更紧凑）而非 Hex（体积翻倍）。 -
命令注入防护：切勿用
sh -c "$cmd"执行解密结果。务必strings.Fields()拆分并传入exec.Command，杜绝 shell 元字符执行风险。 - 错误处理：所有 I/O 和密码操作必须检查错误，避免静默失败。
-
权限控制：加密文件（如
cmd.enc）应设为0600权限，防止未授权读取。
通过以上实现，你已构建出一条端到端的安全命令调度链路：加密持久化 → 受控解密 → 隔离执行。该模式适用于自动化运维、受限环境指令下发等场景，兼顾安全性与Go原生工程实践。
