2020年10月

自 1998 年以来，IPv6 一直在努力解决 IPv4 可用 IP 地址的不足的问题，然而尽管 IPv6 在效率和安全方面具有优势，但其采用速度仍然缓慢。

在大多数情况下，已经没有人一再对互联网地址耗尽的可怕境况发出警告，因为，从互联网协议版本 4（IPv4）的世界到 IPv6 的迁移，虽然缓慢，但已经坚定地开始了，并且相关软件已经到位，以防止许多人预测的地址耗竭。

但在我们看到 IPv6 的现状和发展方向之前，让我们先回到互联网寻址的早期。

什么是 IPv6，为什么它很重要？

IPv6 是最新版本的 互联网协议 Internet Protocol （IP），它可以跨互联网识别设备，从而确定它们的位置。每一个使用互联网的设备都要通过自己的 IP 地址来识别，以便可以通过互联网通信。在这方面，它就像你需要知道街道地址和邮政编码一样，以便邮寄信件。

之前的版本 IPv4 采用 32 位寻址方案，可以支持 43 亿台设备，本以为已经足够。然而，互联网、个人电脑、智能手机以及现在物联网设备的发展证明，这个世界需要更多的地址。

幸运的是， 互联网工程任务组 Internet Engineering Task Force （IETF）在 20 年前就认识到了这一点。1998 年，它创建了 IPv6，使用 128 位寻址方式来支持大约 340 亿亿亿 trillion trillion （或者 2 的 128 次幂，如果你喜欢用这种表示方式的话）。IPv4 的地址可表示为四组一至三位十进制数，IPv6 则使用八组四位十六进制数字，用冒号隔开。

IPv6 的好处是什么？

IETF 在其工作中为 IPv6 加入了对 IPv4 增强的功能。IPv6 协议可以更有效地处理数据包，提高性能和增加安全性。它使互联网服务提供商（ISP）能够通过使他们的路由表更有层次性来减少其大小。

网络地址转换（NAT）和 IPv6

IPv6 的采用被推迟，部分原因是 网络地址转换 network address translation （NAT）导致的，NAT 可以将私有 IP 地址转化为公共 IP 地址。这样一来，拥有私有 IP 地址的企业的机器就可以向位于私有网络之外拥有公共 IP 地址的机器发送和接收数据包。

如果没有 NAT，拥有数千台或数万台计算机的大公司如果要与外界通信，就会吞噬大量的公有 IPv4 地址。但是这些 IPv4 地址是有限的，而且接近枯竭，以至于不得不限制分配。

NAT 有助于缓解这个问题。有了 NAT，成千上万的私有地址计算机可以通过防火墙或路由器等 NAT 设备呈现在公共互联网上。

NAT 的工作方式是，当一台拥有私有 IP 地址的企业计算机向企业网络外的公共 IP 地址发送数据包时，首先会进入 NAT 设备。NAT 在翻译表中记下数据包的源地址和目的地址。NAT 将数据包的源地址改为 NAT 设备面向公众的地址，并将数据包一起发送到外部目的地。当数据包回复时，NAT 将目的地址翻译成发起通信的计算机的私有 IP 地址。这样一来，一个公网 IP 地址可以代表多台私有地址的计算机。

谁在部署 IPv6？

运营商网络和互联网服务供应商是最早开始在其网络上部署 IPv6 的群体，其中移动网络处于领先地位。例如，T-Mobile USA 有超过 90% 的流量通过 IPv6，Verizon Wireless 紧随其后，占 82.25%。根据行业组织 World Ipv6 Launch 的数据，Comcast 和 AT&T 的网络分别为 63% 和 65%。

主要网站则排在其后 —— World IPv6 Launch 称，目前 Alexa 前 1000 的网站中只有不到 30% 可以通过 IPv6 到达。

企业在部署方面比较落后，根据 互联网协会 Internet Society 的《2017年 IPv6 部署状况》报告，只有不到四分之一的企业宣传其 IPv6 前缀。复杂性、成本和完成迁移所需时间都是他们给出的理由。此外，一些项目由于软件兼容性的问题而被推迟。例如，一份 2017 年 1 月的报告称，Windows 10 中的一个 bug “破坏了微软在其西雅图总部推出纯 IPv6 网络的努力”。

何时会有更多部署？

互联网协会表示，IPv4 地址的价格将在 2018 年达到顶峰，然后在 IPv6 部署通过 50% 大关后，价格会下降。目前，根据 Google，全球的 IPv6 采用率为 20% 到 22%，但在美国约为 32%。

随着 IPv4 地址的价格开始下降，互联网协会建议企业出售现有的 IPv4 地址，以帮助资助其 IPv6 的部署。根据一个发布在 GitHub 上的说明，麻省理工学院已经这样做了。这所大学得出的结论是，其有 800 万个 IPv4 地址是“过剩”的，可以在不影响当前或未来需求的情况下出售，因为它还持有 20 个 非亿级 nonillion IPv6 地址。（非亿级地址是指数字 1 后面跟着 30 个零）。

此外，随着部署的增多，更多的公司将开始对 IPv4 地址的使用收费，而免费提供 IPv6 服务。英国的 ISP Mythic Beasts 表示，“IPv6 连接是标配”，而 “IPv4 连接是可选的额外服务”。

IPv4 何时会被“关闭”？

在 2011 年至 2018 年期间，世界上大部分地区“用完”了新的 IPv4 地址 —— 但我们不会完全没有 IPv4 地址，因为 IPv4 地址会被出售和重新使用（如前所述），而剩余的地址将用于 IPv6 过渡。

目前还没有正式的 IPv4 关闭日期，所以人们不用担心有一天他们的互联网接入会突然消失。随着越来越多的网络过渡，越来越多的内容网站支持 IPv6，以及越来越多的终端用户为 IPv6 功能升级设备，世界将慢慢远离 IPv4。

为什么没有 IPv5？

曾经有一个 IPv5，也被称为 互联网流协议 Internet Stream Protocol ，简称 ST。它被设计用于跨 IP 网络的面向连接的通信，目的是支持语音和视频。

它在这个任务上是成功的，并被实验性地使用。它的一个缺点是它的 32 位地址方案 —— 与 IPv4 使用的方案相同，从而影响了它的普及。因此，它存在着与 IPv4 相同的问题 —— 可用的 IP 地址数量有限。这导致了发展出了 IPv6 并和最终得到采用。尽管 IPv5 从未被公开采用，但它已经用掉了 IPv5 这个名字。

via: https://www.networkworld.com/article/3254575/what-is-ipv6-and-why-aren-t-we-there-yet.html

作者：Keith Shaw,Josh Fruhlinger 选题：lujun9972 译者：wxy 校对：wxy

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

下载我们的电子书，学习如何更好地使用 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中国 荣誉推出

本文是该系列的第五篇。

对于实时消息，我们将使用 服务器发送事件 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中国 荣誉推出

Windows 上的 Linux 正在继续发展，功能越来越强大。现在，图形化的 Linux 程序正在被整合到 WSL 中。

在微软 Build 2020 虚拟开发者大会上，微软 CEO 萨提亚·纳德拉宣布 Windows 的 Linux 子系统（WSL）2.0 即将支持 Linux GUI 和应用程序。现在这一天比以往任何时候都要近。在最近的 X.Org 开发者大会（XDC）上，微软合作伙伴开发者负责人 Steve Pronovost 透露，微软已经可以在 WSL 中运行图形化的 Linux 应用。

一直以来，虽然都可以在 WSL 上运行 GIMP 图形编辑器、Evolution 电子邮件客户端和 LibreOffice 等 Linux 图形程序，但这并不容易。你必须安装一个第三方 X Window 显示服务器，比如 Windows 10 中的 VcXsrv Windows X Server，然后对 Windows 和 Linux 做一些调整，让它们顺利地一起工作。X Window 系统几乎是所有 Linux 图形用户界面的基础。

现在，微软已经将 Wayland 显示服务器移植到 WSL 中。Wayland 是最流行的 X Window 兼容的显示服务器。在 WSL2 中，它通过远程桌面协议（RDP）连接将图形化的 Linux 应用程序连接到主 Windows 显示器上。这意味着你可以在同一个桌面屏幕上同时运行 Linux 和 Windows GUI 应用程序。

Pronovost 解释道：

WSL 本质上是在 Windows 托管的虚拟机里面运行 Linux，我们将应用程序（控制台程序，现在还有 GUI 程序）整合回你的 Windows 桌面，这样你就可以在统一的体验里面同时运行 Win32 和 Linux 应用程序。由于 Linux 是在虚拟机中运行，我们不能运行期望直接访问 GPU 的原生 GPU 驱动程序（除非我们做一些类似于离散设备分配的事情，并将其中一个宿主机 GPU 分配给虚拟机......但那样宿主机将失去对该 GPU 的访问！）。有了GPU-PV（GPU 准虚拟化），我们基本上可以在 Linux 中投射宿主机 GPU，让 Linux 和 Windows 进程共享同一个物理 GPU，而不需要固定的资源分区。

微软 WSL 项目经理 Craig Loewen 在 Twitter 上补充道，使用第三方 X 服务器和内置 Wayland 服务器的关键区别在于。“你不需要启动显示服务器，我们会为你处理。”此外，它还带有“与 Windows 的完美集成”，例如投影和 Linux 图标支持。

Loewen 还表示，你可以在其中运行 Linux Web 浏览器。“我们还没有用完整的桌面环境（DE）对它进行充分测试，因为我们想先专注于运行经常被问及的应用，主要是 IDE（集成开发环境），这样你就可以在一个完整的 Linux 环境中运行这些应用，”他说。

不过，先别太兴奋。Loewen 继续说道：“我们还没有制定测试通道的时间表，不过，这项工作通常会在接下来几个月内提供给 Insiders 试用。”

微软将 Linux 整合到 Windows 中已经有一段时间了。四年前，微软推出了 WSL，将 Linux Bash shell 带到了 Windows 10 中。通过 Bash 和 WSL，你可以运行大多数 Linux shell 工具和流行的 Linux 编程语言。

随着时间的推移，Linux 更成为 Windows 桌面上的一等公民。多个 Linux 发行版，从 Ubuntu 开始，随后是红帽 Fedora 和 SUSE Linux 企业桌面版（SLED） 都进入了 Windows 商店。随后，微软用 WSL 2 取代了将 Linux 内核调用转换为 Windows 调用的 WSL 翻译层。这一更新是在精简版 Hyper-V 管理程序上运行的微软自己的 Linux 内核附带的。

最近，从 Windows 10 Insider Preview build 20211 开始，Windows 用户可以访问 Linux 文件系统。这包括访问 Windows 本身不支持的 Linux 文件系统，例如 ext4。这也意味着，如果你用不同的磁盘双启动 Windows 和 Linux，现在可以从 Windows 访问 Linux 文件。有了这个功能，你可以通过管理权限从 Windows 文件资源管理器和 PowerShell 窗口访问 Linux 文件。

按照现在的发展速度，我对 Windows 11 可能会运行在 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中国 荣誉推出

本文是该系列的第四篇。

在这篇文章中，我们将对端点进行编码，以创建一条消息并列出它们，同时还将编写一个端点以更新参与者上次阅读消息的时间。 首先在 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中国 荣誉推出

  1. 1
  2. ...
  3. 7
  4. 8
  5. 9
  6. 10
  7. 11
  8. 12