标签 Windows 下的文章

Go程序员拥抱C语言简明指南

本文永久链接 – https://tonybai.com/2022/05/16/the-short-guide-of-embracing-c-lang-for-gopher

本文是为于航老师的极客时间专栏《深入C语言和程序运行原理》写的加餐文章《Tony Bai:Go程序员拥抱C语言简明指南》,这里分享给大家,尤其是那些想学习C语言的Gopher们。


你好,我是Tony Bai。

也许有同学对我比较熟悉,看过我在极客时间上的专栏《Tony Bai ·Go语言第一课》,或者是关注了我的博客。那么,作为一个Gopher,我怎么跑到这个C语言专栏做分享了呢?其实,在学习Go语言并成为一名Go程序员之前,我也曾是一名地地道道的C语言程序员。

大学毕业后,我就开始从事C语言后端服务开发工作,在电信增值领域摸爬滚打了十多年。不信的话,你可以去翻翻我的博客,数一数我发的C语言相关文章是不是比关于Go的还多。一直到近几年,我才将工作中的主力语言从C切换到了Go。不过这并不是C语言的问题,主要原因是我转换赛道了。我目前在智能网联汽车领域从事面向云原生平台的先行研发,而在云原生方面,新生代的Go语言有着更好的生态。

不过作为资深C程序员,C语言已经在我身上打下了深深的烙印。虽然Go是我现在工作中的主力语言,但我仍然会每天阅读一些C开源项目的源码,每周还会写下数百行的C代码。在一些工作场景中,特别是在我参与先行研发一些车端中间件时,C语言有着资源占用小、性能高的优势,这一点是Go目前还无法匹敌的。

正因为我有着C程序员和Go程序员的双重身份,接到这个加餐邀请时,我就想到了一个很适合聊的话题——在 Gopher(泛指Go程序员)与C语言之间“牵线搭桥”。在这门课的评论区里,我看到一些同学说,“正是因为学了Go,所以我想学好C”。如果你也对Go比较熟悉,那么恭喜你,这篇加餐简直是为你量身定制的:一个熟悉Go的程序员在学习C时需要注意的问题,还有可能会遇到的坑,我都替你总结好了。

当然,我知道还有一些对Go了解不多的同学,看到这里也别急着退出去。因为C和Go这两门语言的比较,本身就是一个很有意思的话题。今天的加餐,会涉及这两门语言的异同点,通过对C与Go语言特性的比较,你就能更好地理解“C 语言为什么设计成现在这样”。

一. C语言是现代IT工业的根基

在比较C和Go之前,先说说我推荐Gopher学C的最重要原因吧:用一句话总结,C语言在IT工业中的根基地位,是Go和其他语言目前都无法动摇的

C语言是由美国贝尔实验室的丹尼斯·里奇(Dennis Ritchie)以Unix发明人肯·汤普森(Ken Thompson)设计的B语言为基础而创建的高级编程语言。诞生于上个世纪(精确来说是1972年)的它,到今年(2022年)已到了“知天命”的半百年纪。 年纪大、设计久远一直是“C语言过时论”兴起的根源,但如果你相信这一论断,那就大错特错了。下面,我来为你分析下个中缘由。

首先,我们说说C语言本身:C语言一直在演进,从未停下过脚步

虽然C语言之父丹尼斯·里奇不幸于2011年永远地离开了我们,但C语言早已成为ANSI(美国国家标准学会)标准以及ISO/IEC(国际标准化组织和国际电工委员会)标准,因此其演进也早已由标准委员会负责。我们来简单回顾一下C语言标准的演进过程:

  • 1989年,ANSI发布了首个C语言标准,被称为C89,又称ANSI C。次年,ISO和IEC把ANSI C89标准定为C语言的国际标准(ISO/IEC 9899:1990),又称C90,它也是C语言的第一个官方版本;
  • 1999年,ISO和IEC发布了C99标准(ISO/IEC 9899:1999),它是C语言的第二个官方版本;
  • 2011年,ISO和IEC发布了C11标准(ISO/IEC 9899:2011),它是C语言的第三个官方版本;
  • 2018年,ISO和IEC发布了C18标准(ISO/IEC 9899:2018),它是C语言的第四个官方版本。
    目前,ISO/IEC标准化委员会正在致力于C2x标准的改进与制定,预计它会在2023年发布。

其次,时至今日,C语言的流行度仍然非常高

著名编程语言排行榜TIOBE的数据显示,各大编程语言年度平均排名的总位次,C语言多年来高居第一,如下图(图片来自TIOBE)所示:

这说明,无论是在过去还是现在,C语言都是一门被广泛应用的工业级编程语言。

最后,也是最重要的一点是:C语言是现代IT工业的根基,我们说C永远不会退出IT行业舞台也不为过。

如今,无论是普通消费者端的Windows、macOS、Android、苹果iOS,还是服务器端的Linux、Unix等操作系统,亦或是各个工业嵌入式领域的操作系统,其内核实现语言都是C语言。互联网时代所使用的主流Web服务器,比如 Nginx、Apache,以及主流数据库,比如MySQL、Oracle、PostgreSQL等,也都是使用C语言开发的杰作。可以说,现代人类每天都在跟由C语言实现的系统亲密接触,并且已经离不开这些系统了。回到我们程序员的日常,Git、SVN等我们时刻在用的源码版本控制软件也都是由C语言实现的。

可以说,C语言在IT工业中的根基地位,不光Go语言替代不了,C++、Rust等系统编程语言也无法动摇,而且不仅短期如此,长期来看也是如此。

总之,C语言具有紧凑、高效、移植性好、对内存的精细控制等优秀特性,这使得我们在任何时候学习它都不会过时。不过,我在这里推荐Gopher去了解和系统学习C语言,其实还有另一个原因。我们继续往下看。

二. C与Go的相通之处:Gopher拥抱C语言的“先天优势”

众所周知,Go 是在C语言的基础上衍生而来的,二者之间有很多相通之处,因此 Gopher 在学习C语言时是有“先天优势”的。接下来,我们具体看看C和Go的相通之处有哪些。

1. 简单且语法同源

Go语言以简单著称,而作为Go先祖的C语言,入门门槛同样不高:Go有25个关键字,C有32个关键字(C89标准),简洁程度在伯仲之间。C语言曾长期作为高校计算机编程教育的首选编程语言,这与C的简单也不无关系。

和Go不同的是,C语言是一个小内核、大外延的编程语言,其简单主要体现在小内核上了。这个“小内核”包括C基本语法与其标准库,我们可以快速掌握它。但需要注意的是,与Go语言“开箱即用、内容丰富”的标准库不同,C标准库非常小(在C11标准之前甚至连thread库都不包含),所以掌握“小内核”后,在LeetCode平台上刷题是没有任何问题的,但要写出某一领域的工业级生产程序,我们还有很多外延知识技能要学习,比如并发原语、操作系统的系统调用,以及进程间通信等。

C语言的这种简单很容易获得Gopher们的认同感。当年Go语言之父们在设计Go语言时,也是主要借鉴了C语言的语法。当然,这与他们深厚的C语言背景不无关系:肯·汤普森(Ken Thompson)是Unix之父,与丹尼斯·里奇共同设计了C语言;罗博·派克(Rob Pike)是贝尔实验室的资深研究员,参与了Unix系统的演进、Plan9操作系统的开发,还是UTF-8编码的发明人;罗伯特·格瑞史莫(Robert Griesemer)也是用C语言手写Java虚拟机的大神级人物。

Go的第一版编译器就是由肯·汤普森(Ken Thompson)用C语言实现的。并且,Go语言的早期版本中,C代码的比例还不小。以Go语言发布的第一个版本,Go 1.0版本为例,我们通过loccount工具对其进行分析,会得到下面的结果:

$loccount .
all          SLOC=460992  (100.00%) LLOC=193045  in 2746 files
Go           SLOC=256321  (55.60%)  LLOC=109763  in 1983 files
C            SLOC=148001  (32.10%)  LLOC=73458   in 368 files
HTML         SLOC=25080   (5.44%)   LLOC=0       in 57 files
asm          SLOC=10109   (2.19%)   LLOC=0       in 133 files
... ...

这里我们看到,在1.0版本中,C语言代码行数占据了32.10%的份额,这一份额直至Go 1.5版本实现自举后,才下降为不到1%。

我当初对Go“一见钟情”,其中一个主要原因就是Go与C语言的语法同源。相对应地,相信这种同源的语法也会让Gopher们喜欢上C语言。

2. 静态编译且基础范式相同

除了语法同源,C语言与Go语言的另一个相同点是,它们都是静态编译型语言。这意味着它们都有如下的语法特性:

  • 变量与函数都要先声明后才能使用;
  • 所有分配的内存块都要有对应的类型信息,并且在确定其类型信息后才能操作;
  • 源码需要先编译链接后才能运行。

相似的编程逻辑与构建过程,让学习C语言的Gopher可以做到无缝衔接。

除此之外,Go 和C的基础编程范式都是命令式编程(imperative programming),即面向算法过程,由程序员通过编程告诉计算机应采取的动作。然后,计算机按程序指令执行一系列流程,生成特定的结果,就像菜谱指定了厨师做蛋糕时应遵循的一系列步骤一样。

从Go看 C,没有面向对象,没有函数式编程,没有泛型(Go 1.18已加入),满眼都是类型与函数,可以说是相当亲切了。

3. 错误处理机制如出一辙

对于后端编程语言来说,错误处理机制十分重要。如果两种语言的错误处理机制不同,那么这两种语言的代码整体语法风格很可能大不相同。

在C语言中,我们通常用一个类型为整型的函数返回值作为错误状态标识,函数调用者基于值比较的方式,对这一代表错误状态的返回值进行检视。通常,当这个返回值为0时,代表函数调用成功;当这个返回值为其他值时,代表函数调用出现错误。函数调用者需根据该返回值所代表的错误状态,来决定后续执行哪条错误处理路径上的代码。

C语言这种简单的基于错误值比较的错误处理机制,让每个开发人员必须显式地去关注和处理每个错误。经过显式错误处理的代码会更为健壮,也会让开发人员对这些代码更有信心。另外,这些错误就是普通的值,我们不需要额外的语言机制去处理它们,只需利用已有的语言机制,像处理其他普通类型值那样去处理错误就可以了。这让代码更容易调试,我们也更容易针对每个错误处理的决策分支进行测试覆盖。

C语言错误处理机制的这种简单与显式,跟Go语言的设计哲学十分契合,于是Go语言设计者决定继承这种错误处理机制。因此,当Gopher们来到C语言的世界时,无需对自己的错误处理思维做出很大的改变,就可以很容易地适应C语言的风格。

三. 知己知彼,来看看C与Go的差异

虽说 Gopher 学习C语言有“先天优势”,但是不经过脚踏实地的学习与实践就想掌握和精通C语言,也是不可能的。而且,C 和Go还是有很大差异的,Gopher 们只有清楚这些差异,做到“知己知彼”,才能在学习过程中分清轻重,有的放矢。俗话说,“磨刀不误砍柴功”,下面我们就一起看看C与Go有哪些不同。

1. 设计哲学

在人类自然语言学界,有一个很著名的假说——“萨丕尔-沃夫假说”。这个假说的内容是这样的:语言影响或决定人类的思维方式。对我来说,编程语言也不仅仅是一门工具,它还影响着程序员的思维方式。每次开始学习一门新的编程语言时,我都会先了解这门编程语言的设计哲学。

每种编程语言都有自己的设计哲学,即便这门语言的设计者没有将其显式地总结出来,它也真真切切地存在,并影响着这门语言的后续演进,以及这门语言程序员的思维方式。我在《Tony Bai · Go语言第一课》专栏里,将Go语言的设计哲学总结成了5点,分别是简单、显式、组合、并发和面向工程

那么C语言的设计哲学又是什么呢?从表面上看,简单紧凑、性能至上、极致资源、全面移植,这些都可以作为C的设计哲学,但我倾向于一种更有人文气息的说法:满足和相信程序员

在这样的设计哲学下,一方面,C语言提供了几乎所有可以帮助程序员表达自己意图的语法手段,比如宏、指针与指针运算、位操作、pragma指示符、goto语句,以及跳转能力更为强大的longjmp等;另一方面,C语言对程序员的行为并没有做特别严格的限定与约束,C程序员可以利用语言提供的这些语法手段,进行天马行空的发挥:访问硬件、利用指针访问内存中的任一字节、操控任意字节中的每个位(bit)等。总之,C语言假定程序员知道他们在做什么,并选择相信程序员。

C语言给了程序员足够的自由,可以说,在C语言世界,你几乎可以“为所欲为”。但这种哲学也是有代价的,那就是你可能会犯一些莫名其妙的错误,比如悬挂指针,而这些错误很少或不可能在其他语言中出现。

这里再用一个比喻来更为形象地表达下:从Go世界到C世界,就好比在动物园中饲养已久的动物被放归到野生自然保护区,有了更多自由,但周围也暗藏着很多未曾遇到过的危险。因此,学习C语言的Gopher们要有足够的心理准备。

2. 内存管理

接下来我们来看C与Go在内存管理方面的不同。我把这一点放在第二位,是因为这两种语言在内存管理上有很大的差异,而且这一差异会给程序员的日常编码带来巨大影响。

我们知道,Go是带有垃圾回收机制(俗称GC)的静态编程语言。使用Go编程时,内存申请与释放,在栈上还是在堆上分配,以及新内存块的清零等等,这一切都是自动的,且对程序员透明。

但在C语言中,上面说的这些都是程序员的责任。手工内存管理在带来灵活性的同时,也带来了极大的风险,其中最常见的就是内存泄露(memory leak)与悬挂指针(dangling pointer)问题。

内存泄露主要指的是程序员手工在堆上分配的内存在使用后没有被释放(free),进而导致的堆内存持续增加。而悬挂指针的意思是指针指向了非法的内存地址,未初始化的指针、指针所指对象已经被释放等,都是导致悬挂指针的主要原因。针对悬挂指针进行解引用(dereference)操作将会导致运行时错误,从而导致程序异常退出的严重后果。

Go语言带有GC,而C语言不带GC,这都是由各自语言设计哲学所决定的。GC是不符合C语言的设计哲学的,因为一旦有了GC,程序员就远离了机器,程序员直面机器的需求就无法得到满足了。并且,一旦有了GC,无论是在性能上还是在资源占用上,都不可能做到极致了。

在C中,手工管理内存到底是一种什么感觉呢?作为一名有着十多年C开发经验的资深C程序员,我只能告诉你:与内存斗,其乐无穷!这是在带GC的编程语言中无法体会到的。

3. 语法形式

虽然C语言是Go的先祖,并且Go也继承了很多C语言的语法元素,但在变量/函数声明、行尾分号、代码块是否用括号括起、标识符作用域,以及控制语句语义等方面,二者仍有较大差异。因此,对Go已经很熟悉的程序员在初学C时,受之前编码习惯的影响,往往会踩一些“坑”。基于此,我总结了Gopher学习C语言时需要特别注意的几点,接下来我们具体看看。

第一,注意声明变量时类型与变量名的顺序

前面说过,Go与C都是静态编译型语言,这就要求我们在使用任何变量之前,需要先声明这个变量。但Go采用的变量声明语法颇似Pascal语言,即变量名在前,变量类型在后,这与C语言恰好相反,如下所示:

Go:

var a, b int
var p, q *int

vs.

C:
int a, b;
int *p, *q;

此外,Go支持短变量声明,并且由于短变量声明更短小,无需显式提供变量类型,Go编译器会根据赋值操作符后面的初始化表达式的结果,自动为变量赋予适当类型。因此,它成为了Gopher们喜爱和重度使用的语法。但短声明在C中却不是合法的语法元素:

int main() {
    a := 5; //  error: expected expression
    printf("a = %d\n", a);
}

不过,和上面的变量类型与变量名声明的顺序问题一样,C编译器会发现并告知我们这个问题,并不会给程序带来实质性的伤害。

第二,注意函数声明无需关键字前缀

无论是C语言还是Go语言,函数都是基本功能逻辑单元,我们也可以说C程序就是一组函数的集合。实际上,我们日常的C代码编写大多集中在实现某个函数上。

和变量一样,函数在两种语言中都需要先声明才能使用。Go语言使用func关键字作为函数声明的前缀,并且函数返回值列表放在函数声明的最后。但在C语言中,函数声明无需任何关键字作为前缀,函数只支持单一返回值,并且返回值类型放在函数名的前面,如下所示:

Go:
func Add(a, b int) int {
    return a+b
}

vs.

C:
int Add(int a, int b) {
    return a+b;
}

第三,记得加上代码行结尾的分号

我们日常编写Go代码时,极少手写分号。这是因为,Go设计者当初为了简化代码编写,提高代码可读性,选择了由编译器在词法分析阶段自动在适当位置插入分号的技术路线。如果你是一个被Go编译器惯坏了的Gopher,来到C语言的世界后,一定不要忘记代码行尾的分号。比如上面例子中的C语言Add函数实现,在return语句后面记得要手动加上分号。

第四,补上“省略”的括号

同样是出于简化代码、增加可读性的考虑,Go设计者最初就取消掉了条件分支语句(if)、选择分支语句(switch)和循环控制语句(for)中条件表达式外围的小括号:

// Go代码
func f() int {
    return 5
}
func main() {
    a := 1
    if a == 1 { // 无需小括号包裹条件表达式
        fmt.Println(a)
    }

    switch b := f(); b { // 无需小括号包裹条件表达式
    case 4:
        fmt.Println("b = 4")
    case 5:
        fmt.Println("b = 5")
    default:
        fmt.Println("b = n/a")
    }

    for i := 1; i < 10; i++ { // 无需小括号包裹循环语句的循环表达式
        a += i
    }
    fmt.Println(a)
}

这一点恰恰与C语言“背道而驰”。因此,我们在使用C语言编写代码时,务必要想着补上这些括号:

// C代码
int f() {
        return 5;
}

int main() {
    int a = 1;
    if (a == 1) { // 需用小括号包裹条件表达式
        printf("%d\n", a);
    }

    int b = f();
    switch (b) { // 需用小括号包裹条件表达式
    case 4:
        printf("b = 4\n");
        break;
    case 5:
        printf("b = 5\n");
        break;
    default:
        printf("b = n/a\n");
    }

    int i = 0;
    for (i = 1; i < 10; i++) { // 需用小括号包裹循环语句的循环表达式
        a += i;
    }
    printf("%d\n", a);
}

第五,留意C与Go导出符号的不同机制

C语言通过头文件来声明对外可见的符号,所以我们不用管符号是不是首字母大写的。但在Go中,只有首字母大写的包级变量、常量、类型、函数、方法才是可导出的,即对外部包可见。反之,首字母小写的则为包私有的,仅在包内使用。Gopher一旦习惯了这样的规则,在切换到C语言时,就会产生“心理后遗症”:遇到在其他头文件中定义的首字母小写的函数时,总以为不能直接使用。

第六,记得在switch case语句中添加break

C 语言与Go语言在选择分支语句的语义方面有所不同:C语言的 case 语句中,如果没有显式加入break语句,那么代码将向下自动掉落执行。而Go在最初设计时就重新规定了switch case的语义,默认不自动掉落(fallthrough),除非开发者显式使用fallthrough关键字。

适应了Go的switch case语句的语义后再回来写C代码,就会存在潜在的“风险”。我们来看一个例子:

// C代码:
int main() {
    int a = 1;
    switch(a) {
        case 1:printf("a = 1\n");
        case 2:printf("a = 2\n");
        case 3:printf("a = 3\n");
        default:printf("a = ?\n");
    }
}

这段代码是按Go语义编写的switch case,编译运行后得到的结果如下:

a = 1
a = 2
a = 3
a = ?

这显然不符合我们输出“a = 1”的预期。对于初学C的Gopher而言,这个问题影响还是蛮大的,因为这样编写的代码在C编译器眼中是完全合法的,但所代表的语义却完全不是开发人员想要的。这样的程序一旦流入到生产环境,其缺陷可能会引发生产故障。

一些Clint 工具可以检测出这样的问题,因此对于写C代码的Gopher,我建议在提交代码前使用lint工具对代码做一下检查。

4. 构建机制

Go与C都是静态编译型语言,它们的源码需要经过编译器和链接器处理,这个过程称为构建(build),构建后得到的可执行文件才是最终交付给用户的成果物。

和Go语言略有不同的是,C语言的构建还有一个预处理(pre-processing)阶段,预处理环节的输出才是C编译器的真正输入。C语言中的宏就是在预处理阶段展开的。不过,Go没有预处理阶段。

C语言的编译单元是一个C源文件(.c),每个编译单元在编译过程中会对应生成一个目标文件(.o/.obj),最后链接器将这些目标文件链接在一起,形成可执行文件。

而Go则是以一个包(package)为编译单元的,每个包内的源文件生成一个.o文件,一个包的所有.o文件聚合(archive)成一个.a文件,链接器将这些目标文件链接在一起形成可执行文件。

Go语言提供了统一的Go命令行工具链,且Go编译器原生支持增量构建,源码构建过程不需要Gopher手工做什么配置。但在C语言的世界中,用于构建C程序的工具有很多,主流的包括gcc/clang,以及微软平台的C编译器。这些编译器原生不支持增量构建,为了提升工程级构建的效率,避免每次都进行全量构建,我们通常会使用第三方的构建管理工具,比如make(Makefile)或CMake。考虑移植性时,我们还会使用到configure文件,用于在目标机器上收集和设置编译器所需的环境信息。

5. 依赖管理

我在前面提过,C语言仅提供了一个“小内核”。像依赖管理这类的事情,C语言本身并没有提供跟Go中的Go Module类似的,统一且相对完善的解决方案。在C语言的世界中,我们依然要靠外部工具(比如CMake)来管理第三方的依赖。

C语言的第三方依赖通常以静态库(.a)或动态共享库(.so)的形式存在。如果你的应用要使用静态链接,那就必须在系统中为C编译器提供第三方依赖的静态库文件。但在实际工作中,完全采用静态链接有时是会遇到麻烦的。这是因为,很多操作系统在默认安装时是不带开发包的,也就是说,像 libc、libpthread 这样的系统库只提供了动态共享库版本(如/lib下提供了libc的共享库libc.so.6),其静态库版本是需要自行下载、编译和安装的(如libc的静态库libc.a在安装后是放在/usr/lib下面的)。所以多数情况下,我们是将****静态、动态****两种链接方式混合在一起使用的,比如像libc这样的系统库多采用动态链接。

动态共享库通常是有版本的,并且按照一定规则安装到系统中。举个例子,一个名为libfoo的动态共享库,在安装的目录下文件集合通常是这样:

2022-03-10 12:28 libfoo.so -> libfoo.so.0.0.0*
2022-03-10 12:28 libfoo.so.0 -> libfoo.so.0.0.0*
2022-03-10 12:28 libfoo.so.0.0.0*

按惯例,每个动态共享库都有多个名字属性,包括real name、soname和linker name。下面我们来分别看下。

  • real name:实际包含共享库代码的那个文件的名字(如上面例子中的libfoo.so.0.0.0)。动态共享库的真实版本信息就在real name中,显然real name中的版本号符合语义版本规范,即major.minor.patch。当两个版本的major号一致,说明是向后兼容的两个版本;
  • soname:shared object name的缩写,也是这三个名字中最重要的一个。无论是在编译阶段还是在运行阶段,系统链接器都是通过动态共享库的soname(如上面例子中的libfoo.so.0)来唯一识别共享库的。我们看到的soname实际上是仅包含major号的共享库名字;
  • linker name:编译阶段提供给编译器的名字(如上面例子中的libfoo.so)。如果你构建的共享库的real name跟上面例子中libfoo.so.0.0.0类似,带有版本号,那么你在编译器命令中直接使用-L path -lfoo是无法让链接器找到对应的共享库文件的,除非你为libfoo.so.0.0.0提供了一个linker name(如libfoo.so,一个指向libfoo.so.0.0.0的符号链接)。linker name一般在共享库安装时手工创建。
    动态共享库有了这三个名称属性,依赖管理就有了依据。但由于在链接的时候使用的是linker name,而linker name并不带有版本号,真实版本与主机环境有关,因此要实现C应用的可重现构建还是比较难。在实践中,我们通常会使用专门的构建主机,项目组将该主机上的依赖管理起来,进而保证每次构建所使用的依赖版本是可控的。同时,应用部署的目标主机上的依赖版本也应该得到管理,避免运行时出现动态共享库版本不匹配的问题。

6. 代码风格

Go语言是历史上首次实现了代码风格全社区统一的编程语言。它基本上消除了开发人员在代码风格上的无休止的、始终无法达成一致的争论,以及不同代码风格带来的阅读、维护他人代码时的低效。gofmt工具格式化出来的代码风格已经成为Go开发者的一种共识,融入到Go语言的开发文化当中了。所以,如果你让某个Go开发者说说gofmt后的代码风格是什么样的,多数Go开发者可能说不出,因为代码会被gofmt自动变成那种风格,大家已经不再关心风格了。

而在C语言的世界,代码风格仍存争议。但经过多年的演进,以及像Go这样新兴语言的不断“教育”,C社区也在尝试进行这方面的改进,涌现出了像clang-format这样的工具。目前,虽然还没有在全社区达成一致的代码风格(由于历史原因,这很难做到),但已经可以减少很多不必要的争论。

对于正在学习C语言,并进行C编码实践的Gopher,我的建议是:不要拘泥于使用什么代码风格,先用clang-format,并确定一套风格模板就好

四. 小结

作为一名对Go跟随和研究了近十年的程序员,我深刻体会到,Go的简单性、性能和生产力使它成为了创建面向用户的应用程序和服务的理想语言。快速的迭代让团队能够快速地作出反应,以满足用户不断变化的需求,让团队可以将更多精力集中在保持灵活性上。

但Go也有缺点,比如缺少对内存以及一些低级操作的精确控制,而C语言恰好可以弥补这个缺陷。C 语言提供的更精细的控制允许更多的精确性,使得C成为低级操作的理想语言。这些低级操作不太可能发生变化,并且C相比Go还提高了性能。所以,如果你是一个有性能与低级操作需求的 Gopher ,就有充分的理由来学习C语言。

C 的优势体现在最接近底层机器的地方,而Go的优势在离用户较近的地方能得到最大发挥。当然,这并不是说两者都不能在对方的空间里工作,但这样做会增加“摩擦”。当你的需求从追求灵活性转变为注重效率时,用C重写库或服务的理由就更充分了。

总之,虽然Go和C的设计有很大的不同,但它们也有很多相似性,具备发挥兼容优势的基础。并且,当我们同时使用这二者时,就可以既有很大的灵活性,又有很好的性能,可以说是相得益彰!

五. 写在最后

今天的加餐中,我主要是基于C与Go的比较来讲解的,对于Go语言的特性并没有作详细展开。如果你还想进一步了解Go语言的设计哲学、语法特性、程序设计相关知识,欢迎来学习我在极客时间上的专栏《Tony Bai ·Go语言第一课》。在这门课里,我会用我十年Gopher的经验,带给你一条系统、完整的Go语言入门路径。

感谢你看到这里,如果今天的内容让你有所收获,欢迎把它分享给你的朋友。


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2022年,Gopher部落全面改版,将持续分享Go语言与Go应用领域的知识、技巧与实践,并增加诸多互动形式。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

我爱发短信:企业级短信平台定制开发专家 https://51smspush.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

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

究竟是什么让Go语言成为恶意软件作者的最爱

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实战:高可用集群搭建、配置、运维与应用”在慕课网热卖中,欢迎小伙伴们订阅学习!

img{512x368}

我爱发短信:企业级短信平台定制开发专家 https://51smspush.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

微信赞赏:
img{512x368}

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

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats