构建安全的加密密钥代理：IPC与持久化最佳实践

package main

import (
    "fmt"
    "net"
    "os"
    "syscall"
)

// getPeerCred 从 UnixConn 获取连接对端的凭证信息
func getPeerCred(conn net.Conn) (*syscall.Ucred, error) {
    // 将 net.Conn 转换为 net.UnixConn 以访问底层文件描述符
    unixConn, ok := conn.(*net.UnixConn)
    if !ok {
        return nil, fmt.Errorf("connection is not a UnixConn")
    }

    // 获取 UnixConn 的底层文件描述符
    file, err := unixConn.File()
    if err != nil {
        return nil, fmt.Errorf("failed to get file from UnixConn: %w", err)
    }
    defer file.Close() // 确保文件描述符被关闭

    // 使用 syscall.GetsockoptUcred 获取对端凭证
    // int(file.Fd()) 将 os.File 的文件描述符转换为 int
    ucred, err := syscall.GetsockoptUcred(int(file.Fd()), syscall.SOL_SOCKET, syscall.SO_PEERCRED)
    if err != nil {
        return nil, fmt.Errorf("failed to get SO_PEERCRED: %w", err)
    }
    return ucred, nil
}

func main() {
    socketPath := "/tmp/my_key_agent.sock"
    // 清理旧的套接字文件，以防上次非正常退出
    os.Remove(socketPath)

    // 启动 Unix 域套接字服务器
    listener, err := net.Listen("unix", socketPath)
    if err != nil {
        fmt.Printf("Error listening: %v\n", err)
        return
    }
    defer listener.Close()
    fmt.Printf("Key agent listening on %s\n", socketPath)

    // 设置套接字文件权限，例如只有当前用户可读写
    // 这提供了第一层保护
    if err := os.Chmod(socketPath, 0600); err != nil {
        fmt.Printf("Error setting socket permissions: %v\n", err)
        return
    }

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Printf("Error accepting connection: %v\n", err)
            continue
        }
        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()

    // 获取客户端凭证
    ucred, err := getPeerCred(conn)
    if err != nil {
        fmt.Printf("Error getting peer credentials: %v\n", err)
        return
    }

    fmt.Printf("Accepted connection from PID: %d, UID: %d, GID: %d\n",
        ucred.Pid, ucred.Uid, ucred.Gid)

    // 这里可以根据 ucred.Uid 和 ucred.Pid 来决定是否允许该客户端进行操作
    // 例如，只允许与代理运行相同 UID 的进程进行通信
    if ucred.Uid != uint32(os.Geteuid()) {
        fmt.Printf("Unauthorized client (UID %d) attempted to connect. Denying access.\n", ucred.Uid)
        return
    }

    // 模拟 RPC 调用，例如处理解密请求
    // 在实际应用中，这里会是 RPC 服务器的逻辑
    fmt.Fprintf(conn, "Hello from key agent! Your UID %d is authorized.\n", ucred.Uid)
}

type Checksum [ChecksumSize]byte

// SumKeyPair 用于设置密钥时，将校验和与密钥绑定
type SumKeyPair struct {
    Sum Checksum
    Key []byte // 在SetKey时传递，之后仅在代理内部使用
}

// DecryptRequest 客户端发送给代理的解密请求
type DecryptRequest struct {
    Sum Checksum // 标识哪个文件的密钥
    Data []byte   // 待解密的数据
}

// DecryptReply 代理返回给客户端的解密结果
type DecryptReply struct {
    DecryptedData []byte
    Success       bool
    ErrorMsg      string
}

// Cache 模拟密钥缓存
type Cache map[Checksum][]byte

// SetKey 添加或更新与文件校验和对应的密钥
// 客户端在提供正确密码后调用此方法
func (c Cache) SetKey(pair SumKeyPair, reply *bool) error {
    _, *reply = c[pair.Sum] // *reply指示是否为更新操作
    c[pair.Sum] = pair.Key
    return nil
}

// DecryptData 使用缓存的密钥解密数据
// 客户端发送加密数据，代理进行解密并返回结果
func (c Cache) DecryptData(req DecryptRequest, reply *DecryptReply) error {
    key, available := c[req.Sum]
    if !available {
        reply.Success = false
        reply.ErrorMsg = "Key not found for checksum"
        return nil
    }

    // 实际解密逻辑（此处仅为示意）
    // decryptedData := performDecryption(req.Data, key)
    // 假设解密成功，将解密后的数据填充到 reply.DecryptedData
    reply.DecryptedData = req.Data // 示例：直接返回原数据，实际应为解密结果
    reply.Success = true
    return nil
}

// 注意：不提供 RequestKey 方法直接返回密钥