下载我们的电子书，学习如何更好地使用 awk。

在众多 Linux 命令中，sed、awk 和 grep 恐怕是其中最经典的三个命令了。它们引人注目或许是由于名字发音与众不同，也可能是它们无处不在，甚至是因为它们存在已久，但无论如何，如果要问哪些命令很有 Linux 风格，这三个命令是当之无愧的。其中 sed 和 grep 已经有很多简洁的标准用法了，但 awk 的使用难度却相对突出。

在日常使用中，通过 sed 实现字符串替换、通过 grep 实现过滤，这些都是司空见惯的操作了，但 awk 命令相对来说是用得比较少的。在我看来，可能的原因是大多数人都只使用 sed 或者 grep 的一些变化实现某些功能，例如：

$ sed -e 's/foo/bar/g' file.txt
$ grep foo file.txt

因此，尽管你可能会觉得 sed 和 grep 使用起来更加顺手，但实际上它们还有更多更强大的作用没有发挥出来。当然，我们没有必要在这两个命令上钻研得很深入，但我有时会好奇自己“学习”命令的方式。很多时候我会记住一整串命令“咒语”，而不会去了解其中的运作过程，这就让我产生了一种很熟悉命令的错觉，我可以随口说出某个命令的好几个选项参数，但这些参数具体有什么作用，以及它们的相关语法，我都并不明确。

这大概就是很多人对 awk 缺乏了解的原因了。

为使用而学习 awk

awk 并不深奥。它是一种相对基础的编程语言，因此你可以把它当成一门新的编程语言来学习：使用一些基本命令来熟悉语法、了解语言中的关键字并实现更复杂的功能，然后再多加练习就可以了。

awk 是如何解析输入内容的

awk 的本质是将输入的内容看作是一个数组。当 awk 扫描一个文本文件时，会把每一行作为一条 记录 record ，每一条记录中又分割为多个 字段 field 。awk 记录了各条记录各个字段的信息，并通过内置变量 NR（记录数） 和 NF（字段数） 来调用相关信息。例如一下这个命令可以查看文件的行数：

$ awk 'END { print NR;}' example.txt
36

从上面的命令可以看出 awk 的基本语法，无论是一个单行命令还是一整个脚本，语法都是这样的：

模式或关键字 { 操作 }

在上面的例子中，END 是一个关键字而不是模式，与此类似的另一个关键字是 BEGIN。使用 BEGIN 或 END 可以让 awk 在解析内容前或解析内容后执行大括号中指定的操作。

你可以使用 模式 pattern 作为过滤器或限定符，这样 awk 只会对匹配模式的对应记录执行指定的操作。以下这个例子就是使用 awk 实现 grep 命令在文件中查找“Linux”字符串的功能：

$ awk '/Linux/ { print $0; }' os.txt
OS: CentOS Linux (10.1.1.8)
OS: CentOS Linux (10.1.1.9)
OS: Red Hat Enterprise Linux (RHEL) (10.1.1.11)
OS: Elementary Linux (10.1.2.4)
OS: Elementary Linux (10.1.2.5)
OS: Elementary Linux (10.1.2.6)

awk 会将文件中的每一行作为一条记录，将一条记录中的每个单词作为一个字段，默认情况下会以空格作为 字段分隔符 field separator （FS）切割出记录中的字段。如果想要使用其它内容作为分隔符，可以使用 --field-separator 选项指定分隔符：

$ awk --field-separator ':' '/Linux/ { print $2; }' os.txt
 CentOS Linux (10.1.1.8)
 CentOS Linux (10.1.1.9)
 Red Hat Enterprise Linux (RHEL) (10.1.1.11)
 Elementary Linux (10.1.2.4)
 Elementary Linux (10.1.2.5)
 Elementary Linux (10.1.2.6)

在上面的例子中，可以看到在 awk 处理后每一行的行首都有一个空格，那是因为在源文件中每个冒号（:）后面都带有一个空格。和 cut 有所不同的是，awk 可以指定一个字符串作为分隔符，就像这样：

$ awk --field-separator ': ' '/Linux/ { print $2; }' os.txt
CentOS Linux (10.1.1.8)
CentOS Linux (10.1.1.9)
Red Hat Enterprise Linux (RHEL) (10.1.1.11)
Elementary Linux (10.1.2.4)
Elementary Linux (10.1.2.5)
Elementary Linux (10.1.2.6)

awk 中的函数

可以通过这样的语法在 awk 中自定义函数：

函数名称(参数) { 操作 }

函数的好处在于只需要编写一次就可以多次复用，因此函数在脚本中起到的作用会比在构造单行命令时大。同时 awk 自身也带有很多预定义的函数，并且工作原理和其它编程语言或电子表格一样。你只需要了解函数需要接受什么参数，就可以放心使用了。

awk 中提供了数学运算和字符串处理的相关函数。数学运算函数通常比较简单，传入一个数字，它就会传出一个结果：

$ awk 'BEGIN { print sqrt(1764); }'
42

而字符串处理函数则稍微复杂一点，但 GNU awk 手册中也有充足的文档。例如 split() 函数需要传入一个待分割的单一字段、一个用于存放分割结果的数组，以及用于分割的 定界符 delimiter 。

例如前面示例中的输出内容，每条记录的末尾都包含了一个 IP 地址。由于变量 NF 代表的是每条记录的字段数量，刚好对应的是每条记录中最后一个字段的序号，因此可以通过引用 NF 将每条记录的最后一个字段传入 split() 函数：

$ awk --field-separator ': ' '/Linux/ { split($NF, IP, "."); print "subnet: " IP[3]; }' os.txt
subnet: 1
subnet: 1
subnet: 1
subnet: 2
subnet: 2
subnet: 2

还有更多的函数，没有理由将自己限制在每个 awk 代码块中。你可以在终端中使用 awk 构建复杂的管道，也可以编写 awk 脚本来定义和使用你自己的函数。

下载电子书

使用 awk 本身就是一个学习 awk 的过程，即使某些操作使用 sed、grep、cut、tr 命令已经完全足够了，也可以尝试使用 awk 来实现。只要熟悉了 awk，就可以在 Bash 中自定义一些 awk 函数，进而解析复杂的数据。

下载我们的这本电子书（需注册）学习并开始使用 awk 吧！

via: https://opensource.com/article/20/9/awk-ebook

作者：Seth Kenlon 选题：lujun9972 译者：HankChow 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

本文是该系列的第五篇。

• 第一篇: 模式
• 第二篇: OAuth
• 第三篇: 对话
• 第四篇: 消息

对于实时消息，我们将使用 服务器发送事件 Server-Sent Events 。这是一个打开的连接，我们可以在其中传输数据流。我们会有个端点，用户会在其中订阅发送给他的所有消息。

消息户端

在 HTTP 部分之前，让我们先编写一个 映射 map ，让所有客户端都监听消息。 像这样全局初始化：

type MessageClient struct {
    Messages chan Message
    UserID   string
}

var messageClients sync.Map

已创建的新消息

还记得在 上一篇文章 中，当我们创建这条消息时，我们留下了一个 “TODO” 注释。在那里，我们将使用这个函数来调度一个 goroutine。

go messageCreated(message)

把这行代码插入到我们留注释的位置。

func messageCreated(message Message) error {
    if err := db.QueryRow(`
 SELECT user\_id FROM participants
 WHERE user\_id != $1 and conversation\_id = $2
 `, message.UserID, message.ConversationID).
    Scan(&message.ReceiverID); err != nil {
        return err
    }

    go broadcastMessage(message)

    return nil
}

func broadcastMessage(message Message) {
    messageClients.Range(func(key, \_ interface{}) bool {
        client := key.(\*MessageClient)
        if client.UserID == message.ReceiverID {
            client.Messages <- message
        }
        return true
    })
}

该函数查询接收者 ID（其他参与者 ID），并将消息发送给所有客户端。

订阅消息

让我们转到 main() 函数并添加以下路由：

router.HandleFunc("GET", "/api/messages", guard(subscribeToMessages))

此端点处理 /api/messages 上的 GET 请求。请求应该是一个 EventSource 连接。它用一个事件流响应，其中的数据是 JSON 格式的。

func subscribeToMessages(w http.ResponseWriter, r \*http.Request) {
    if a := r.Header.Get("Accept"); !strings.Contains(a, "text/event-stream") {
        http.Error(w, "This endpoint requires an EventSource connection", http.StatusNotAcceptable)
        return
    }

    f, ok := w.(http.Flusher)
    if !ok {
        respondError(w, errors.New("streaming unsupported"))
        return
    }

    ctx := r.Context()
    authUserID := ctx.Value(keyAuthUserID).(string)

    h := w.Header()
    h.Set("Cache-Control", "no-cache")
    h.Set("Connection", "keep-alive")
    h.Set("Content-Type", "text/event-stream")

    messages := make(chan Message)
    defer close(messages)

    client := &MessageClient{Messages: messages, UserID: authUserID}
    messageClients.Store(client, nil)
    defer messageClients.Delete(client)

    for {
        select {
        case <-ctx.Done():
            return
        case message := <-messages:
            if b, err := json.Marshal(message); err != nil {
                log.Printf("could not marshall message: %v\n", err)
                fmt.Fprintf(w, "event: error\ndata: %v\n\n", err)
            } else {
                fmt.Fprintf(w, "data: %s\n\n", b)
            }
            f.Flush()
        }
    }
}

首先，它检查请求头是否正确，并检查服务器是否支持流式传输。我们创建一个消息通道，用它来构建一个客户端，并将其存储在客户端映射中。每当创建新消息时，它都会进入这个通道，因此我们可以通过 for-select 循环从中读取。

服务器发送事件 Server-Sent Events 使用以下格式发送数据：

data: some data here\n\n

我们以 JSON 格式发送：

data: {"foo":"bar"}\n\n

我们使用 fmt.Fprintf() 以这种格式写入响应 写入器 writter ，并在循环的每次迭代中刷新数据。

这个循环会一直运行，直到使用请求上下文关闭连接为止。我们延迟了通道的关闭和客户端的删除，因此，当循环结束时，通道将被关闭，客户端不会收到更多的消息。

注意， 服务器发送事件 Server-Sent Events （EventSource）的 JavaScript API 不支持设置自定义请求头?，所以我们不能设置 Authorization: Bearer <token>。这就是为什么 guard() 中间件也会从 URL 查询字符串中读取令牌的原因。

实时消息部分到此结束。我想说的是，这就是后端的全部内容。但是为了编写前端代码，我将再增加一个登录端点：一个仅用于开发的登录。

• 源代码

via: https://nicolasparada.netlify.com/posts/go-messenger-realtime-messages/

作者：Nicolás Parada 选题：lujun9972 译者：gxlct008 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

来学习下 Go 语言的安全检查工具 gosec。

Go 语言写的代码越来越常见，尤其是在容器、Kubernetes 或云生态相关的开发中。Docker 是最早采用 Golang 的项目之一，随后是 Kubernetes，之后大量的新项目在众多编程语言中选择了 Go。

像其他语言一样，Go 也有它的长处和短处（如安全缺陷）。这些缺陷可能会因为语言本身的缺陷加上程序员编码不当而产生，例如，C 代码中的内存安全问题。

无论它们出现的原因是什么，安全问题都应该在开发过程的早期修复，以免在封装好的软件中出现。幸运的是，静态分析工具可以帮你以更可重复的方式处理这些问题。静态分析工具通过解析用某种编程语言写的代码来找到问题。

这类工具中很多被称为 linter。传统意义上，linter 更注重的是检查代码中编码问题、bug、代码风格之类的问题，它们可能不会发现代码中的安全问题。例如，Coverity 是一个很流行的工具，它可以帮助寻找 C/C++ 代码中的问题。然而，也有一些工具专门用来检查源码中的安全问题。例如，Bandit 可以检查 Python 代码中的安全缺陷。而 gosec 则用来搜寻 Go 源码中的安全缺陷。gosec 通过扫描 Go 的 AST（ 抽象语法树 abstract syntax tree ）来检查源码中的安全问题。

开始使用 gosec

在开始学习和使用 gosec 之前，你需要准备一个 Go 语言写的项目。有这么多开源软件，我相信这不是问题。你可以在 GitHub 的 热门 Golang 仓库中找一个。

本文中，我随机选了 Docker CE 项目，但你可以选择任意的 Go 项目。

安装 Go 和 gosec

如果你还没安装 Go，你可以先从仓库中拉取下来。如果你用的是 Fedora 或其他基于 RPM 的 Linux 发行版本：

$ dnf install golang.x86_64

如果你用的是其他操作系统，请参照 Golang 安装页面。

使用 version 参数来验证 Go 是否安装成功：

$ go version
go version go1.14.6 linux/amd64

运行 go get 命令就可以轻松地安装 gosec：

$ go get github.com/securego/gosec/cmd/gosec

上面这行命令会从 GitHub 下载 gosec 的源码，编译并安装到指定位置。在仓库的 README 中你还可以看到安装该工具的其他方法。

gosec 的源码会被下载到 $GOPATH 的位置，编译出的二进制文件会被安装到你系统上设置的 bin 目录下。你可以运行下面的命令来查看 $GOPATH 和 $GOBIN 目录：

$ go env | grep GOBIN
GOBIN="/root/go/gobin"
$ go env | grep GOPATH
GOPATH="/root/go"

如果 go get 命令执行成功，那么 gosec 二进制应该就可以使用了：

$ ls -l ~/go/bin/
total 9260
-rwxr-xr-x. 1 root root 9482175 Aug 20 04:17 gosec

你可以把 $GOPATH 下的 bin 目录添加到 $PATH 中。这样你就可以像使用系统上的其他命令一样来使用 gosec 命令行工具（CLI）了。

$ which gosec
/root/go/bin/gosec
$

使用 gosec 命令行工具的 -help 选项来看看运行是否符合预期：

$ gosec -help

gosec - Golang security checker

gosec analyzes Go source code to look for common programming mistakes that
can lead to security problems.

VERSION: dev
GIT TAG:
BUILD DATE:

USAGE:

之后，创建一个目录，把源码下载到这个目录作为实例项目（本例中，我用的是 Docker CE）：

$ mkdir gosec-demo
$ cd gosec-demo/
$ pwd
/root/gosec-demo
$ git clone https://github.com/docker/docker-ce.git
Cloning into 'docker-ce'...
remote: Enumerating objects: 1271, done.
remote: Counting objects: 100% (1271/1271), done.
remote: Compressing objects: 100% (722/722), done.
remote: Total 431003 (delta 384), reused 981 (delta 318), pack-reused 429732
Receiving objects: 100% (431003/431003), 166.84 MiB | 28.94 MiB/s, done.
Resolving deltas: 100% (221338/221338), done.
Updating files: 100% (10861/10861), done.

代码统计工具（本例中用的是 cloc）显示这个项目大部分是用 Go 写的，恰好迎合了 gosec 的功能。

$ ./cloc /root/gosec-demo/docker-ce/
   10771 text files.
    8724 unique files.                                          
    2560 files ignored.


-----------------------------------------------------------------------------------
Language                         files          blank        comment           code
-----------------------------------------------------------------------------------
Go                                7222         190785         230478        1574580
YAML                                37           4831            817         156762
Markdown                           529          21422              0          67893
Protocol Buffers                   149           5014          16562          10071

使用默认选项运行 gosec

在 Docker CE 项目中使用默认选项运行 gosec，执行 gosec ./... 命令。屏幕上会有很多输出内容。在末尾你会看到一个简短的 “Summary”，列出了浏览的文件数、所有文件的总行数，以及源码中发现的问题数。

$ pwd
/root/gosec-demo/docker-ce
$ time gosec ./...
[gosec] 2020/08/20 04:44:15 Including rules: default
[gosec] 2020/08/20 04:44:15 Excluding rules: default
[gosec] 2020/08/20 04:44:15 Import directory: /root/gosec-demo/docker-ce/components/engine/opts
[gosec] 2020/08/20 04:44:17 Checking package: opts
[gosec] 2020/08/20 04:44:17 Checking file: /root/gosec-demo/docker-ce/components/engine/opts/address_pools.go
[gosec] 2020/08/20 04:44:17 Checking file: /root/gosec-demo/docker-ce/components/engine/opts/env.go
[gosec] 2020/08/20 04:44:17 Checking file: /root/gosec-demo/docker-ce/components/engine/opts/hosts.go

# End of gosec run

Summary:
   Files: 1278
   Lines: 173979
   Nosec: 4
  Issues: 644

real    0m52.019s
user    0m37.284s
sys     0m12.734s
$

滚动屏幕你会看到不同颜色高亮的行：红色表示需要尽快查看的高优先级问题，黄色表示中优先级的问题。

关于误判

在开始检查代码之前，我想先分享几条基本原则。默认情况下，静态检查工具会基于一系列的规则对测试代码进行分析，并报告出它们发现的所有问题。这是否意味着工具报出来的每一个问题都需要修复？非也。这个问题最好的解答者是设计和开发这个软件的人。他们最熟悉代码，更重要的是，他们了解软件会在什么环境下部署以及会被怎样使用。

这个知识点对于判定工具标记出来的某段代码到底是不是安全缺陷至关重要。随着工作时间和经验的积累，你会慢慢学会怎样让静态分析工具忽略非安全缺陷，使报告内容的可执行性更高。因此，要判定 gosec 报出来的某个问题是否需要修复，让一名有经验的开发者对源码做人工审计会是比较好的办法。

高优先级问题

从输出内容看，gosec 发现了 Docker CE 的一个高优先级问题，它使用的是低版本的 TLS（ 传输层安全 Transport Layer Security ）。无论什么时候，使用软件和库的最新版本都是确保它更新及时、没有安全问题的最好的方法。

[/root/gosec-demo/docker-ce/components/engine/daemon/logger/splunk/splunk.go:173] - G402 (CWE-295): TLS MinVersion too low. (Confidence: HIGH, Severity: HIGH)
    172:
  > 173:        tlsConfig := &tls.Config{}
    174:

它还发现了一个弱随机数生成器。它是不是一个安全缺陷，取决于生成的随机数的使用方式。

[/root/gosec-demo/docker-ce/components/engine/pkg/namesgenerator/names-generator.go:843] - G404 (CWE-338): Use of weak random number generator (math/rand instead of crypto/rand) (Confidence: MEDIUM, Severity: HIGH)
    842: begin:
  > 843:        name := fmt.Sprintf("%s_%s", left[rand.Intn(len(left))], right[rand.Intn(len(right))])
    844:        if name == "boring_wozniak" /* Steve Wozniak is not boring */ {

中优先级问题

这个工具还发现了一些中优先级问题。它标记了一个通过与 tar 相关的解压炸弹这种方式实现的潜在的 DoS 威胁，这种方式可能会被恶意的攻击者利用。

[/root/gosec-demo/docker-ce/components/engine/pkg/archive/copy.go:357] - G110 (CWE-409): Potential DoS vulnerability via decompression bomb (Confidence: MEDIUM, Severity: MEDIUM)
    356:
  > 357:                        if _, err = io.Copy(rebasedTar, srcTar); err != nil {
    358:                                w.CloseWithError(err)

它还发现了一个通过变量访问文件的问题。如果恶意使用者能访问这个变量，那么他们就可以改变变量的值去读其他文件。

[/root/gosec-demo/docker-ce/components/cli/cli/context/tlsdata.go:80] - G304 (CWE-22): Potential file inclusion via variable (Confidence: HIGH, Severity: MEDIUM)
    79:         if caPath != "" {
  > 80:                 if ca, err = ioutil.ReadFile(caPath); err != nil {
    81:                         return nil, err

文件和目录通常是操作系统安全的最基础的元素。这里，gosec 报出了一个可能需要你检查目录的权限是否安全的问题。

[/root/gosec-demo/docker-ce/components/engine/contrib/apparmor/main.go:41] - G301 (CWE-276): Expect directory permissions to be 0750 or less (Confidence: HIGH, Severity: MEDIUM)
    40:         // make sure /etc/apparmor.d exists
  > 41:         if err := os.MkdirAll(path.Dir(apparmorProfilePath), 0755); err != nil {
    42:                 log.Fatal(err)

你经常需要在源码中启动命令行工具。Go 使用内建的 exec 库来实现。仔细地分析用来调用这些工具的变量，就能发现安全缺陷。

[/root/gosec-demo/docker-ce/components/engine/testutil/fakestorage/fixtures.go:59] - G204 (CWE-78): Subprocess launched with variable (Confidence: HIGH, Severity: MEDIUM)
    58:
  > 59:              cmd := exec.Command(goCmd, "build", "-o", filepath.Join(tmp, "httpserver"), "github.com/docker/docker/contrib/httpserver")
    60:                 cmd.Env = append(os.Environ(), []string{

低优先级问题

在这个输出中，gosec 报出了一个 unsafe 调用相关的低优先级问题，这个调用会绕开 Go 提供的内存保护。再仔细分析下你调用 unsafe 的方式，看看是否有被别人利用的可能性。

[/root/gosec-demo/docker-ce/components/engine/pkg/archive/changes_linux.go:264] - G103 (CWE-242): Use of unsafe calls should be audited (Confidence: HIGH, Severity: LOW)
    263:        for len(buf) > 0 {
  > 264:                dirent := (*unix.Dirent)(unsafe.Pointer(&buf[0]))
    265:                buf = buf[dirent.Reclen:]



[/root/gosec-demo/docker-ce/components/engine/pkg/devicemapper/devmapper_wrapper.go:88] - G103 (CWE-242): Use of unsafe calls should be audited (Confidence: HIGH, Severity: LOW)
    87: func free(p *C.char) {
  > 88:         C.free(unsafe.Pointer(p))
    89: }

它还标记了源码中未处理的错误。源码中出现的错误你都应该处理。

[/root/gosec-demo/docker-ce/components/cli/cli/command/image/build/context.go:172] - G104 (CWE-703): Errors unhandled. (Confidence: HIGH, Severity: LOW)
    171:                err := tar.Close()
  > 172:                os.RemoveAll(dockerfileDir)
    173:                return err

自定义 gosec 扫描

使用 gosec 的默认选项会带来很多的问题。然而，经过人工审计，随着时间推移你会掌握哪些问题是不需要标记的。你可以自己指定排除和包含哪些测试。

我上面提到过，gosec 是基于一系列的规则从 Go 源码中查找问题的。下面是它使用的完整的规则列表：

• G101：查找硬编码凭证
• G102：绑定到所有接口
• G103：审计 unsafe 块的使用
• G104：审计未检查的错误
• G106：审计 ssh.InsecureIgnoreHostKey 的使用
• G107: 提供给 HTTP 请求的 url 作为污点输入
• G108: /debug/pprof 上自动暴露的剖析端点
• G109: strconv.Atoi 转换到 int16 或 int32 时潜在的整数溢出
• G110: 潜在的通过解压炸弹实现的 DoS
• G201：SQL 查询构造使用格式字符串
• G202：SQL 查询构造使用字符串连接
• G203：在 HTML 模板中使用未转义的数据
• G204：审计命令执行情况
• G301：创建目录时文件权限分配不合理
• G302：使用 chmod 时文件权限分配不合理
• G303：使用可预测的路径创建临时文件
• G304：通过污点输入提供的文件路径
• G305：提取 zip/tar 文档时遍历文件
• G306: 写到新文件时文件权限分配不合理
• G307: 把返回错误的函数放到 defer 内
• G401：检测 DES、RC4、MD5 或 SHA1 的使用
• G402：查找错误的 TLS 连接设置
• G403：确保最小 RSA 密钥长度为 2048 位
• G404：不安全的随机数源（rand）
• G501：导入黑名单列表：crypto/md5
• G502：导入黑名单列表：crypto/des
• G503：导入黑名单列表：crypto/rc4
• G504：导入黑名单列表：net/http/cgi
• G505：导入黑名单列表：crypto/sha1
• G601: 在 range 语句中使用隐式的元素别名

排除指定的测试

你可以自定义 gosec 来避免对已知为安全的问题进行扫描和报告。你可以使用 -exclude 选项和上面的规则编号来忽略指定的问题。

例如，如果你不想让 gosec 检查源码中硬编码凭证相关的未处理的错误，那么你可以运行下面的命令来忽略这些错误：

$ gosec -exclude=G104 ./...
$ gosec -exclude=G104,G101 ./...

有时候你知道某段代码是安全的，但是 gosec 还是会报出问题。然而，你又不想完全排除掉整个检查，因为你想让 gosec 检查新增的代码。通过在你已知为安全的代码块添加 #nosec 标记可以避免 gosec 扫描。这样 gosec 会继续扫描新增代码，而忽略掉 #nosec 标记的代码块。

运行指定的检查

另一方面，如果你只想检查指定的问题，你可以通过 -include 选项和规则编号来告诉 gosec 运行哪些检查：

$ gosec -include=G201,G202 ./...

扫描测试文件

Go 语言自带对测试的支持，通过单元测试来检验一个元素是否符合预期。在默认模式下，gosec 会忽略测试文件，你可以使用 -tests 选项把它们包含进来：

gosec -tests ./...

修改输出的格式

找出问题只是它的一半功能；另一半功能是把它检查到的问题以用户友好同时又方便工具处理的方式报告出来。幸运的是，gosec 可以用不同的方式输出。例如，如果你想看 JSON 格式的报告，那么就使用 -fmt 选项指定 JSON 格式并把结果保存到 results.json 文件中：

$ gosec -fmt=json -out=results.json ./...

$ ls -l results.json
-rw-r--r--. 1 root root 748098 Aug 20 05:06 results.json
$

         {
             "severity": "LOW",
             "confidence": "HIGH",
             "cwe": {
                 "ID": "242",
                 "URL": "https://cwe.mitre.org/data/definitions/242.html"
             },
             "rule_id": "G103",
             "details": "Use of unsafe calls should be audited",
             "file": "/root/gosec-demo/docker-ce/components/engine/daemon/graphdriver/graphtest/graphtest_unix.go",
             "code": "304: \t// Cast to []byte\n305: \theader := *(*reflect.SliceHeader)(unsafe.Pointer(\u0026buf))\n306: \theader.      Len *= 8\n",
             "line": "305",
             "column": "36"
         },

用 gosec 检查容易被发现的问题

静态检查工具不能完全代替人工代码审计。然而，当代码量变大、有众多开发者时，这样的工具往往有助于以可重复的方式找出容易被发现的问题。它对于帮助新开发者识别和在编码时避免引入这些安全缺陷很有用。

via: https://opensource.com/article/20/9/gosec

作者：Gaurav Kamathe 选题：lujun9972 译者：lxbowlf 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

本文是该系列的第四篇。

• 第一篇: 模式
• 第二篇: OAuth
• 第三篇: 对话

在这篇文章中，我们将对端点进行编码，以创建一条消息并列出它们，同时还将编写一个端点以更新参与者上次阅读消息的时间。 首先在 main() 函数中添加这些路由。

router.HandleFunc("POST", "/api/conversations/:conversationID/messages", requireJSON(guard(createMessage)))
router.HandleFunc("GET", "/api/conversations/:conversationID/messages", guard(getMessages))
router.HandleFunc("POST", "/api/conversations/:conversationID/read_messages", guard(readMessages))

消息会进入对话，因此端点包含对话 ID。

创建消息

该端点处理对 /api/conversations/{conversationID}/messages 的 POST 请求，其 JSON 主体仅包含消息内容，并返回新创建的消息。它有两个副作用：更新对话 last_message_id 以及更新参与者 messages_read_at。

func createMessage(w http.ResponseWriter, r *http.Request) {
    var input struct {
        Content string `json:"content"`
    }
    defer r.Body.Close()
    if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    errs := make(map[string]string)
    input.Content = removeSpaces(input.Content)
    if input.Content == "" {
        errs["content"] = "Message content required"
    } else if len([]rune(input.Content)) > 480 {
        errs["content"] = "Message too long. 480 max"
    }
    if len(errs) != 0 {
        respond(w, Errors{errs}, http.StatusUnprocessableEntity)
        return
    }

    ctx := r.Context()
    authUserID := ctx.Value(keyAuthUserID).(string)
    conversationID := way.Param(ctx, "conversationID")

    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        respondError(w, fmt.Errorf("could not begin tx: %v", err))
        return
    }
    defer tx.Rollback()

    isParticipant, err := queryParticipantExistance(ctx, tx, authUserID, conversationID)
    if err != nil {
        respondError(w, fmt.Errorf("could not query participant existance: %v", err))
        return
    }

    if !isParticipant {
        http.Error(w, "Conversation not found", http.StatusNotFound)
        return
    }

    var message Message
    if err := tx.QueryRowContext(ctx, `
        INSERT INTO messages (content, user_id, conversation_id) VALUES
            ($1, $2, $3)
        RETURNING id, created_at
    `, input.Content, authUserID, conversationID).Scan(
        &message.ID,
        &message.CreatedAt,
    ); err != nil {
        respondError(w, fmt.Errorf("could not insert message: %v", err))
        return
    }

    if _, err := tx.ExecContext(ctx, `
        UPDATE conversations SET last_message_id = $1
        WHERE id = $2
    `, message.ID, conversationID); err != nil {
        respondError(w, fmt.Errorf("could not update conversation last message ID: %v", err))
        return
    }

    if err = tx.Commit(); err != nil {
        respondError(w, fmt.Errorf("could not commit tx to create a message: %v", err))
        return
    }

    go func() {
        if err = updateMessagesReadAt(nil, authUserID, conversationID); err != nil {
            log.Printf("could not update messages read at: %v\n", err)
        }
    }()

    message.Content = input.Content
    message.UserID = authUserID
    message.ConversationID = conversationID
    // TODO: notify about new message.
    message.Mine = true

    respond(w, message, http.StatusCreated)
}

首先，它将请求正文解码为包含消息内容的结构。然后，它验证内容不为空并且少于 480 个字符。

var rxSpaces = regexp.MustCompile("\\s+")

func removeSpaces(s string) string {
    if s == "" {
        return s
    }

    lines := make([]string, 0)
    for _, line := range strings.Split(s, "\n") {
        line = rxSpaces.ReplaceAllLiteralString(line, " ")
        line = strings.TrimSpace(line)
        if line != "" {
            lines = append(lines, line)
        }
    }
    return strings.Join(lines, "\n")
}

这是删除空格的函数。它遍历每一行，删除两个以上的连续空格，然后回非空行。

验证之后，它将启动一个 SQL 事务。首先，它查询对话中的参与者是否存在。

func queryParticipantExistance(ctx context.Context, tx *sql.Tx, userID, conversationID string) (bool, error) {
    if ctx == nil {
        ctx = context.Background()
    }
    var exists bool
    if err := tx.QueryRowContext(ctx, `SELECT EXISTS (
        SELECT 1 FROM participants
        WHERE user_id = $1 AND conversation_id = $2
    )`, userID, conversationID).Scan(&exists); err != nil {
        return false, err
    }
    return exists, nil
}

我将其提取到一个函数中，因为稍后可以重用。

如果用户不是对话参与者，我们将返回一个 404 NOT Found 错误。

然后，它插入消息并更新对话 last_message_id。从这时起，由于我们不允许删除消息，因此 last_message_id 不能为 NULL。

接下来提交事务，并在 goroutine 中更新参与者 messages_read_at。

func updateMessagesReadAt(ctx context.Context, userID, conversationID string) error {
    if ctx == nil {
        ctx = context.Background()
    }

    if _, err := db.ExecContext(ctx, `
        UPDATE participants SET messages_read_at = now()
        WHERE user_id = $1 AND conversation_id = $2
    `, userID, conversationID); err != nil {
        return err
    }
    return nil
}

在回复这条新消息之前，我们必须通知一下。这是我们将要在下一篇文章中编写的实时部分，因此我在那里留一了个注释。

获取消息

这个端点处理对 /api/conversations/{conversationID}/messages 的 GET 请求。 它用一个包含会话中所有消息的 JSON 数组进行响应。它还具有更新参与者 messages_read_at 的副作用。

func getMessages(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    authUserID := ctx.Value(keyAuthUserID).(string)
    conversationID := way.Param(ctx, "conversationID")

    tx, err := db.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
    if err != nil {
        respondError(w, fmt.Errorf("could not begin tx: %v", err))
        return
    }
    defer tx.Rollback()

    isParticipant, err := queryParticipantExistance(ctx, tx, authUserID, conversationID)
    if err != nil {
        respondError(w, fmt.Errorf("could not query participant existance: %v", err))
        return
    }

    if !isParticipant {
        http.Error(w, "Conversation not found", http.StatusNotFound)
        return
    }

    rows, err := tx.QueryContext(ctx, `
        SELECT
            id,
            content,
            created_at,
            user_id = $1 AS mine
        FROM messages
        WHERE messages.conversation_id = $2
        ORDER BY messages.created_at DESC
    `, authUserID, conversationID)
    if err != nil {
        respondError(w, fmt.Errorf("could not query messages: %v", err))
        return
    }
    defer rows.Close()

    messages := make([]Message, 0)
    for rows.Next() {
        var message Message
        if err = rows.Scan(
            &message.ID,
            &message.Content,
            &message.CreatedAt,
            &message.Mine,
        ); err != nil {
            respondError(w, fmt.Errorf("could not scan message: %v", err))
            return
        }

        messages = append(messages, message)
    }

    if err = rows.Err(); err != nil {
        respondError(w, fmt.Errorf("could not iterate over messages: %v", err))
        return
    }

    if err = tx.Commit(); err != nil {
        respondError(w, fmt.Errorf("could not commit tx to get messages: %v", err))
        return
    }

    go func() {
        if err = updateMessagesReadAt(nil, authUserID, conversationID); err != nil {
            log.Printf("could not update messages read at: %v\n", err)
        }
    }()

    respond(w, messages, http.StatusOK)
}

首先，它以只读模式开始一个 SQL 事务。检查参与者是否存在，并查询所有消息。在每条消息中，我们使用当前经过身份验证的用户 ID 来了解用户是否拥有该消息（mine）。 然后，它提交事务，在 goroutine 中更新参与者 messages_read_at 并以消息响应。

读取消息

该端点处理对 /api/conversations/{conversationID}/read_messages 的 POST 请求。 没有任何请求或响应主体。 在前端，每次有新消息到达实时流时，我们都会发出此请求。

func readMessages(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    authUserID := ctx.Value(keyAuthUserID).(string)
    conversationID := way.Param(ctx, "conversationID")

    if err := updateMessagesReadAt(ctx, authUserID, conversationID); err != nil {
        respondError(w, fmt.Errorf("could not update messages read at: %v", err))
        return
    }

    w.WriteHeader(http.StatusNoContent)
}

它使用了与更新参与者 messages_read_at 相同的函数。

到此为止。实时消息是后台仅剩的部分了。请等待下一篇文章。

• 源代码

via: https://nicolasparada.netlify.com/posts/go-messenger-messages/

作者：Nicolás Parada 选题：lujun9972 译者：gxlct008 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

如果你想尝试在 Windows 10 中设置一个或多个 Ubuntu 虚拟机进行自己的实验，请按照以下步骤进行。

1、启用 Hyper-V 平台

所有 64 位 Windows 10 专业版、企业版和教育版都内置了这个 管理程序 （ hypervisor ） ，但默认情况下并没有启用。在在旧电脑上启用该功能之前，你可能需要打开一些固件选项。有关完整说明，请参阅“Windows 10：如何启用 Hyper-V 并创建虚拟机”。

2、使用快速创建工具来下载并安装 Ubuntu 虚拟机

Hyper-V 提供了两种创建新虚拟机的方法。老式的方法是通过一个繁琐的多步骤向导来点击。更简单的解决方案是使用 Hyper-V 的“快速创建”工具。你可以在 Hyper-V 管理器的右侧窗格中找到一个快捷方式，或者你可以直接在 Windows 10 搜索框搜索 Vmcreate.exe 命令打开它。

从左侧的陈列栏中选择一个 Ubuntu 版本，然后点击“创建虚拟机”按钮。这将需要下载 1.6GB（18.04.3 LTS）到 2GB（更近的版本）。下载完成后，该“快速创建”功能会提取镜像、配置虚拟机，然后显示一个对话框，告诉你虚拟机已成功创建。

3、调整一些设置

虽然你可以通过点击“连接”立即开始，但如果你的 Windows 10 主机上有足够的资源，我建议你点击“编辑设置”，以便你可以先进行一些调整。

我建议你在第一次运行虚拟机之前编辑一些设置

从新虚拟机的硬件列表中选择“内存”，然后将分配的 RAM 从其默认值 2048 改为 4096，这应该会带来更好的性能。如果你想要一个固定数量的虚拟内存，你也可以禁用动态内存。你可能还希望将系统磁盘的大小从其默认的 12GB 提升到更多。单击“硬盘驱动器”，然后单击“编辑”，并按照提示操作，直到进行到“扩展”命令那一步。

根据需要调整分配给你的 Linux 虚拟机的内存

最后，在“管理”标题下，单击“检查点”，然后清除“使用自动检查点”框。（如果你希望能够回滚更改，可以随时手动创建检查点。）

这些调整完毕后，可以关闭“设置”对话框，并首次打开虚拟机。

4、设置你的用户账户

运行 Ubuntu 的系统配置，选择你的默认语言、时区等。当你进入创建登录凭证的界面时，将默认设置保留在“需要我的密码才能登录”。

虽然听起来很方便，但不要启用自动登录功能。如果你选择此选项，将无法使用增强型会话登录，并且你的虚拟机将被迫在一个相对较小的窗口中运行，其默认分辨率无法轻松更改。

这也是运行“系统更新管理器”应用程序并获取最新 Ubuntu 更新的好时机。（点击左下角的 Ubuntu 图标，使用搜索框找到该应用。）

5、使用增强版会话登录

如果你在“虚拟机连接”窗口中看到这个对话框，你就会知道已经启动了一个增强的会话：

将该滑块移至最右侧，以全屏方式运行虚拟机

滑动开关来选择你的显示分辨率。我喜欢将滑块向右移动，到全屏位置。如果你有多个显示器，并希望虚拟机跨越它们，请选择 “使用所有我的显示器”复选框。单击“连接”继续，打开 Xrdp 登录对话框，如图所示：

登录到 Xrdp 以启动增强型 Hyper-V 会话

输入你在创建 Ubuntu Linux 账户时设置的用户名和密码，然后点击“确定”。假设大神们没有生气，你就会登录到你的虚拟机上，可以开始工作了。如果你还没有在你要连接的会话上登录，可能需要第二次输入密码。（如果你得到一个黑屏，尝试按回车键。）

如果你使用 18.04.3 LTS 虚拟机，所有这些都应该可以正常工作。如果你使用的是 Ubuntu 19.10，你可能要经历我所做的同样令人沮丧的一次次重启，然后一切才能正常工作。

对于 Ubuntu 20.04 来说，在基本会话中一切都很正常，但是在我编辑 /etc/xrdp 中的 Xrdp.ini 文件之前，运行增强会话的选项是不可用的。这是一个受保护的位置，所以我不得不用管理员的凭证打开一个编辑器，这个任务既不直观也不容易。

我必须修改 ini 文件中的两行内容。首先，把 port=3389 改为 port=vsock://-1:3389。然后把 use_vsock=true 改为 use_vsock=false。关闭虚拟机连接窗口并再次连接到虚拟机，你应该可以启动增强型会话。但你可能还需要召唤一些小神灵，烧一些香。毕竟，这是 Linux。

（正如我之前所提到的，Canonical/微软团队将在 20.04.1 更新中对该镜像进行修复，所以到时候 xrdp.ini 文件不需要编辑了。）

而你现在就只能靠自己了。你必须找到能让你完成实际工作的生产力软件。如果你像我一样，主要使用微软的服务，准备好接受一大堆的挫折吧。

微软目前没有任何适用于 Linux 的 Office 应用程序，所以你需要从 Web 浏览器访问你的文件。(是的，有 Linux 的 Office 克 隆版，包括 LibreOffice 套件，它是微软 Office 2007 的忠实克隆版。它……勉强够用。)

在 Ubuntu Linux 20.04 中，我可以直接连接 Google Drive，这样那些云端备份的文件就直接出现在文件应用中。还可以使用一个易于安装的 Dropbox 应用。但是 OneDrive 呢？那就不一定了。有一个开源的第三方同步客户端，但安装时需要半打以上的依赖包，我没有耐心也没有信心完成这个过程。

Ubuntu Linux 中的默认浏览器是 Mozilla Firefox，它在 18.04.3 LTS 版本上工作得足够好，但在 20.04 版本中却很卡顿。微软表示，它计划为 Linux 发布基于 Chromium 的新 Edge，但到目前为止，这还只是一个排期。从好的方面来看，有一个做得非常好的微软 Teams 客户端，它可以提供一个原生的 .deb 包来安装。

虽然整体体验出乎意料的流畅，但有太多的时刻，运行 Linux 对我来说感觉略显磕磕绊绊。比如在 20.04 版本中，Firefox 会将包文件下载到一个临时文件夹，在那里无法正常打开。当我弄清楚我必须把这些文件移到下载目录下，一切都好了。（请注意， Google Chrome 浏览器的下载会默认到正确的位置。）

另一方面，如果你的工作日是在谷歌生态系统中度过的，Linux 可能会感到非常舒适。在安装 Chrome 浏览器和设置 G Suite 之后，这个虚拟机基本上就是一个略显廉价的 Chromebook。

我是不是要改用 Linux 作为主要操作系统？呃，不会。但我会让这些虚拟机继续服务，并定期检查。因为你永远不知道会……

via: https://www.zdnet.com/article/microsoft-helped-me-install-ubuntu-linux-on-my-windows-10-pc-and-its-actually-pretty-good/

作者：Ed Bott 译者：wxy 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出

Vagrant 是一个出色的工具，DevOps 专业人员、程序员、系统管理员和普通极客来使用它来建立可重复的基础架构来进行开发和测试。引用自它的网站：

Vagrant 是用于在单工作流程中构建和管理虚拟机环境的工具。凭借简单易用的工作流程并专注于自动化，Vagrant 降低了开发环境的设置时间，提高了生产效率，并使“在我的机器上可以工作”的借口成为过去。

如果你已经熟悉 Vagrant 的基础知识，那么该文档为所有的功能和内部结构提供了更好的参考。

Vagrant 提供了基于行业标准技术构建的、易于配置、可复制、可移植的工作环境，并由一个一致的工作流程控制，帮助你和你的团队最大限度地提高生产力和灵活性。

https://www.vagrantup.com/intro

本指南将逐步介绍使 Vagrant 在基于 Fedora 的计算机上工作所需的步骤。

我从最小化安装 Fedora 服务器开始，因为这样可以减少宿主机操作系统的内存占用，但如果你已经有一台可以使用的 Fedora 机器，无论是服务器还是工作站版本，那么也没问题。

检查机器是否支持虚拟化

$ sudo lscpu | grep Virtualization

Virtualization:                  VT-x
Virtualization type:             full

安装 qemu-kvm

sudo dnf install qemu-kvm libvirt libguestfs-tools virt-install rsync

启用并启动 libvirt 守护进程

sudo systemctl enable --now libvirtd

安装 Vagrant

sudo dnf install vagrant

安装 Vagrant libvirtd 插件

sudo vagrant plugin install vagrant-libvirt

添加一个 box

vagrant box add fedora/32-cloud-base --provider=libvirt

（LCTT 译注：以防你不知道，box 是 Vagrant 中的一种包格式，Vagrant 支持的任何平台上的任何人都可以使用盒子来建立相同的工作环境。）

创建一个最小化的 Vagrantfile 来测试

$ mkdir vagrant-test
$ cd vagrant-test
$ vi Vagrantfile

Vagrant.configure("2") do |config|
  config.vm.box = "fedora/32-cloud-base"
end

注意文件名和文件内容的大小写。

检查文件

vagrant status

Current machine states:

default not created (libvirt)

The Libvirt domain is not created. Run 'vagrant up' to create it.

启动 box

vagrant up

连接到你的新机器

vagrant ssh

完成了。现在你的 Fedora 机器上 Vagrant 可以工作了。

要停止该机器，请使用 vagrant halt。这只是简单地停止机器，但保留虚拟机和磁盘。 要关闭并删除它，请使用 vagrant destroy。这将删除整个机器和你在其中所做的任何更改。

接下来的步骤

在运行 vagrant up 命令之前，你不需要下载 box。你可以直接在 Vagrantfile 中指定 box 和提供者，如果还没有的话，Vagrant 会下载它。下面是一个例子，它还设置了内存量和 CPU 数量：

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|
  config.vm.box = "fedora/32-cloud-base"
  config.vm.provider :libvirt do |libvirt|
    libvirt.cpus = 1
    libvirt.memory = 1024
  end
end

关于使用 Vagrant、创建你自己的机器和使用不同 box 的更多信息，请参见官方文档 https://www.vagrantup.com/docs。

有一个庞大的仓库，你可以随时下载使用这些 box，它们的的官方仓库是 Vagrant Cloud - https://app.vagrantup.com/boxes/search。这里有些是基本的操作系统，有些提供完整的功能，如数据库、网络服务器等。

via: https://fedoramagazine.org/vagrant-qemukvm-fedora-devops-sysadmin/

作者：Andy Mott 选题：lujun9972 译者：geekpi 校对：wxy

本文由 LCTT 原创编译，Linux中国 荣誉推出