2020年5月份，Go语言之父Rob Pike接受了evrone.com的专访。当Rob Pike老爷子被问及多年来他看到过最奇怪、最有创意或有趣的Go用法或最让他惊讶的是什么时，老爷子是这么回答的：

Rob：最大的惊喜是当我们得知Go被用于编写恶意软件时。您无法控制谁将使用您的作品或他们将如何使用它。

近期安全技术公司Intezer发布了一份名为《Year of the Gopher, A 2020 Go Malware Round-Up》的报告，该报告称在过去几年中，安全人员发现的用Go编写的新恶意软件几乎增加了2000%，这一标题迅速引爆程序员社区，有人唾弃Go踏入“歧途”，也有人膜拜Go的niubility：能被黑客看中和使用的都是精华！

那么究竟是什么让黑客们这么青睐Go并用之去编写恶意软件呢？估计但那份几十页的报告没几个人会完整的读一遍，本文我们就结合报告的内容(分类、整理、摘录)做一些探究。

1. Go语言的简介

报告首先简单介绍了Go的前世今生。

Go是一种开源的编程语言，由Robert Griesemer、Rob Pike和Ken Thompson于2007年在Google开发。它于2009年11月向公众发布。开发新语言的动机来自于使用当前编程语言(当时三巨头都是用C++)的挫折感。由于CPU不再通过增加时钟周期的数量来提高速度。相反，更多的速度开始通过添加更多的CPU核并允许更多的并行执行来获得。这种硬件上的进化并没有很好地反映在通用编程语言中。虽然C、C++和Java等语言提供了在多核上并行执行事务的功能，但它们为程序员提供的帮助却很少，无法高效、安全地完成这项工作。

Google的程序员们于是开始设计一种新的编程语言，为方便和安全的使用并发或并行提供“原生/一等公民地位”的支持。另一个目标则是要将解释型语言的编程便利性与静态类型和编译型语言的效率和安全性结合起来。另外在设计时，Google是将其用于Google基础设施运行的一部分网络服务中，因此对网络的支持也很重要。

为了提供在解释语言中编程的感觉，Go使用垃圾收集并处理所有的内存管理。所有的Go二进制文件都包含一个称为运行时的通用库，这导致Go二进制文件的大小比用C语言编写的类似的静态链接的程序要大。该库负责处理垃圾收集、执行线程的调度以及该语言的所有其他关键功能。虽然它被称为运行时，但比起Java运行时，它更像C语言的libc，它已经与二进制文件进行了静态编译。Go二进制文件被编译成本地机器代码，但也可以被编译成以JavaScript为运行时的WebAssembly。

Go 1.4版本及更早版本的编译器是用C语言实现的，但随着2015年1.5版本的发布，编译器完全用Go语言编写，并实现了自举。转为自举编译器后，给用户在交叉编译方面的体验带来了巨大的改善。之前使用基于C语言的编译器时，需要在编译代码的机器上安装一个针对目标操作系统和架构的C编译器。和针对不同目标的C代码进行交叉编译时的方式非常相似。从1.5版本开始，只需要向编译器指明它的编译目标架构，就可以实现对不同操作系统和架构的交叉编译。不需要针对目标的特殊编译器。Go可以通过不依赖主机上的库来执行例如syscalls(系统调用)。本来由libc提供的功能由Go的标准库提供和处理。这种方便的交叉编译有一个限制，那就是当Go程序需要通过其外函数接口（FFI）与C语言编写的库进行交互时。

新的功能和解决方案使得程序员在新项目中采用Go。2016年，TIOBE授予Go“年度最佳编程语言”，这是一个授予评分上升幅度最高的语言的奖项。随着软件开发者因其功能而开始采用Go，恶意软件作者也开始采用Go也就不足为奇了。

人们注意到使用Go开发的恶意软件增多是从2019年Palo Alto Networks公司发布的一份分析报告开始的。2019年7月，Palo Alto Networks公司的Unit 42发布了对当时发现的用Go编写的恶意软件的分析报告。研究发现，2017年至2019年期间，人们发现的Go恶意软件样本增加 了1944%，这量化了一个很容易发现的趋势。在2019年之前，发现用Go编写的恶意软件更多的是一种罕见的现象，而在2019年期间，这成为了一种日常现象。报告中分析的恶意软件中，大部分，92%的恶意软件针对Windows，而4.5%针对Linux，3.5%针对macOS。
人们观察到的另一点是，渗透测试(pen-testing)团队采用Go来开发他们的工具，这在Unit 42的研究中很突出。

最常见的恶意软件家族类型是开源或渗透测试后门。其次是coinminer(挖矿)、窃取者和僵尸网络。这篇报告涵盖了2020年期间活跃的用Go编写的已知恶意软件的活动。

2. 使用Go的嵌入文件功能实现恶意加载器

与其他语言产生的二进制文件相比，Go编译器产生的二进制文件相对较大。例如，一个Hello World二进制文件有1700多个函数。由于二进制文件中有这么多的常用代码，因此在寻找可疑代码时就像大海捞针一样。这可能是为什么恶意Go二进制文件有时不被 反病毒引擎检测到的原因之一。这导致一些威胁行为者在Go中开发加载器，并利用它们来提供其他较老的、易被检测到的恶意软件。这种技术可以降低被检出率，甚至有时会使恶意软件完全无法被检测到。在Go二进制文件中嵌入其他二进制文件相对容易。有很多开源库已经解决了这个问题。下面是其中的一些列表：

• https://github.com/gobuffalo/packr
• https://github.com/rakyll/statik
• https://github.com/GeertJohan/go.rice
• https://github.com/UnnoTed/fileb0x
• https://github.com/mjibson/esc
• https://github.com/kevinburke/go-bindata
• https://github.com/lu4p/binclude
• https://github.com/omeid/go-resources
• https://github.com/pyros2097/go-embed
• https://github.com/wlbr/mule
• https://github.com/miscing/embed
• https://github.com/kyioptr/gassets

上述包的大部分的设计都是为了允许嵌入网络服务的静态资源文件(asset)，但使用案例并不限于此。嵌入文件的功能受到了广泛的好评，以至于今年2020年早些时候有人建议将该功能直接添加到Go编译器中。该建议已被接受，并已与2021年2月发布的Go 1.16版本一起发布了。从这个角度来看，Go 1.16版本加入嵌入文件功能，颇有些“助纣为虐”之嫌^_^。

3. 使用Go标准库强大的加密库和便捷的跨主机交叉编译特性实现恶意加密器和勒索软件

Go的标准库提供了一套非常强大的加密库，允许开发者在不需要使用任何第三方库的情况下，在应用中加入加密功能。

一个开源的加密加载器是Go shellcode LoaDer。它用AES对有效载荷进行加密。它对有效载荷进行解密，并在执行之前使用ZwProtectVirtualMemory将解密缓冲区标记为读取/执行。

我们还观察到威胁行为者编写自己的加密器和加载器。例如，我们看到一个名为gocrypter的加载器被用于加密商品恶意软件；大多数是RAT(Remote Access Trojans，远程访问木马)和键盘记录器。有效载荷已经用AES加密，并作为base64编码的blob存储在二进制内部。加密器将其解码成字节，并在写入磁盘和执行之前进行解密。

在2020年仍有一些活动的勒索软件，比如：RobbinHood。RobbinHood在2019年春季被发现，当巴尔的摩市被发现受到该勒索软件攻击时，得到了很多媒体的关注。Sophos在2月份发布了一份报告，详细介绍了该威胁行为者的一些演变过程。通过利用技嘉公司的一个脆弱的驱动程序，威胁行为者开始加载一个未签名的驱动程序。一旦驱动程序被加载，它将杀死进程和篡改保护软件，以确保勒索软件可以在不被中断的情况下加密硬盘驱动器的其余部分。但在2020年11月，仍有新的样本被发现，但勒索说明没有改变。11月的一个样本的PDB字符串为C:/Users/User/go/src/Robbinhood7，这表明根据恶意软件作者的说法，它可能是第7个版本的勒索软件。

另一个用Go编写的、仍然活跃的老牌勒索软件是Snatch。Snatch是在2018年12月被发现的，到现在似乎还在使用。该勒索软件由Snatch Team使用，他们通过远程访问服务（例如RDP）瞄准企业环境。一旦进入网络，该组织就会尝试在所有机器上部署勒索软件， 并对文件进行加密。该勒索软件在加密文件时有一个有趣的技术，该技术在2019年10月被引入到勒索软件中。该勒索软件将自己安装为一项服务，即使Windows启动到安全模式，也可以启动。在此之后，勒索软件将Windows重新启动到安全模式，允许它加密硬盘上的所有文件，而不会被安装的任何潜在的安全保护软件阻止。

Nefilim是一款勒索软件，最早出现在2020年3月。它是另一款名为Nemty的勒索软件的前身。最初的版本是用C++编写的，但在7月，该恶意软件用Go重新编写。除了加密受害者机器上的文件外，Nefilim背后的威胁行为者还窃取受害者的数据，并用于勒索。

由于Go提供了一种针对不同架构和操作系统交叉编译二进do制文件的简单方法，因此它被用于RaaS(Ransomware as a Service)勒索软件并不奇怪。它允许威胁行为者使用单一的代码库，以极低的工作量制作针对不同操作系统的二进制文件。Go已经被用于RaaS。在2020年的春天，一个新的RaaS被宣布，名为Smaug。Smaug是一个相对简单的勒索软件，但它为Windows、Linux和macOS提供”用户”的勒索软件服务。它可以在”企业”模式下运行，即所有机器使用一个密钥，或者每台机器模式下使用一个密钥。

Go可以为其他操作系统和架构制作二进制文件，这使得威胁行为者可以轻松地针对不同类型的设备，例如，嵌入式系统。在2019年夏天，我们发现了QNAPCrypt，也就是eCh0raix，这是一款针对QNAP NAS设备的勒索软件。后来，它还被用来针对Synology NAS设备。2020年，又发现了一款针对QNAP设备的新勒索软件。新的勒索软件被称为AgeLocker，因为它使用了开源的加密工具和库age。

在2020年期间发现的其他用Go编写的勒索软件包括。1月发现的Betasup，2月发现的Sorena也就是HackForLife和Vash，3月发现的GoGoogle。

4. 使用Go优秀的网络协议栈实现开发RAT(远程访问木马)、恶意偷窃程序、恶意机器人和僵尸网络

Go的网络协议栈写得非常好，易于操作。Go已经成为云计算的编程语言之一，很多云原生应用都是用它编写的。例如，Docker、Kubernetes、InfluxDB、Traefik、Terraform、CockroachDB、Prometheus和Consul都是用Go编写的。这是有道理的，因为创建Go背后的原因之一正是要发明一种更好的语言，可以用来取代Google内部使用的C++网络服务。因此远程访问木马(RAT)是用Go编写的，这并不奇怪。毕竟，它们非常需要优良的网络服务功能。

在这一年中，既有新的RAT出现，也有老的RAT不断被使用。早在2020年8月，我们发现了一个Linux版本的Carbanak威胁行为体使用的后门。该样本使用2017年2月发布的Go 1.8版本编译器进行编译。同样的编译器版本和构建环境被用于2017年RSA报告的一部分的初始Windows样本。

Glupteba是一个自2011年以来一直存在的恶意软件，但在2019年9月，发现了一个用Go改写的新版本。在整个2020年，这个新版本出现的更为频繁。该恶意软件在感染机器时，会尝试安装一个root-kit。为了绕过Windows中防止安装内核驱动程序的保护措施，恶意软件利用了一个脆弱的VirtualBox驱动程序。恶意软件会安装该驱动程序，由于该驱动程序是经过签名的，所以Windows会允许安装，并使用它在Ring-0中执行代码，以禁用Kernel Patch Protection（KPP）。这种技术并不新鲜，它最早被APT组织Turla使用。除此之外，该恶意软件还试图通过利用EternalBlue在本地网络内进行传播。

Windows并不是唯一一个被用Go编写的RAT攻击的操作系统。2020年10月，Bitdefender发布了一个针对Linux的新RAT的发现。Bitdefender的研究人员认为，它可能与2019年的PowerGhost活动有关。该威胁行为体针对的是易受CVE-2019-2725影响的WebLogic服务器。该RAT似乎被作者命名为NiuB。该恶意软件由两个二进制文件组成，即主恶意软件和一个防护恶意软件。该恶意软件收集受感染机器的信息，并将其发送到C2服务器。它可以执行shell命令，下载并执行其他二进制文件。

2020年1月，FireEye发布了一份针对NetScaler设备的攻击报告。攻击是利用CVE-2019-19781漏洞。作为攻击的一部分，威胁行为者使用了一种新的恶意软件，以前从未见过。FireEye将该恶意软件命名为NOTROBIN。它是用Go编写的，并被编译成在*BSD上运行，这是NetScaler使用的底层操作系统。一个有趣的功能是，该恶意软件通过扫描新的NetScaler模板文件并将其删除来阻止其他恶意软件利用相同的漏洞，这些文件可能是作为利用尝试的一部分添加的。它在18634端口上打开一个UDP监听器，但忽略发送到它的数据。它基本上充当了一个mutex，以确保受感染的机器上只运行一个恶意软件的副本。

已经有一些用Go编写的窃取器。在2019年，Malwarebytes报告了一个名为CryptoStealer.Go的窃取器。它旨在窃取加密货币钱包和 存储在浏览器中的数据，如信用卡信息。

同样在2020年期间，发现了一个用Go编写的剪贴板窃取器。它似乎自2019年以来一直活跃。根据上传到VirusTotal的样本的文件名 ，该窃取器被伪装成黑客工具，表明它被用来针对其他威胁行为者。该恶意软件的设计很简单。它将自己安装在App/DataLocal/Support下，并隐藏文件或文件夹。它读取剪贴板并检查它是否看起来像加密货币地址。如果是，恶意软件就会用攻击者自己的比特币、莱特币、Monero或Ethereum钱包替换剪贴板内容。

该恶意软件中的比特币钱包地址自2018年秋季以来一直处于活跃状态。截至本文撰写时，它已经收到了534笔交易，价值近11BTC。

随着Go作为标准库的一部分支持许多网络协议，以及为不同架构编译二进制文件的便利性，越来越多的机器人用Go编写也就不足为奇了。另外，二进制文件包含了正常运行所需的一切，这也为代码作者提供了更多的保证，例如，它可以在不同的Linux发行版上运行。它不用担心机器上是否已经安装了库。因为它需要什么，就自带什么。还有很多第三方库，提供了访问其他服务的功能。

比如这里列出了一些机器人库，可以用来开发不同服务的机器人。

• https://github.com/go-joe/joe
• https://github.com/bot-api/telegram
• https://github.com/shomali11/slacker
• https://github.com/go-chat-bot/bot
• https://github.com/frodsan/fbot
• https://github.com/go-telegram-bot-api/telegram-bot-api
• https://github.com/tucnak/telebot

随着开源机器人库的出现，它们被恶意软件作者滥用的情况并不少见。IRCFlu就是一个例子。IRCFlu是一个托管在GitHub上的IRC机器人。该机器人提供了在托管机器人的机器上执行任意代码的功能，这使得威胁行为者可以利用这个机器人远程控制多台受感染的机器。

除了开源项目被滥用外，2020年还出现了老牌知名僵尸网络的攻击行为。被称为ddg的僵尸网络是由Netlab在360首次报道的。他们在2017年10月检测到该僵尸网络对托管OrientDB的服务器的攻击。该僵尸网络的目标是安装Monero矿机。2020年，该僵尸网络进行了更新，通过增加一个p2p网络支持的C2基础设施，使其更有弹性地抵御击杀。混合的p2p网络基础设施允许威胁行为者在正常的C2服务器瘫痪时保持对机器人的控制。

另一个仍然活跃的老僵尸网络是StealthWorker，也被称为GoBrut。StealthWorker是Malwarebytes在2019年2月首次报道的。它是一个以Stealth Bomber为名在暗网论坛上销售的僵尸，用于通过凭证式蛮力攻击获得网络服务的访问权限。

僵尸网络r2r2是另一个通过蛮横强迫凭证传播的僵尸。它最早是在2018年被发现的。它随机生成IP地址，并试图通过弱凭证访问运行SSH的服务。一旦它获得了一个立足点，它就会在机器上安装一个密码器。该僵尸的功能非常有限，它由不到200百行的代码组成。

其他僵尸网络也在不断进化，以增加其潜在的目标。在2020年，Orthrus，也被称为Golang，演变为也针对Windows服务器。该僵尸是Antiy在2019年6月首次报道的。它主要针对未受保护或凭证薄弱的Redis服务器。一旦它获得远程代码执行，它就会安装一套二进制文件。一个是针对其他易受攻击服务的扫描器，一个看门狗服务和一个密码器。扫描器试图破坏其他有已知漏洞的网络服务。例如，Weblogic，Elasticsearch和Drupal是目标。在2020年，该恶意软件还增加了针对微软SQL服务器的目标。它试图通过强行获取凭证来获得访问权。该恶意软件包括一个近3000个密码的列表，它只针对SQL服务器使用。

12月，我们发现了另一个跨操作系统的挖掘机器人，我们称之为XMRig Miner Dropper。它的目标是运行MySQL、Tomcat和Jenkins的服务器以及凭证较弱或脆弱的WebLogic。根据底层操作系统的不同，该机器人提供了一个用于执行shell脚本或PowerShell脚本的有效载荷。一旦它入侵机器，它就会安装一个密码器，并试图利用其他服务器。

2016年9月，Mirai的源代码被发布。这导致许多新的僵尸网络从Mirai源代码中衍生出来。虽然该僵尸代码是用C++编写的，但该代码的发布为其他恶意软件作者用不同语言编写类似的僵尸提供了蓝本。2020年1月，Bitdefender发布了一份报告，介绍了一个用Go编写的受Mirai启发的新僵尸网络，他们将其命名为LiquorBot。该僵尸网络本质上是Mirai在Go中的重新实现，目标是运行在ARM（32位和64位）、x86（32位和64位）和MIPS上的Linux设备。该僵尸通过强行获取SSH证书和利用路由器的已知漏洞进行传播。一旦它获得了设备的访问权限，它就会试图感染其他人，并且还安装了一个Monero密码器。

LiquorBot并不是唯一受Mirai启发的僵尸网络。4月，我们发现了Kaiji，这是一个通过SSH蛮横强迫来针对Linux服务器和物联网设备的僵尸网络。除了强行插入薄弱的凭证外，该僵尸还试图使用在受感染机器上发现的本地SSH密钥来传播到企业内的其他机器。与Mirai类似，Kaiji允许僵尸管理员对他们选择的任何基础设施发起DDoS攻击。攻击包括两个TCPFlood实现（一个带有原始套接字）、两个UDPFlood实现（一个带有原始套接字）、IPSpoof攻击、SYNACK攻击、SYN攻击和ACK攻击。

2020年6月，Kaiji将其目标方法扩大到包括暴露API套接字的服务器。该恶意软件开始在互联网上扫描端口2375暴露的主机。如果它找到了一个，它会尝试部署一个流氓Docker容器，并在容器中执行Kaiji。

Kaiji不是唯一一个针对暴露的Docker API的僵尸网络。2020年11月，NetLab 360报告发现了一种名为Blackrota的新恶意软件。Kinsing，也被称为h2Miner，已经被称为针对Docker API。2020年1月，阿里巴巴云的研究人员首次报道了Kinsing。该僵尸网络正在使用masscan寻找暴露Hadoop Yarn、Redis和Docker的机器。当它发现一台运行这些服务的服务器时，它会试图利用服务中的已知漏洞来进一步传播自己。5月，我们观察到Kinsing利用SaltStack的两个漏洞CVE-2020-11651和CVE-2020-11652进行传播。该恶意软件还开始使用LD-PRELOAD用户地rootkit来隐藏其进程。

SSH brute-force已经成为用Go编写的僵尸网络采用的主要攻击方式之一。我们发现了IPStorm的一个新的Linux变种，其中包括这种攻击向量。IPStorm是一个点对点(p2p)僵尸网络，于2019年5月首次被发现。它使用开源项目IPFS作为其网络骨干。除了原始的Windows变体，我们还发现了作为Linux变体的一部分，针对Android和物联网设备的变体。与本报告中的其他僵尸网络不同，IPStorm的目标不是安装矿机。相反，该僵尸网络似乎提供了一个代理网络。这个代理网络是作为互联网上的匿名代理网络出售的。

IPStorm不是唯一一个在2020年活跃的Go编写的p2p网络。2020年8月，Guardicore发布了一份关于他们从同年1月开始追踪的一个新的p2p僵尸网络的报告。该僵尸网络被命名为FritzFrog，通过强行使用弱小的凭证来感染机器。Guardicore称，该僵尸网络已经成功入侵了超过500台服务器，其中包括 “美国和欧洲的知名高教机构，以及一家铁路公司”。

5. 未来预测与结论

虽然与用其他语言编写的恶意软件相比，用Go编写的恶意软件数量相对较少，但同比增长幅度很大。这种增长速度很可能会继续下去，这意味着用Go编写的恶意软件将变得更加频繁。对于针对Linux环境的恶意软件来说，用Go编写的部分比针对Windows的恶意软件要大。这很可能导致，在根据针对特定系统的恶意软件总量统计中，针对Linux系统的恶意软件的比例将可能变得最大。

在目前用Go编写的Linux恶意软件中，有很大一部分是用于DDoS或安装密码器的机器人。这种趋势可能会持续下去。其他类型也可能会变得更加频繁。我们已经看到了针对Linux系统的Go勒索软件，而且有可能会出现更多的以窃取和加密有价值数据为目标的勒索软件。这与Proofpoint对2021年的预测一致，即勒索软件威胁行为者将开始更加关注攻击云端。这意味着企业应该采用专注于云的检测和预防产品，以确保他们的云环境受到保护。许多传统的防病毒和保护解决方案都是为了保护Windows环境而设计的，而Linux环境则更多地成为了”二等公民”。

根据CrowdStrike从2020年开始的事件报告，在40%的事件中，恶意软件没有被反病毒产品检测到。除此之外，Go恶意软件一直很难被反病毒产品检测到，所以这种趋势很可能会继续下去。我们已经看到威胁行为者以相同的恶意软件代码库为中心，针对不同的操作系统进行攻击，导致恶意软件样本较少或未被检测到。由于恶意软件来自相同的代码库，因此使用代码基因的检测方法非常有效。未来我们很可能会看到更多针对多个操作系统的恶意软件，因为像Go这样的编程语言为恶意软件作者提供了一种简单的交叉编译恶意软件的方法。

在Windows方面，许多威胁行为者已经使用Go来制作勒索软件。未来这种趋势很可能会继续下去。随着更多RaaS产品的出现，用Go编写勒索软件也不是不可能。由于能够轻松地进行交叉编译，RaaS运营商可以为他们的”客户”提供更广泛的目标。

Go是一种开源的编程语言，它是在Google内部开发的，目的是利用过去几十年在硬件上取得的进步。它的设计是为了让开发者能够轻松地制作快速、安全、以网络为中心的代码，并在当今的多核CPU上获益。这使得该语言得到了极大的应用，尤其是在云环境中。开发者并不是唯一采用Go的人。Go强大的跨平台交叉编译、优秀的网络实现和加密库以及原生的文件嵌入功能让其颇受恶意软件开发者的青睐！ 在过去几年中，在市面上发现的用Go编写的新恶意软件几乎增加了2000%。这些恶意软件中有许多是针对Linux和物联网设备的僵尸网络，以安装加密矿机或将受感染的机器注册到DDoS僵尸网络中。此外，用Go编写的勒索软件似乎也变得更加普遍。一些用Go编写的著名勒索软件是Nefilim、EKANS和RobbinHood，这些勒索软件用于所谓的大型猎物攻击。

传统的反病毒解决方案似乎仍然难以检测到用Go编写的恶意软件。较新的技术不仅可以根据代码重用来判断恶意，还可以对威胁进行分类，已经取得了较大的成功，因为它们甚至可以处理Linux和Windows二进制文件之间的相似性。虽然用Go编写的恶意软件可能仍处于初级阶段，但它可能很快就会进入青春期，从而导致大量增加。

“Gopher部落”知识星球正式转正（从试运营星球变成了正式星球）！“gopher部落”旨在打造一个精品Go学习和进阶社群！高品质首发Go技术文章，“三天”首发阅读权，每年两期Go语言发展现状分析，每天提前1小时阅读到新鲜的Gopher日报，网课、技术专栏、图书内容前瞻，六小时内必答保证等满足你关于Go语言生态的所有需求！部落目前虽小，但持续力很强。在2021年上半年，部落将策划两个专题系列分享，并且是部落独享哦：

• Go技术书籍的书摘和读书体会系列
• Go与eBPF系列

Go技术专栏“改善Go语⾔编程质量的50个有效实践”正在慕课网火热热销中！本专栏主要满足广大gopher关于Go语言进阶的需求，围绕如何写出地道且高质量Go代码给出50条有效实践建议，上线后收到一致好评！欢迎大家订阅！目前该技术专栏正在新春促销！关注我的个人公众号“iamtonybai”，发送“go专栏活动”即可获取专栏专属优惠码，可在订阅专栏时抵扣20元哦(2021.2月末前有效)。

我的网课“Kubernetes实战：高可用集群搭建、配置、运维与应用”在慕课网热卖中，欢迎小伙伴们订阅学习！

我爱发短信：企业级短信平台定制开发专家 https://tonybai.com/。smspush : 可部署在企业内部的定制化短信平台，三网覆盖，不惧大并发接入，可定制扩展； 短信内容你来定，不再受约束, 接口丰富，支持长短信，签名可选。2020年4月8日，中国三大电信运营商联合发布《5G消息白皮书》，51短信平台也会全新升级到“51商用消息平台”，全面支持5G RCS消息。

著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格5$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式：

• 微博：https://weibo.com/bigwhite20xx
• 微信公众号：iamtonybai
• 博客：tonybai.com
• github: https://github.com/bigwhite
• “Gopher部落”知识星球：https://public.zsxq.com/groups/51284458844544

微信赞赏：

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

注：本文是首发于笔者微信公众号“iamtonybai”上的付费文章，这里免费分享给大家！

在2020.11.9~11.13举行的全球最具影响力的Go语言技术大会GopherCon 2020上，Go语言之父之一的Robert Griesemer为全世界Gopher们带来了本次大会最重量级的演讲“Typing [Generic] Go”。

在这个演讲中，Robert Griesemer向Gopher们介绍了自从今年中旬在Go官网发表文章“The Next Step for Generics”以来Go泛型(Go Generics)技术草案的最新变化，并详细介绍了类型参数(type parameter)是如何满足Go现有的类型系统的，以及Go编译器是如何对Go泛型代码进行类型检查的。

本文整理了此次演讲的重点内容，供广大Gopher参考，希望能为大家理解Go泛型带来帮助。

一. 预备知识

为了更好地理解Robert Griesemer的讲解，这里先带着大家回顾一下Go generics技术草案演化史。

• 2017年7月，Go核心团队领军人物Russ Cox在Gophercon 2017大会上发表演讲“Toward Go 2”，正式吹响Go向下一个阶段演化的号角；
• 2018年8月，在Gophercon 2018大会结束后不久，Go核心团队发布了Go2 draft proposal，这里面涵盖了由Ian Lance Taylor和Robert Griesemer操刀主写的Go泛型的第一版draft proposal。这版草案引入了contract关键字来定义泛型类型参数(type parameter)的约束、类型参数放在普通函数参数列表前面的小括号中，并用type关键字声明：

// 第一版泛型技术草案中的典型泛型语法

contract stringer(x T) {
    var s string = x.String()
}

func Stringify(type T stringer)(s []T) (ret []string) {

}

• 2019年7月，Ian Lance Taylor在GopherCon 2019大会上发表演讲“Why Generics?”，并更新了泛型的技术草案，简化了contract的语法设计：

// 简化后的contract语法如下：

contract stringer(T) {
    T String() string
}

• 2020年6月，《Featherweight Go》论文发表在arxiv.org上，该论文缘于Rob Pike向著名计算机科学家、函数语言专家、Haskell语言的设计者之一、Java泛型的设计者PHILIP WADLER发出的一次邀请，希望PHILIP WADLER帮助Go核心团队解决Go语言的泛型扩展问题：

而这篇论文则是对这次邀请的回应。这篇论文为Go语言的一个最小语法子集设计了泛型语法Featherweight Generic Go(FGG)，并成功地给出了FGG到Feighterweight Go(FG)的可行性实现的形式化证明。

该篇论文采用monomorphisation(单态)的实现，而非Java使用的擦触法(Erasure)，这样的好处之一是如果代码中没有使用任何泛型抽象，程序的运行时不会因支持泛型而承担额外的消耗。

该论文的形式化证明给Go团队带来了信心，也是的Go团队在一些语法问题上达成更广泛的一致。

• 2020.6月末，Ian Lance Taylor和Robert Griesemer在Go官方博客发表了文章《The Next Step for Generics》，介绍了Go泛型工作的最新进展。Go团队放弃了之前的技术草案，并重新编写了一个新草案。在这份新技术方案中，Go团队放弃了引入contract关键字作为泛型类型参数的约束，而采用扩展后的interface来替代contract。这样上面的Stringify函数就可以写成如下形式：

type Stringer interface {
    String() string
}

func Stringify(type T Stringer)(s []T) (ret []string) {
    ... ...
}

同时，Go团队还推出了可以在线试验Go泛型语法的playground：https://go2goplay.golang.org，这样gopher们可以直观体验新语法，并给出自己的意见反馈。

• 2020年11月的GopherCon 2020大会，Griesemer与全世界Gopher同步了Go泛型的最新进展和roadmap，在最新的技术草案版本中，小括号被方括号取代，类型参数前面的type关键字也不再需要了：

func Stringify[T Stringer](s []T) (ret []string) {
    ... ...
}

go2goplay.golang.org也支持了方括号语法，gopher可以在线体验。

下面我们就来看看Griesemer对最新Go泛型技术草案的详细讲解。

二. 类型参数(Type parameters)技术草案详解

这版草案与2019年中旬发布的草案的最大变动就是使用interface而不是contract来表达对类型参数的约束。

该版设计的主要特性：

• 类型参数(Type parameters) – 一种将类型或函数进行参数化的机制
• 约束(Constraints) – 一种表达对类型参数的约束的机制
• 类型推导(Type inference，可选)

普通函数参数列表 vs. 泛型函数的类型参数列表

我们知道，普通函数的参数列表是这样的：

(x, y aType, z anotherType)

• x, y, z是形参(parameter)的名字，即变量；
• aType，anotherType是形参的类型，即类型。

我们再来看一下类型参数(type parameter)列表：

[P, Q aConstraint, R anotherConstraint]

• P，Q，R是类型形参的名字，即类型；
• aConstraint，anotherConstraint代表类型参数的约束(constraint)，可以理解为一种元类型(meta-type，即修饰类型的类型)。

注：按惯例，类型参数(type parameter)的名字都是头母大写的。

为什么需要类型参数(type parameter)

我们先来看一下当前Go语言标准库中提供的排序方案：

// $GOROOT/src/sort/sort.go
type Interface interface {
        Len() int
        Less(i, j int) bool
        Swap(i, j int)
}

func Sort(data Interface) {
    ... ...
}

为了应用这个排序函数Sort，我们需要让被排序的类型实现sort.Interface接口，就像下面例子中这样：

type IntSlice []int

func (p IntSlice) Len() int           { return len(p) }
func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }
func (p IntSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

func main() {
        sl := IntSlice([]int{89, 14, 8, 9, 17, 56, 95, 3})
        fmt.Println(sl)
        sort.Sort(sl)
        fmt.Println(sl)
}

这真是我们想要的实现方式吗？我们真正需要的是这样的：

func Sort(list []Elem)

// 使用
var myList = []Elem{...}
Sort(myList)

解决办法：使用type parameter(类型参数或叫做参数化的类型，将类型作为参数传递)：

约束(constraints)

约束(constraint)规定了一个类型实参(type argument)必须满足的条件要求。而在泛型Go中，我们使用interface来定义约束。

如果某个类型实现了某个约束(规定的所有条件要求)，那么它就是一个合法的类型实参。

下面是一个泛型版本的Sort函数：

func Sort[Elem interface{ Less(y Elem) bool }](list []Elem)

我们看到上面函数Sort的类型形参(type parameter)Elem的约束是一个interface，这样传入的类型实参(type argument)只要实现了该接口即可。

约束的定义中也可以引用类型形参，比如下面这个泛型函数：

类型形参的声明与作用域

类型参数的作用域始于[，终于泛型函数的函数体结尾或泛型类型的声明结尾。

泛型的类型具化与类型检查

下面是一个使用泛型版本Sort函数的例子：

func Sort[Elem interface{ Less(y Elem) bool }](list []Elem)

type book struct{…}
func (x book) Less(y book) bool {…}
var bookshelf []book
…
Sort[book](bookshelf) // 泛型函数调用

上面的泛型函数调用Sort[book](bookshelf)将分成两个阶段：

1. 具化(instantiation)

形象点说，具化(instantiation)就好比一家生产“排序机器”的工厂根据要排序的对象的类型将这样的机器生产出来的过程。以上面的例子来说，整个具化过程如下：

• 工厂接单：Sort[book]，发现要排序的对象类型为book；
• 模具检查与匹配：检查book类型是否满足模具的约束要求(即是否实现了Less方法)，如满足，则将其作为类型实参替换Sort函数中的类型形参，结果为Sort[book interface{ Less(y book) bool }]；
• 生产机器：将泛型函数Sort具化为一个新函数，这里将其起名为booksort，其函数原型为func([]book)。本质上booksort := Sort[book]。

1. 调用(invocation)

一旦“排序机器”被生产出来，那么它就可以对目标对象进行排序了，这和普通的函数调用没有区别。这里就相当于调用booksort(bookshelf)，整个过程只需检查传入的函数实参(bookshelf)的类型与booksort函数原型中的形参类型([]book)是否匹配即可。

用伪代码来表述上面两个过程如下：

Sort[book](bookshelf)

<=>

具化：booksort := Sort[book]
调用：booksort(bookshelf)

泛型类型

除了函数可以携带类型参数变身为“泛型函数”外，类型也可以拥有类型参数而化身为“泛型类型”：

type Lesser[T any] interface{
   Less(y T) bool
}

上面代码中的any代表没有任何约束，等价于interface{}。

泛型类型的类型参数的声明与作用域范围

泛型类型的类型参数的声明方式如下，类型参数的作用域范围也同见下图：

用泛型类型改造Sort

用泛型类型定义一个具名的约束条件- Lesser接口类型：

type Lesser[T any] interface{
   Less(y T) bool
}

使用Lesser[T]作为约束的Sort函数可以这样写：

func Sort[Elem Lesser[Elem]](list []Elem)

注意：任何泛型函数或泛型类型在使用前都必须先“具化(instantiation)”。

我们再来看看Sort函数的内部实现：

func Sort[Elem Lesser[Elem]](list []Elem) {
    ...
    var i, j int
    ...
    if list[i].Less(List[j]) {
        ...
    }
    ...
}

• 这里的list[i]和list[j]的类型是Elem；
• Elem不是一个接口类型，它是泛型函数(Sort)的类型参数，Lesser[Elem]是作为类型参数的约束而存在的，不要与函数常规参数列表混淆。

再次强调：类型参数是一个真实的类型，不是一个接口类型(变量)，当然我们可以使用一个接口类型作为类型实参来具化一个泛型函数或泛型类型。

实参类型自动推导(Argument type inference)

我们是想要：

Sort[book](bookshelf)

还是：

Sort(bookshelf)

显然是后者。我们希望Go编译器能够根据传入的变量自动推导出类型参数的实参类型。

这样，在具化之前，如果泛型函数调用没有显式提供实参类型，那么Go编译器将进行自动实参类型推导。有了是实参类型的自动推导，大多数泛型调用的方式与常规函数调用一致。

类型列表(type lists)

到这里，约束仅限于描述方法要求。下面的函数调用仍然无法工作：

Sort([]int{1, 2, 3})

因为原生的int类型不满足Elem的约束，没有实现Less方法。虽然我们可以用下面替代方法实现整型切片的排序：

type myInt int
func (x myInt) Less(y myInt) bool { return x < y }

但这还是太麻烦了。

Go泛型扩展了interface语法，除了让interface拥有自己的方法列表外，还支持在interface中定义类型列表(type list)：

type Float interface {
   type float32, float64
}

// float32和float64都可以作为类型实参传递给Sin
func Sin[T Float](x T) T

现在，一个类型实参要想满足约束，要么它实现了约束中的所有方法，要么它或它的底层类型(underlying type)在约束的类型列表中。

下面是一个泛型函数min的声明与约束定义：

func min[T Ordered](x, y T) T ...

type Ordered interface {
    type int, int8, int16, ..., uint, uint8, uint16, ..., float32, float64, string
}

函数min的实现如下：

func min[T Ordered](x, y T) T {
    if x < y {
        return x
    }
    return y
}

• x和y的类型都是T，T类型要满足约束Ordered；
• x < y是合法的，因为在Ordered的类型列表中的每个类型都支持"<"比较。

但不同类型参数代表的却是不同类型：

func invalid[Tx, Ty Ordered](x Tx, y Ty) Tx {
    ...
    if x < y { // 不合法
        ...
    }
}

• x的类型是Tx，y的类型是Ty；
• Tx和Ty是不同类型；
• "<"需要两个操作数拥有相同的类型。

类型列表应用的典型示例

• 将[]byte和string的操作整合在一起

我们知道目前标准库中有一个bytes包和一个strings包，这两个包一个用于处理[]byte，一个则用于处理string。但使用过这两个包的gopher会发现，这两个包中大部分函数和方法是一样的，甚至处理逻辑都是一样的。有了泛型后，我们可以将对两种类型的大部分操作整合在一起，以Index函数为例：

type Bytes interface {
   type []byte, string
}

// Index returns the index of the first instance of sep
// in s, or -1 if sep is not present in s.
func Index[bytes Bytes](s, sep bytes) int

• 类型参数(type parameter)之间的关系

type Pointer[T any] interface {
    type *T
}

func f[T any, PT Pointer[T]](x T)

或

func foo[T any, PT interface{type *T}](x T)

上面是基于类型列表表述“一个类型的指针类型”约束的方案。PT的实参的类型必须是T的实参类型的指针类型。

下面这几个函数和接口很大可能会加入到标准库：

func BasicSort[Elem Ordered](list []Elem)

func Sort[Elem Lesser[Elem]](list []Elem)

type Lesser[Elem any] interface {
    Less(Elem) Elem
}

小结

关于泛型声明：

• 类型参数列表和普通参数列表相似，只是使用"[ ]"括起；
• 函数和类型都可以拥有类型参数列表；
• 使用interface表达对类型参数的约束。

关于泛型使用：

• 泛型函数和类型在使用之前必须先“具化(instantiated)”；
• 类型自动推导可实现函数隐式具化；
• 如果类型实参满足约束，那么具化才会合法。

截至2020.10月份的泛型设计草案版本，我们对以下特性设计的满意度为：

三. 结束语

“能力越大，责任越大”

• 类型参数(泛型)是Go工具集中的新成员；
• 它与语言的其他部分正交；
• 其正交性也打开了编码风格的一个新维度。

泛型引入了抽象，无用的抽象带来复杂性。请三思而后行！

示例1

func ReadAll(r io.Reader) ([]byte, error)

对比：

func ReadAll[reader io.Reader](r reader) ([]byte, error)

=> 引入泛型的版本并未解决任何实际问题(还带来了复杂难以理解的抽象)

示例2

// Drain drains any elements remaining on the channel.
func Drain[T any](c <-chan T)

// Merge merges two channels of some element type into
// a single channel.
func Merge[T any](c1, c2 <-chan T) <-chan T

=> 类型参数让以往无法实现的逻辑成为现实。

何时使用泛型

• 增强静态类型安全性
• 更高效的内存使用
• (显著的)更好的性能

泛型是带有类型检查的宏(macro)。使用宏之前请三思！

接下来的工作

Go核心团队正在着手做出一个完整的泛型实现，以便我们解决所有未解决的问题。我们继续欢迎大家的反馈！

如何抢先体验泛型：

• playground: https://go2goplay.golang.org/
• go2go命令工具：git checkout dev.go2go

注：2020.11.21日，Go开发团队技术负责人Russ Cox在golang-dev上的mail确认了Go泛型(type parameter)将在Go 1.18版本落地，即2022.2月份。

关注公众号“iamtonybai”，fgg获取论文“Featherweight Go”下载链接；发送gophercon2020获取GopherCon 2020大会技术ppt资料。

“Gopher部落”知识星球开球了！高品质首发Go技术文章，“三天”首发阅读权，每年两期Go语言发展现状分析，每天提前1小时阅读到新鲜的Gopher日报，网课、技术专栏、图书内容前瞻，六小时内必答保证等满足你关于Go语言生态的所有需求！星球首开，福利自然是少不了的！2020年年底之前，8.8折(很吉利吧^_^)加入星球，下方图片扫起来吧！

Go技术专栏“改善Go语⾔编程质量的50个有效实践”正在慕课网火热热销中！本专栏主要满足广大gopher关于Go语言进阶的需求，围绕如何写出地道且高质量Go代码给出50条有效实践建议，上线后收到一致好评！欢迎大家订阅！

我的网课“Kubernetes实战：高可用集群搭建、配置、运维与应用”在慕课网热卖中，欢迎小伙伴们订阅学习！

我爱发短信：企业级短信平台定制开发专家 https://tonybai.com/
smspush : 可部署在企业内部的定制化短信平台，三网覆盖，不惧大并发接入，可定制扩展； 短信内容你来定，不再受约束, 接口丰富，支持长短信，签名可选。2020年4月8日，中国三大电信运营商联合发布《5G消息白皮书》，51短信平台也会全新升级到“51商用消息平台”，全面支持5G RCS消息。

著名云主机服务厂商DigitalOcean发布最新的主机计划，入门级Droplet配置升级为：1 core CPU、1G内存、25G高速SSD，价格5$/月。有使用DigitalOcean需求的朋友，可以打开这个链接地址：https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 - https://github.com/bigwhite/gopherdaily

我的联系方式：

• 微博：https://weibo.com/bigwhite20xx
• 微信公众号：iamtonybai
• 博客：tonybai.com
• github: https://github.com/bigwhite

微信赞赏：

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。