Question

当我运行Node HTTP服务器应用程序时，我通常会调用自定义函数

function runAsWWW()
{
 try 
 {
  process.setgid('www-data');
  process.setuid('www-data');
 } catch (err) 
 {
  console.error('Cowardly refusal to keep the process alive as root.');
  process.exit(1);
 }
}

来自server.listen(8080,'localhost',null,runAsWWW);

因此服务器实际上作为www-data用户运行，以提供更好的安全性。当我通过发布go run index.go？

启动Golang Web服务器时，我能做些类似的事情

Answer 1

没有。你无法在go中可靠地setuid或setgid，因为这对多线程程序不起作用。

您需要通过某种类型的主管（例如supervisord，runit，monit）或通过您的init系统直接以预期用户身份启动该程序。

Answer 2

扩展@ JimB 的答案：

使用进程管理器以特定用户身份运行应用程序（并处理重新启动/崩溃，记录重定向等）。 setuid和setgid对于多线程应用程序来说是普遍不好的想法。

使用您的操作系统＆＃39;流程管理器（Upstart，systemd，sysvinit）或独立流程管理器（Supervisor，runit，monit等）。

以下是主管的一个例子：

[program:yourapp]
command=/home/yourappuser/bin/yourapp # the location of your app
autostart=true
autorestart=true
startretries=10
user=yourappuser # the user your app should run as (i.e. *not* root!)
directory=/srv/www/yourapp.com/ # where your application runs from
environment=APP_SETTINGS="/srv/www/yourapp.com/prod.toml" # environmental variables
redirect_stderr=true
stdout_logfile=/var/log/supervisor/yourapp.log # the name of the log file.
stdout_logfile_maxbytes=50MB
stdout_logfile_backups=10

此外：如果您不反向代理，并且您的Go应用程序需要绑定到端口＆lt; 1024（例如端口80或443）然后使用setcap - 例如：setcap cap_net_bind_service=+ep /home/yourappuser/bin/yourapp

PS：我写了a little article关于如何使用Supervisor运行Go应用程序（从＆＃34开始;我没有安装Supervisor＆＃34;）。

Answer 3

您可以检查该程序是否在具有os/user包的某个用户下运行：

curr, err := user.Current()
// Check err.
www, err := user.Lookup("www-data")
// Check err.
if *curr != *www {
    panic("Go away!")
}

这不是您想要的，但它确实阻止它在任何其他用户下运行。您可以使用www-data：

运行su来运行它

su www-data -c "myserver"

Answer 4

安全地实现这一目标的一种方法是自行解决。

这是一个关于如何实现安全setuid的原始未经测试的示例：

1）确保你是root用户 2）听取通缉端口（以root身份） 3）分叉为www-data用户。 4）接受并提供请求。

http://play.golang.org/p/sT25P0KxXK

package main

import (
        "flag"
        "fmt"
        "log"
        "net"
        "net/http"
        "os"
        "os/exec"
        "os/user"
        "strconv"
        "syscall"
)

var listenFD = flag.Int("l", 0, "listen pid")

func handler(w http.ResponseWriter, req *http.Request) {
        u, err := user.Current()
        if err != nil {
                log.Println(err)
                return
        }
        fmt.Fprintf(w, "%s\n", u.Name)
}

func lookupUser(username string) (uid, gid int, err error) {
        u, err := user.Lookup(username)
        if err != nil {
                return -1, -1, err
        }
        uid, err = strconv.Atoi(u.Uid)
        if err != nil {
                return -1, -1, err
        }
        gid, err = strconv.Atoi(u.Gid)
        if err != nil {
                return -1, -1, err
        }
        return uid, gid, nil
}

// FDListener .
type FDListener struct {
        file *os.File
}

// Accept .
func (ln *FDListener) Accept() (net.Conn, error) {
        fd, _, err := syscall.Accept(int(*listenFD))
        if err != nil {
                return nil, err
        }
        conn, err := net.FileConn(os.NewFile(uintptr(fd), ""))
        if err != nil {
                return nil, err
        }
        return conn.(*net.TCPConn), nil
}

// Close .
func (ln *FDListener) Close() error {
        return ln.file.Close()
}

// Addr .
func (ln *FDListener) Addr() net.Addr {
        return nil
}

func start() error {
        u, err := user.Current()
        if err != nil {
                return err
        }
        if u.Uid != "0" && *listenFD == 0 {
                // we are not root and we have no listen fd. Error.
                return fmt.Errorf("need to run as root: %s", u.Uid)
        } else if u.Uid == "0" && *listenFD == 0 {
                // we are root and we have no listen fd. Do the listen.
                l, err := net.Listen("tcp", "0.0.0.0:80")
                if err != nil {
                        return fmt.Errorf("Listen error: %s", err)
                }
                f, err := l.(*net.TCPListener).File()
                if err != nil {
                        return err
                }

                uid, gid, err := lookupUser("guillaume")
                if err != nil {
                        return err
                }
                // First extra file: fd == 3
                cmd := exec.Command(os.Args[0], "-l", fmt.Sprint(3))
                cmd.Stdin = os.Stdin
                cmd.Stdout = os.Stdout
                cmd.Stderr = os.Stderr
                cmd.ExtraFiles = append(cmd.ExtraFiles, f)
                cmd.SysProcAttr = &syscall.SysProcAttr{
                        Credential: &syscall.Credential{
                                Uid: uint32(uid),
                                Gid: uint32(gid),
                        },
                }
                if err := cmd.Run(); err != nil {
                        return fmt.Errorf("cmd.Run error: %s", err)
                }
                return nil
        } else if u.Uid != "0" && *listenFD != 0 {
                // We are not root and we have a listen fd. Do the accept.
                ln := &FDListener{file: os.NewFile(uintptr(*listenFD), "net")}
                if err := http.Serve(ln, http.HandlerFunc(handler)); err != nil {
                        return err
                }
        }
        return fmt.Errorf("setuid fail: %s, %d", u.Uid, *listenFD)
}

func main() {
        flag.Parse()

        if err := start(); err != nil {
                log.Fatal(err)
        }
}

将Golang作为www-data运行

4 个答案: