标签 gomodule 下的文章

Go编译的几个细节,连专家也要停下来想想

本文永久链接 – https://tonybai.com/2024/11/11/some-details-about-go-compilation

在Go开发中,编译相关的问题看似简单,但实则蕴含许多细节。有时,即使是Go专家也需要停下来,花时间思考答案或亲自验证。本文将通过几个具体问题,和大家一起探讨Go编译过程中的一些你可能之前未曾关注的细节。

注:本文示例使用的环境为Go 1.23.0、Linux Kernel 3.10.0和CentOS 7.9。

1. Go编译默认采用静态链接还是动态链接?

我们来看第一个问题:Go编译默认采用静态链接还是动态链接呢?

很多人脱口而出:动态链接,因为CGO_ENABLED默认值为1,即开启Cgo。也有些人会说:“其实Go编译器默认是静态链接的,只有在使用C语言库时才会动态链接”。那么到底哪个是正确的呢?

我们来看一个具体的示例。但在这之前,我们要承认一个事实,那就是CGO_ENABLED默认值为1,你可以通过下面命令来验证这一点:

$go env|grep CGO_ENABLED
CGO_ENABLED='1'

验证Go默认究竟是哪种链接,我们写一个hello, world的Go程序即可:

// go-compilation/main.go

package main

import "fmt"

func main() {
    fmt.Println("hello, world")
}

构建该程序:

$go build -o helloworld-default main.go

之后,我们查看一下生成的可执行文件helloworld-default的文件属性:

$file helloworld-default
helloworld-default: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
$ldd helloworld-default
   不是动态可执行文件

我们看到,虽然CGO_ENABLED=1,但默认情况下,Go构建出的helloworld程序是静态链接的(statically linked)。

那么默认情况下,Go编译器是否都会采用静态链接的方式来构建Go程序呢?我们给上面的main.go添加一行代码:

// go-compilation/main-with-os-user.go

package main

import (
    "fmt"
    _ "os/user"
)

func main() {
    fmt.Println("hello, world")
}

和之前的hello, world不同的是,这段代码多了一行包的空导入,导入的是os/user这个包。

编译这段代码,我们得到helloworld-with-os-user可执行文件。

$go build -o helloworld-with-os-user main-with-os-user.go

使用file和ldd检视文件helloworld-with-os-user:

$file helloworld-with-os-user
helloworld-with-os-user: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), not stripped

$ldd helloworld-with-os-user
    linux-vdso.so.1 =>  (0x00007ffcb8fd4000)
    libpthread.so.0 => /lib64/libpthread.so.0 (0x00007fb5d6fce000)
    libc.so.6 => /lib64/libc.so.6 (0x00007fb5d6c00000)
    /lib64/ld-linux-x86-64.so.2 (0x00007fb5d71ea000)

我们看到:一行新代码居然让helloworld从静态链接变为了动态链接,同时这也是如何编译出一个hello world版的动态链接Go程序的答案。

通过nm命令我们还可以查看Go程序依赖了哪些C库的符号:

$nm -a helloworld-with-os-user |grep " U "
                 U abort
                 U __errno_location
                 U fprintf
                 U fputc
                 U free
                 U fwrite
                 U malloc
                 U mmap
                 U munmap
                 U nanosleep
                 U pthread_attr_destroy
                 U pthread_attr_getstack
                 U pthread_attr_getstacksize
                 U pthread_attr_init
                 U pthread_cond_broadcast
                 U pthread_cond_wait
                 U pthread_create
                 U pthread_detach
                 U pthread_getattr_np
                 U pthread_key_create
                 U pthread_mutex_lock
                 U pthread_mutex_unlock
                 U pthread_self
                 U pthread_setspecific
                 U pthread_sigmask
                 U setenv
                 U sigaction
                 U sigaddset
                 U sigemptyset
                 U sigfillset
                 U sigismember
                 U stderr
                 U strerror
                 U unsetenv
                 U vfprintf

由此,我们可以得到一个结论,在默认情况下(CGO_ENABLED=1),Go会尽力使用静态链接的方式,但在某些情况下,会采用动态链接。那么究竟在哪些情况下会默认生成动态链接的程序呢?我们继续往下看。

2. 在何种情况下默认会生成动态链接的Go程序?

在以下几种情况下,Go编译器会默认(CGO_ENABLED=1)生成动态链接的可执行文件,我们逐一来看一下。

2.1 一些使用C实现的标准库包

根据上述示例,我们可以看到,在某些情况下,即使只依赖标准库,Go 仍会在CGO_ENABLED=1的情况下采用动态链接。这是因为代码依赖的标准库包使用了C版本的实现。虽然这种情况并不常见,但os/user包net包是两个典型的例子。

os/user包的示例在前面我们已经见识过了。user包允许开发者通过名称或ID查找用户账户。对于大多数Unix系统(包括linux),该包内部有两种版本的实现,用于解析用户和组ID到名称,并列出附加组ID。一种是用纯Go编写,解析/etc/passwd和/etc/group文件。另一种是基于cgo的,依赖于标准C库(libc)中的例程,如getpwuid_r、getgrnam_r和getgrouplist。当cgo可用(CGO_ENABLED=1),并且特定平台的libc实现了所需的例程时,将使用基于cgo的(libc支持的)代码,即采用动态链接方式。

同样,net包在名称解析(Name Resolution,即域名或主机名对应IP查找)上针对大多数Unix系统也有两个版本的实现:一个是纯Go版本,另一个是基于C的版本。C版本会在cgo可用且特定平台实现了相关C函数(比如getaddrinfo和getnameinfo等)时使用。

下面是一个简单的使用net包并采用动态链接的示例:

// go-compilation/main-with-net.go

package main

import (
    "fmt"
    _ "net"
)

func main() {
    fmt.Println("hello, world")
}

编译后,我们查看一下文件属性:

$go build -o helloworld-with-net main-with-net.go 

$file helloworld-with-net
helloworld-with-net: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), not stripped

$ldd helloworld-with-net
    linux-vdso.so.1 =>  (0x00007ffd75dfd000)
    libresolv.so.2 => /lib64/libresolv.so.2 (0x00007fdda2cf9000)
    libpthread.so.0 => /lib64/libpthread.so.0 (0x00007fdda2add000)
    libc.so.6 => /lib64/libc.so.6 (0x00007fdda270f000)
    /lib64/ld-linux-x86-64.so.2 (0x00007fdda2f13000)

我们看到C版本实现依赖了libresolv.so这个用于名称解析的C库。

由此可得,当Go在默认cgo开启时,一旦依赖了标准库中拥有C版本实现的包,比如os/user、net等,Go编译器会采用动态链接的方式编译Go可执行程序。

2.2 显式使用cgo调用外部C程序

如果使用cgo与外部C代码交互,那么生成的可执行文件必然会包含动态链接。下面我们来看一个调用cgo的简单示例。

首先,建立一个简单的C lib:

// go-compilation/my-c-lib

$tree my-c-lib
my-c-lib
├── Makefile
├── mylib.c
└── mylib.h

// go-compilation/my-c-lib/Makefile

.PHONY:  all static

all:
        gcc -c -fPIC -o mylib.o mylib.c
        gcc -shared -o libmylib.so mylib.o
static:
        gcc -c -fPIC -o mylib.o mylib.c
        ar rcs libmylib.a mylib.o

// go-compilation/my-c-lib/mylib.h

#ifndef MYLIB_H
#define MYLIB_H

void hello();
int add(int a, int b);

#endif // MYLIB_H

// go-compilation/my-c-lib/mylib.c

#include <stdio.h>

void hello() {
    printf("Hello from C!\n");
}

int add(int a, int b) {
    return a + b;
}

执行make all构建出动态链接库libmylib.so!接下来,我们编写一个Go程序通过cgo调用libmylib.so中:

// go-compilation/main-with-call-myclib.go 

package main

/*
#cgo CFLAGS: -I ./my-c-lib
#cgo LDFLAGS: -L ./my-c-lib -lmylib
#include "mylib.h"
*/
import "C"
import "fmt"

func main() {
    // 调用 C 函数
    C.hello()

    // 调用 C 中的加法函数
    result := C.add(3, 4)
    fmt.Printf("Result of addition: %d\n", result)
}

编译该源码:

$go build -o helloworld-with-call-myclib main-with-call-myclib.go

通过ldd可以看到,可执行文件helloworld-with-call-myclib是动态链接的,并依赖libmylib.so:

$ldd helloworld-with-call-myclib
    linux-vdso.so.1 =>  (0x00007ffcc39d8000)
    libmylib.so => not found
    libpthread.so.0 => /lib64/libpthread.so.0 (0x00007f7166df5000)
    libc.so.6 => /lib64/libc.so.6 (0x00007f7166a27000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f7167011000)

设置LD_LIBRARY_PATH(为了让程序找到libmylib.so)并运行可执行文件helloworld-with-call-myclib:

$ LD_LIBRARY_PATH=./my-c-lib:$LD_LIBRARY_PATH ./helloworld-with-call-myclib
Hello from C!
Result of addition: 7

2.3 使用了依赖cgo的第三方包

在日常开发中,我们经常依赖一些第三方包,有些时候这些第三方包依赖cgo,比如mattn/go-sqlite3。下面就是一个依赖go-sqlite3包的示例:

// go-compilation/go-sqlite3/main.go
package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/mattn/go-sqlite3"
)

func main() {
    // 打开数据库(如果不存在,则创建)
    db, err := sql.Open("sqlite3", "./test.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 创建表
    sqlStmt := `CREATE TABLE IF NOT EXISTS user (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT);`
    _, err = db.Exec(sqlStmt)
    if err != nil {
        log.Fatalf("%q: %s\n", err, sqlStmt)
    }

    // 插入数据
    _, err = db.Exec(`INSERT INTO user (name) VALUES (?)`, "Alice")
    if err != nil {
        log.Fatal(err)
    }

    // 查询数据
    rows, err := db.Query(`SELECT id, name FROM user;`)
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    for rows.Next() {
        var id int
        var name string
        err = rows.Scan(&id, &name)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("%d: %s\n", id, name)
    }

    // 检查查询中的错误
    if err = rows.Err(); err != nil {
        log.Fatal(err)
    }
}

编译和运行该源码:

$go build demo
$ldd demo
    linux-vdso.so.1 =>  (0x00007ffe23d8e000)
    libdl.so.2 => /lib64/libdl.so.2 (0x00007faf0ddef000)
    libpthread.so.0 => /lib64/libpthread.so.0 (0x00007faf0dbd3000)
    libc.so.6 => /lib64/libc.so.6 (0x00007faf0d805000)
    /lib64/ld-linux-x86-64.so.2 (0x00007faf0dff3000)
$./demo
1: Alice

到这里,有些读者可能会问一个问题:如果需要在上述依赖场景中生成静态链接的Go程序,该怎么做呢?接下来,我们就来看看这个问题的解决细节。

3. 如何在上述情况下实现静态链接?

到这里是不是有些烧脑了啊!我们针对上一节的三种情况,分别对应来看一下静态编译的方案。

3.1 仅依赖标准包

在前面我们说过,之所以在使用os/user、net包时会在默认情况下采用动态链接,是因为Go使用了这两个包对应功能的C版实现,如果要做静态编译,让Go编译器选择它们的纯Go版实现即可。那我们仅需要关闭CGO即可,以依赖标准库os/user为例:

$CGO_ENABLED=0 go build -o helloworld-with-os-user-static main-with-os-user.go
$file helloworld-with-os-user-static
helloworld-with-os-user-static: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
$ldd helloworld-with-os-user-static
    不是动态可执行文件

3.2 使用cgo调用外部c程序(静态链接)

对于依赖cgo调用外部c的程序,我们要使用静态链接就必须要求外部c库提供静态库,因此,我们需要my-c-lib提供一份libmylib.a,这通过下面命令可以实现(或执行make static):

$gcc -c -fPIC -o mylib.o mylib.c
$ar rcs libmylib.a mylib.o

有了libmylib.a后,我们还要让Go程序静态链接该.a文件,于是我们需要修改一下Go源码中cgo链接的flag,加上静态链接的选项:

// go-compilation/main-with-call-myclib-static.go
... ...
#cgo LDFLAGS: -static -L my-c-lib -lmylib
... ...

编译链接并查看一下文件属性:

$go build -o helloworld-with-call-myclib-static main-with-call-myclib-static.go

$file helloworld-with-call-myclib-static
helloworld-with-call-myclib-static: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=b3da3ed817d0d04230460069b048cab5f5bfc3b9, not stripped

我们得到了预期的结果!

3.3 依赖使用cgo的外部go包(静态链接)

最麻烦的是这类情况,要想实现静态链接,我们需要找出外部go依赖的所有c库的.a文件(静态共享库)。以我们的go-sqlite3示例为例,go-sqlite3是sqlite库的go binding,它依赖sqlite库,同时所有第三方c库都依赖libc,我们还要准备一份libc的.a文件,下面我们就先安装这些:

$yum install -y gcc glibc-static sqlite-devel
... ...

已安装:
  sqlite-devel.x86_64 0:3.7.17-8.el7_7.1                                                                                          

更新完毕:
  glibc-static.x86_64 0:2.17-326.el7_9.3

接下来,我们就来以静态链接的方式在go-compilation/go-sqlite3-static下编译一下:

$go build -tags 'sqlite_omit_load_extension' -ldflags '-linkmode external -extldflags "-static"' demo

$file ./demo
./demo: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=c779f5c3eaa945d916de059b56d94c23974ce61c, not stripped

这里命令行中的-tags ‘sqlite_omit_load_extension’用于禁用SQLite3的动态加载功能,确保更好的静态链接兼容性。而-ldflags ‘-linkmode external -extldflags “-static”‘的含义是使用外部链接器(比如gcc linker),并强制静态链接所有库。

我们再看完略烧脑的几个细节后,再来看一个略轻松的话题。

4. Go编译出的可执行文件过大,能优化吗?

Go编译出的二进制文件一般较大,一个简单的“Hello World”程序通常在2MB左右:

$ls -lh helloworld-default
-rwxr-xr-x 1 root root 2.1M 11月  3 10:39 helloworld-default

这一方面是因为Go将整个runtime都编译到可执行文件中了,另一方面也是因为Go静态编译所致。那么在默认情况下,Go二进制文件的大小还有优化空间么?方法不多,有两种可以尝试:

  • 去除符号表和调试信息

在编译时使用-ldflags=”-s -w”标志可以去除符号表和调试符号,其中-s用于去掉符号表和调试信息,-w用于去掉DWARF调试信息,这样能显著减小文件体积。以helloworld为例,可执行文件的size减少了近四成:

$go build -ldflags="-s -w" -o helloworld-default-nosym main.go
$ls -l
-rwxr-xr-x 1 root root 2124504 11月  3 10:39 helloworld-default
-rwxr-xr-x 1 root root 1384600 11月  3 13:34 helloworld-default-nosym
  • 使用tinygo

TinyGo是一个Go语言的编译器,它专为资源受限的环境而设计,例如微控制器、WebAssembly和其他嵌入式设备。TinyGo的目标是提供一个轻量级的、能在小型设备上运行的Go运行时,同时尽可能支持Go语言的特性。tinygo的一大优点就是生成的二进制文件通常比标准Go编译器生成的文件小得多:

$tinygo build -o helloworld-tinygo main.go
$ls -l
总用量 2728
-rwxr-xr-x  1 root root 2128909 11月  5 05:43 helloworld-default*
-rwxr-xr-x  1 root root  647600 11月  5 05:45 helloworld-tinygo*

我们看到:tinygo生成的可执行文件的size仅是原来的30%。

注:虽然TinyGo在特定场景(如IoT和嵌入式开发)中非常有用,但在常规服务器环境中,由于生态系统兼容性、性能、调试支持等方面的限制,可能并不是最佳选择。对于需要高并发、复杂功能和良好调试支持的应用,标准Go仍然是更合适的选择。

注:这里使用的tinygo为0.34.0版本。

5. 未使用的符号是否会被编译到Go二进制文件中?

到这里,相信读者心中也都会萦绕一些问题:到底哪些符号被编译到最终的Go二进制文件中了呢?未使用的符号是否会被编译到Go二进制文件中吗?在这一小节中,我们就来探索一下。

出于对Go的了解,我们已经知道无论是GOPATH时代,还是Go module时代,Go的编译单元始终是包(package),一个包(无论包中包含多少个Go源文件)都会作为一个编译单元被编译为一个目标文件(.a),然后Go链接器会将多个目标文件链接在一起生成可执行文件,因此如果一个包被依赖,那么它就会进入到Go二进制文件中,它内部的符号也会进入到Go二进制文件中。

那么问题来了!是否被依赖包中的所有符号都会被放到最终的可执行文件中呢?我们以最简单的helloworld-default为例,它依赖fmt包,并调用了fmt包的Println函数,我们看看Println这个符号是否会出现在最终的可执行文件中:

$nm -a helloworld-default | grep "Println"
000000000048eba0 T fmt.(*pp).doPrintln

居然没有!我们初步怀疑是inline优化在作祟。接下来,关闭优化再来试试:

$go build -o helloworld-default-noinline -gcflags='-l -N' main.go

$nm -a helloworld-default-noinline | grep "Println"
000000000048ec00 T fmt.(*pp).doPrintln
0000000000489ee0 T fmt.Println

看来的确如此!不过当使用”fmt.”去过滤helloworld-default-noinline的所有符号时,我们发现fmt包的一些常见的符号并未包含在其中,比如Printf、Fprintf、Scanf等。

这是因为Go编译器的一个重要特性:死码消除(dead code elimination),即编译器会将未使用的代码和数据从最终的二进制文件中剔除。

我们再来继续探讨一个衍生问题:如果Go源码使用空导入方式导入了一个包,那么这个包是否会被编译到Go二进制文件中呢?其实道理是一样的,如果用到了里面的符号,就会存在,否则不会。

以空导入os/user为例,即便在CGO_ENABLED=0的情况下,因为没有使用os/user中的任何符号,在最终的二进制文件中也不会包含user包:

$CGO_ENABLED=0 go build -o helloworld-with-os-user-noinline -gcflags='-l -N' main-with-os-user.go
[root@iZ2ze18rmx2avqb5xgb4omZ helloworld]# nm -a helloworld-with-os-user-noinline |grep user
0000000000551ac0 B runtime.userArenaState

但是如果是带有init函数的包,且init函数中调用了同包其他符号的情况呢?我们以expvar包为例看一下:

// go-compilation/main-with-expvar.go

package main

import (
    _ "expvar"
    "fmt"
)

func main() {
    fmt.Println("hello, world")
}

编译并查看一下其中的符号:

$go build -o helloworld-with-expvar-noinline -gcflags='-l -N' main-with-expvar.go
$nm -a helloworld-with-expvar-noinline|grep expvar
0000000000556480 T expvar.appendJSONQuote
00000000005562e0 T expvar.cmdline
00000000005561c0 T expvar.expvarHandler
00000000005568e0 T expvar.(*Func).String
0000000000555ee0 T expvar.Func.String
00000000005563a0 T expvar.init.0
00000000006e0560 D expvar..inittask
0000000000704550 d expvar..interfaceSwitch.0
... ...

除此之外,如果一个包即便没有init函数,但有需要初始化的全局变量,比如crypto包的hashes:

// $GOROOT/src/crypto/crypto.go
var hashes = make([]func() hash.Hash, maxHash)

crypto包的相关如何也会进入最终的可执行文件中,大家自己动手不妨试试。下面是我得到的一些输出:

$go build -o helloworld-with-crypto-noinline -gcflags='-l -N' main-with-crypto.go
$nm -a helloworld-with-crypto-noinline|grep crypto
00000000005517b0 B crypto.hashes
000000000048ee60 T crypto.init
0000000000547280 D crypto..inittask

有人会问:os/user包也有一些全局变量啊,为什么这些符号没有被包含在可执行文件中呢?比如:

// $GOROOT/src/os/user/user.go
var (
    userImplemented      = true
    groupImplemented     = true
    groupListImplemented = true
)

这就要涉及Go包初始化的逻辑了。我们看到crypto包包含在可执行文件中的符号中有crypto.init和crypto..inittask这两个符号,显然这不是crypto包代码中的符号,而是Go编译器为crypto包自动生成的init函数和inittask结构。

Go编译器会为每个包生成一个init函数,即使包中没有显式定义init函数,同时每个包都会有一个inittask结构,用于运行时的包初始化系统。当然这么说也不足够精确,如果一个包没有init函数、需要初始化的全局变量或其他需要运行时初始化的内容,则编译器不会为其生成init函数和inittask。比如上面的os/user包。

os/user包确实有上述全局变量的定义,但是这些变量是在编译期就可以确定值的常量布尔值,而且未被包外引用或在包内用于影响控制流。Go编译器足够智能,能够判断出这些初始化是”无副作用的”,不需要在运行时进行初始化。只有真正需要运行时初始化的包才会生成init和inittask。这也解释了为什么空导入os/user包时没有相关的init和inittask符号,而crypto、expvar包有的init.0和inittask符号。

6. 如何快速判断Go项目是否依赖cgo?

在使用开源Go项目时,我们经常会遇到项目文档中没有明确说明是否依赖Cgo的情况。这种情况下,如果我们需要在特定环境(比如CGO_ENABLED=0)下使用该项目,就需要事先判断项目是否依赖Cgo,有些时候还要快速地给出判断。

那究竟是否可以做到这种快速判断呢?我们先来看看一些常见的作法。

第一类作法是源码层面的静态分析。最直接的方式是检查源码中是否存在import “C”语句,这种引入方式是CGO使用的显著标志。

// 在项目根目录中执行
$grep -rn 'import "C"' .

这个命令会递归搜索当前目录下所有文件,显示包含import “C”的行号和文件路径,帮助快速定位CGO的使用位置。

此外,CGO项目通常包含特殊的编译指令,这些指令以注释形式出现在源码中,比如前面见识过的#cgo CFLAGS、#cgo LDFLAGS等,通过对这些编译指令的检测,同样可以来判断项目是否依赖CGO。

不过第一类作法并不能查找出Go项目的依赖包是否依赖cgo。而找出直接依赖或间接依赖是否依赖cgo,我们需要工具帮忙,比如使用Go工具链提供的命令分析项目依赖:

$go list -deps -f '{{.ImportPath}}: {{.CgoFiles}}' ./...  | grep -v '\[\]'

其中ImportPath是依赖包的导入路径,而CgoFiles则是依赖中包含import “C”的Go源文件。我们以go-sqlite3那个依赖cgo的示例来验证一下:

// cd go-compilation/go-sqlite3

$go list -deps -f '{{.ImportPath}}: {{.CgoFiles}}' ./...  | grep -v '\[\]'
runtime/cgo: [cgo.go]
github.com/mattn/go-sqlite3: [backup.go callback.go error.go sqlite3.go sqlite3_context.go sqlite3_load_extension.go sqlite3_opt_serialize.go sqlite3_opt_userauth_omit.go sqlite3_other.go sqlite3_type.go]

用空导入os/user的示例再来看一下:

$go list -deps -f '{{.ImportPath}}: {{.CgoFiles}}'  main-with-os-user.go | grep -v '\[\]'
runtime/cgo: [cgo.go]
os/user: [cgo_lookup_cgo.go getgrouplist_unix.go]

我们知道os/user有纯go和C版本两个实现,因此上述判断只能说“对了一半”,当我关闭CGO_ENABLED时,Go编译器不会使用基于cgo的C版实现。

那是否在禁用cgo的前提下对源码进行一次编译便能验证项目是否对cgo有依赖呢?这样做显然谈不上是一种“快速”的方法,那是否有效呢?我们来对上面的go-sqlite3项目做一个测试,我们在关闭CGO_ENABLED时,编译一下该示例:

// cd go-compilation/go-sqlite3
$ CGO_ENABLED=0 go build demo

我们看到,Go编译器并未报错!似乎该项目不需要cgo! 但真的是这样吗?我们运行一下编译后的demo可执行文件:

$ ./demo
2024/11/03 22:10:36 "Binary was compiled with 'CGO_ENABLED=0', go-sqlite3 requires cgo to work. This is a stub": CREATE TABLE IF NOT EXISTS user (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT);

我们看到成功编译出来的程序居然出现运行时错误,提示需要cgo!

到这里,没有一种方法可以快速、精确的给出项目是否依赖cgo的判断。也许判断Go项目是否依赖CGO并没有捷径,需要从源码分析、依赖检查和构建测试等多个维度进行。

7. 小结

在本文中,我们深入探讨了Go语言编译过程中的几个重要细节,尤其是在静态链接和动态链接的选择上。通过具体示例,我们了解到:

  • 默认链接方式:尽管CGO_ENABLED默认值为1,Go编译器在大多数情况下会采用静态链接,只有在依赖特定的C库或标准库包时,才会切换到动态链接。

  • 动态链接的条件:我们讨论了几种情况下Go会默认生成动态链接的可执行文件,包括依赖使用C实现的标准库包、显式使用cgo调用外部C程序,以及使用依赖cgo的第三方包。

  • 实现静态链接:对于需要动态链接的场景,我们也提供了将其转为静态链接的解决方案,包括关闭CGO、使用静态库,以及处理依赖cgo的外部包的静态链接问题。

  • 二进制文件优化:我们还介绍了如何通过去除符号表和使用TinyGo等方法来优化生成的Go二进制文件的大小,以满足不同场景下的需求。

  • 符号编译与死码消除:最后,我们探讨了未使用的符号是否会被编译到最终的二进制文件中,并解释了Go编译器的死码消除机制。

通过这些细节探讨,我希望能够帮助大家更好地理解Go编译的复杂性,并在实际开发中做出更明智的选择,亦能在面对Go编译相关问题时,提供有效的解决方案。

本文涉及的源码可以在这里下载。


Gopher部落知识星球在2024年将继续致力于打造一个高品质的Go语言学习和交流平台。我们将继续提供优质的Go技术文章首发和阅读体验。同时,我们也会加强代码质量和最佳实践的分享,包括如何编写简洁、可读、可测试的Go代码。此外,我们还会加强星友之间的交流和互动。欢迎大家踊跃提问,分享心得,讨论技术。我会在第一时间进行解答和交流。我衷心希望Gopher部落可以成为大家学习、进步、交流的港湾。让我相聚在Gopher部落,享受coding的快乐! 欢迎大家踊跃加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

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

Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite
  • Gopher Daily归档 – https://github.com/bigwhite/gopherdaily
  • Gopher Daily Feed订阅 – https://gopherdaily.tonybai.com/feed

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

Go开发者的密码学导航:crypto库使用指南

本文永久链接 – https://tonybai.com/2024/10/19/go-crypto-package-design-deep-dive

Go号称“开箱即用”,这与其标准库的丰富功能和高质量是分不开的。而在Go标准库中,crypto库(包括crypto包、crypto目录下相关包以及golang.org/x/crypto下的补充包)又是Go社区最值得称道的Go库之一。

crypto库由Go核心团队维护,确保了最高级别的安全标准和及时的漏洞修复,为开发者提供了可靠的安全保障。crypto还涵盖了从基础的对称加密到复杂的非对称加密,以及各种哈希函数和数字签名算法等广泛的加解密算法支持,以满足Go开发者的各种需求为目的,而不是与其他密码学工具包竞争。此外,crypto库还经过精心优化,能够在不同硬件平台上尽可能地保证高效的执行性能。值得一提的是,crypto库还提供了统一的API设计,使得不同加密算法的使用方式保持一致,也降低了开发者的学习成本。

可以说Go crypto库Go生态中密码学功能的核心,它为Go开发者提供了一套全面、安全、保持现代化提供安全默认值易于使用的密码学工具,使得在Go应用程序中实现各种密码学功能需求时变得简单而可靠。

不过要理解并得心应手的使用crypto库中的相关密码学包仍然并非易事,这是因为密码学涉及数学、密码分析、计算机安全等多个学科,概念多,算法也十分复杂,而大多程序员对密码学的了解又多停留在使用层面,缺乏对其原理和底层机制的深入认知,甚至连每个包的用途都不甚了解。这导致很多开发者浏览了crypto相关包之后,甚至不知道该使用哪个包。

所以在这篇文章中,我想为Go开发者建立一张crypto库的“地图”,这张“地图”将帮助我们从宏观角度理解crypto库的结构,帮助大家快速精准选择正确的包。并且通过对crypto相关包设计的理解,轻松掌握crypto相关包的使用模式。

注:Go标准库crypto库的第一任负责人是Adam Langley(agl),他开创了Go crypto库,他在招募和培养了Filippo Valsorda后离开了Go项目,后者成为了Go crypto的负责人。Filippo在Go项目工作若干年后,把负责人交给了Roland Shoemaker,即现任Go团队安全组的负责人。当然Shoemaker也是Filippo招募到Go团队中的。

下面我们首先来看看Go crypto库的“整体架构”。

1. 标准库crypto与golang.org/x/crypto

Go的密码学功能(即我们统一称的crypto库)分为两个主要部分:标准库的crypto相关包和扩展库golang.org/x/crypto。这种分离设计有其特定的目的和优势:

Go标准库的crypto相关包,包含了最基础、最稳定和使用最广泛的密码学算法。这些算法实现经过Go团队的严格审查,保证了长期稳定性和向后兼容性。同时,这些包是随Go安装包分发的,使用时再无需引入额外的依赖。

而golang.org/x/crypto则号称是Go标准库crypto相关包的补充库,虽然它同样由Go团队维护,但由于不是标准库,它可以包含更多实验性或较新的密码学算法及实现,并可以更快速的迭代和更新。这样它也可以成为Go标准库中一些crypto相关包的“孵化器”,就像当年golang.org/x/net/context提升为标准库context一样。

同时golang.org/x/crypto也是Go标准库依赖的为数极少的外部包之一。比如,下面是Go 1.23.0标准库go.mod文件的内容:

module std

go 1.23

require (
    golang.org/x/crypto v0.23.1-0.20240603234054-0b431c7de36a
    golang.org/x/net v0.25.1-0.20240603202750-6249541f2a6c
)

require (
    golang.org/x/sys v0.22.0 // indirect
    golang.org/x/text v0.16.0 // indirect
)

我们看到Go标准库依赖特定版本的golang.org/x/crypto模块。

与标准库不同的是,如果你要使用golang.org/x/crypto模块中的密码学包,你就需要单独引入项目依赖。此外,golang.org/x 下的包通常被视为实验性或扩展包,因此它们并不严格遵循Go1兼容性承诺。换句话说,这些包在API稳定性上没有与标准库相同的保证,可能会有非向后兼容的更改。

综上,我们看到Go标准库crypto与golang.org/x/crypto的这种分离策略,允许Go团队在保持标准库稳定性的同时,也能够灵活地引入新的密码学算法和技术。

接下来,我们来看看crypto库的整体结构设计原则,这些原则对理解整个crypto库大有裨益。

2. 整体结构设计原则

Go的crypto库整体上的结构设计遵循了几个原则:

2.1 统一接口和类型抽象

首先是统一接口和类型抽象,这在最顶层的crypto包中就能充分体现。

crypto包定义了一个Hash类型和一个创建具体哈希实现的方法。这个设计允许统一管理不同的哈希算法,同时保持了良好的可扩展性:

// $GOROOT/src/crypto/crypto.go

type Hash uint

// New returns a new hash.Hash calculating the given hash function. New panics
// if the hash function is not linked into the binary.
func (h Hash) New() hash.Hash {
    if h > 0 && h < maxHash {
        f := hashes[h]
        if f != nil {
            return f()
        }
    }
    panic("crypto: requested hash function #" + strconv.Itoa(int(h)) + " is unavailable")
}

// HashFunc simply returns the value of h so that [Hash] implements [SignerOpts].
func (h Hash) HashFunc() Hash {
    return h
}

// RegisterHash registers a function that returns a new instance of the given
// hash function. This is intended to be called from the init function in
// packages that implement hash functions.
func RegisterHash(h Hash, f func() hash.Hash) {
    if h >= maxHash {
        panic("crypto: RegisterHash of unknown hash function")
    }
    hashes[h] = f
}

var hashes = make([]func() hash.Hash, maxHash)

Hash类型作为一个统一的标识符,用于表示不同的哈希算法。New方法则“像一个工厂方法”,用于创建具体的哈希实现。新的哈希算法可以很容易地添加到这个系统中,只需定义一个新的常量并提供相应的实现,并将实现通过RegisterHash注册到hashes中即可。下面是一个使用sha256算法的示例(仅做演示,并非惯例写法):

package main

import (
    "crypto"
    _ "crypto/sha256" // register h256 to hashes
)

func main() {
    ht := crypto.SHA256
    h := ht.New()
    h.Write([]byte("hello world"))
    sum := h.Sum(nil)
    println(sum)
}

注:也许是早期标准库的设计问题,hash接口目前没有放到crypto下面,而是在标准库顶层目录下。crypto库中的hash实现通过New方法返回真正的hash.Hash实现。

crypto包还定义了几个关键接口,这些接口被各个子包实现,从而实现了高度的可扩展性和互操作性,比如下面的Signer、SignerOpts、Decrypter接口:

// Signer is an interface for an opaque private key that can be used for
// signing operations. For example, an RSA key kept in a hardware module.
type Signer interface {
    Public() PublicKey
    Sign(rand io.Reader, digest []byte, opts SignerOpts) (signature []byte, err error)
}

// SignerOpts contains options for signing with a [Signer].
type SignerOpts interface {
    HashFunc() Hash
}

// Decrypter is an interface for an opaque private key that can be used for
// asymmetric decryption operations. An example would be an RSA key
// kept in a hardware module.
type Decrypter interface {
    Public() PublicKey
    Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error)
}

以Signer接口为例,这个Signer接口为不同的签名算法(如RSA、ECDSA、Ed25519等)提供了一个统一的抽象。下面是一个使用统一Signer接口但不同Signer实现的示例:

func signData(signer crypto.Signer, data []byte) ([]byte, error) {
    hash := crypto.SHA256
    h := hash.New()
    h.Write(data)
    digest := h.Sum(nil)

    return signer.Sign(rand.Reader, digest, hash)
}

func main() {
    rsaKey, _ := rsa.GenerateKey(rand.Reader, 2048)
    signature, _ := signData(rsaKey, []byte("Hello, World!"))
    println(signature)

    ecdsaKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    signature, _ = signData(ecdsaKey, []byte("Hello, World!"))
    println(signature)
}

在这个例子中,我们看到了如何使用相同的signData函数来处理不同类型的签名算法,这体现了统一接口带来的灵活性和一致性。

在crypto目录下的各个子包中,上述原则也有很好的体现,比如cipher包就定义了Block、Stream等接口,然后aes、des等对称加密包也都提供了创建实现了这些接口的类型的函数,比如aes.NewCipher以及des.NewCipher等。

2.2 模块化

每个子包专注于特定的功能,这种模块化设计使得每个包都相对独立,便于维护和使用。以aes包和des包为例:

// crypto/aes/cipher.go
func NewCipher(key []byte) (cipher.Block, error) {
    // AES specific implementation
}

// crypto/des/cipher.go
func NewCipher(key []byte) (cipher.Block, error) {
    // DES specific implementation
}

这两个包都实现了相同的NewCipher函数,但内部实现完全不同,专注于各自的加密算法。

2.3 易用性与灵活性的平衡

Go crypto库中的很多包既提供了可以满足大多数常见用例的需求、易用性很好的高级API,同时也提供了更灵活的低级API,允许开发者在需要时进行更精细的控制或自定义实现。

让我们以SHA256哈希函数为例来说明这一点:

// 高级API
func highLevelAPI(data []byte) [32]byte {
    return sha256.Sum256(data)
}

// 低级API
func lowLevelAPI(data []byte) [32]byte {
    h := sha256.New()
    h.Write(data)
    return *(*[32]byte)(h.Sum(nil))
}

func main() {
    fmt.Println(lowLevelAPI([]byte("hello world")))
    fmt.Println(highLevelAPI([]byte("hello world")))
}

在这个例子中,sha256.Sum256是高级API,而lowLevelAPI中使用的那套逻辑则是对低级API的组合以实现Sum256功能。

2.4 可扩展性

基于“统一接口和类型抽象”原则设计的crypto库可以让用户轻松地集成自己的实现或第三方库,这种可扩展性便于我们添加新的算法或功能,而不影响现有结构。 比如,我们可以像这下面这样实现自定义的cipher.Block:

type MyCustomCipher struct {
    // ...
}

func (c *MyCustomCipher) BlockSize() int {
    // ...
}

func (c *MyCustomCipher) Encrypt(dst, src []byte) {
    // ...
}

func (c *MyCustomCipher) Decrypt(dst, src []byte) {
    // ...
}

之后,这个自定义的cipher.Block实现便可以直接用在标准库提供的分组密码模式中。

作为crypto库的扩展和实验库,golang.org/x/crypto也遵循了与标准库crypto相关包一致的设计原则,这里就不举例说明了。

有了上述对crypto库的整体设计原则的认知后,我们再来看一下Go标准库crypto目录下的子包结构,了解了这个结果,你就会像拥有了crypto库的“导航”,可以顺利方便地找到你想要的密码学包了。

3. 子包结构概览

众所周知,Go标准库crypto目录下不仅有crypto包,还有众多种类的密码学包,下面这张示意图对这些包进行了简单分类:

下面我会按照图中的类别对各个包做简单介绍,包括功能、用途、简单的示例以及是否推荐使用。密码学一直在发展,很多算法因为不再“牢不可破”而逐渐不再被推荐使用。但Go为了保证Go1兼容性,这些包依赖留在了Go标准库中。

我们自上而下,先从哈希函数开始。

3.1 哈希函数

3.1.1 md5

  • 功能:实现MD5哈希算法
  • 用途:生成数据的128位哈希值
  • 示例:
import "crypto/md5"
hash := md5.Sum([]byte("hello world"))
  • 使用建议:不推荐用于安全相关用途,因为MD5已被证明不够安全。

3.1.2 sha1

  • 功能:实现SHA-1哈希算法
  • 用途:生成数据的160位哈希值
  • 示例:
import "crypto/sha1"
hash := sha1.Sum([]byte("hello world"))
  • 使用建议:不推荐用于安全相关用途,因为SHA-1已被证明存在碰撞风险。

3.1.3 sha256

  • 功能:实现SHA-256哈希算法
  • 用途:生成数据的256位哈希值
  • 示例:
import "crypto/sha256"
hash := sha256.Sum256([]byte("hello world"))
  • 使用建议:推荐使用,安全性高。

3.1.4 sha512

  • 功能:实现SHA-512哈希算法
  • 用途:生成数据的512位哈希值
  • 示例:
import "crypto/sha512"
hash := sha512.Sum512([]byte("hello world"))
  • 使用建议:推荐使用,安全性很高。

3.2 加密和解密

3.2.1 aes

  • 功能:实现AES(Advanced Encryption Standard)对称加密算法
  • 用途:数据对称加密和解密
  • 示例:
import "crypto/aes"
key := []byte("example key 1234") // 16字节的key
block, _ := aes.NewCipher(key)
  • 使用建议:推荐使用,是目前最广泛使用的对称加密算法。

3.2.2 des

  • 功能:实现DES(Data Encryption Standard)和Triple DES加密算法
  • 用途:数据对称加密和解密
  • 示例:
import "crypto/des"
key := []byte("example!") // 8字节的key
block, _ := des.NewCipher(key)
  • 使用建议:不推荐使用DES,密钥长度不足(DES使用56位密钥,实际上是64位,但其中8位是奇偶校验位,不用于加密),容易被暴力破解。推荐使用AES;Triple DES在某些遗留系统中仍在使用。

3.2.3 rc4

  • 功能:实现RC4(Rivest Cipher 4)流加密算法
  • 用途:流数据的加密和解密
  • 示例:
import "crypto/rc4"
key := []byte("secret key")
cipher, _ := rc4.NewCipher(key)
  • 使用建议:不推荐使用,因为RC4已被证明存在安全漏洞。由于这些已知的安全问题,RC4已经被许多现代加密协议和应用所弃用。例如,TLS(Transport Layer Security)协议已经移除了对RC4的支持。

3.2.4 cipher

  • 功能:定义了块加密的通用接口
  • 用途:为其他加密算法提供通用的加密和解密方法
  • 示例:
import "crypto/cipher"
// 使用AES-GCM模式
block, _ := aes.NewCipher(key)
aesgcm, _ := cipher.NewGCM(block)
  • 使用建议:推荐使用,特别是GCM等认证加密模式。

3.3 签名和验证

3.3.1 dsa

  • 功能:实现数字签名算法(DSA, Digital Signature Algorithm)
  • 用途:生成和验证数字签名
  • 示例:
import "crypto/dsa"
var privateKey dsa.PrivateKey
dsa.GenerateKey(&privateKey, rand.Reader)
  • 使用建议:目前的趋势是DSA在许多应用中不再被推荐使用。DSA的安全性高度依赖于密钥长度。随着计算能力的提升,较短的DSA密钥长度(例如1024位)已经不再被认为是安全的。NIST建议使用更长的密钥长度(例如2048位或更长),但这会增加计算复杂性和资源消耗。ECDSA使用椭圆曲线密码学,可以在更短的密钥长度下提供相同级别的安全性。

3.3.2 ecdsa

  • 功能:实现椭圆曲线数字签名算法(ECDSA, Elliptic Curve Digital Signature Algorithm)
  • 用途:生成和验证数字签名
  • 示例:
import "crypto/ecdsa"
privateKey, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
  • 使用建议:强烈推荐使用,安全性高且效率好。

3.3.3 ed25519

  • 功能:实现Ed25519签名算法(Edwards-curve Digital Signature Algorithm with Curve25519)
  • 用途:生成和验证数字签名
  • 示例:
import "crypto/ed25519"
publicKey, privateKey, _ := ed25519.GenerateKey(rand.Reader)
  • 使用建议:强烈推荐使用,安全性高且性能优秀。Ed25519提供了比传统ECDSA更高的安全性和性能,同时减少了某些类型的实现风险。因此,在选择数字签名算法时,Ed25519是一个非常有吸引力的选项,尤其是在需要高性能和强安全保障的应用中。

3.3.4 rsa

  • 功能:实现RSA(Rivest–Shamir–Adleman)加密和签名算法
  • 用途:非对称加密、数字签名
  • 示例:
import "crypto/rsa"
privateKey, _ := rsa.GenerateKey(rand.Reader, 2048)
  • 使用建议:关于是否推荐使用RSA,这取决于具体的应用场景和安全需求。RSA在许多应用中仍然被广泛使用,尤其是在需要公钥加密和数字签名的场景。它是一个经过时间考验的算法,有着良好的安全记录。随着计算能力的提升,特别是量子计算的发展,RSA的安全性可能会受到威胁。此外,对于某些高性能或资源受限的环境,RSA可能不如其他算法(如椭圆曲线加密算法,如ECDSA或Ed25519)高效。尤其是签名,ECDSA或Ed25519可能是更好的选择。

3.4 密钥交换

3.4.1 ecdh

  • 功能:实现椭圆曲线Diffie-Hellman密钥交换(Elliptic Curve Diffie-Hellman)
  • 用途:安全地在不安全的通道上协商共享密钥
  • 示例:
import "crypto/ecdh"
curve := ecdh.P256()
privateKey, _ := curve.GenerateKey(rand.Reader)
  • 使用建议:ECDH是一个强大且高效的密钥交换协议,在许多现代安全通信中被推荐使用,是现代密钥交换的首选方法。

3.5 安全随机数生成

3.5.1 rand

  • 功能:提供加密安全的随机数生成器
  • 用途:生成密钥、随机填充等
  • 示例:
import "crypto/rand"
randomBytes := make([]byte, 32)
rand.Read(randomBytes)
  • 使用建议:强烈推荐使用,不要使用math/rand包(包括math/rand/v2)生成密码学相关的随机数(这些随机数是伪随机)。

3.6 证书和协议

3.6.1 tls

  • 功能:实现传输层安全(TLS, Transport Layer Security)协议
  • 用途:安全网络通信
  • 示例:
import "crypto/tls"
config := &tls.Config{MinVersion: tls.VersionTLS12}
  • 使用建议:强烈推荐使用,是保护网络通信的标准方法。

3.6.2 x509

  • 功能:实现X.509公钥基础设施标准
  • 用途:处理数字证书、证书签名请求(CSR)等
  • 示例:
import "crypto/x509"
cert, _ := x509.ParseCertificate(certDER)
  • 使用建议:推荐使用,是处理数字证书的标准方法。

3.7. 辅助功能

3.7.1 elliptic

  • 功能:实现几个标准的椭圆曲线
  • 用途:为ECDSA和ECDH提供基础
  • 示例:
import "crypto/elliptic"
curve := elliptic.P256()
  • 使用建议:推荐使用,但通常不直接使用,而是通过ecdsa或ecdh包间接使用。

3.7.2 hmac

  • 功能:实现密钥散列消息认证码(HMAC, Hash-based Message Authentication Code)
  • 用途:消息完整性验证
  • 示例:
import "crypto/hmac"
h := hmac.New(sha256.New, []byte("secret key"))
h.Write([]byte("message"))
  • 使用建议:推荐使用,是保护数据完整性和消息认证的标准方法。

3.7.3 subtle

  • 功能:提供一些用于实现加密功能的常用但容易出错的操作
  • 用途:比较、常量时间操作等
  • 示例:
import "crypto/subtle"
equal := subtle.ConstantTimeCompare([]byte("a"), []byte("b"))
  • 使用建议:推荐在需要时使用,有助于防止时序攻击。

结合上面两节,我们看到crypto库的内部依赖结构设计得非常巧妙,以最小化耦合。大多数子包依赖于crypto基础包中定义的接口和类型。crypto/subtle包提供了一些底层的辅助函数,被多个其他包使用。每个加密算法包(如crypto/aes,crypto/rsa)通常是独立的,减少了包间的直接依赖。一些高级功能包(如crypto/tls)会依赖多个基础算法包。大多数需要随机性的包都依赖crypto/rand作为安全随机源。

此外,crypto库与其他Go标准库可紧密集成,包括:

  • 与io包集成:使用io.Reader和io.Writer接口,便于流式处理和与其他I/O操作集成。
  • 与encoding相关包集成:比如与encoding/pem和encoding/asn1包配合,用于处理密钥和证书的编码。
  • 与hash包集成:加密哈希函数实现了hash.Hash接口,保持一致性。
  • 与net包集成:如crypto/tls包与net包紧密集成,提供安全的网络通信。

接下来,再来看看golang.org/x/crypto扩展库,我们同样借鉴上面的分类和介绍方法,看看crypto扩展库中都有哪些有价值的实用密码学包。

4 golang.org/x/crypto扩展库

我们还是从哈希函数开始介绍。

4.1 哈希函数

4.1.1 blake2b和blake2s

  • 功能:实现BLAKE2b和BLAKE2s哈希函数。BLAKE2是一种加密哈希函数,由Jean-Philippe Aumasson、Samuel Neves、Zooko Wilcox-O’Hearn和Christian Winnerlein设计,旨在替代MD5和SHA-1等旧的哈希函数。BLAKE2有两种主要变体:BLAKE2b和BLAKE2s。
  • 用途:生成高速、安全的哈希值。
  • 示例:
import "golang.org/x/crypto/blake2b"
hash := blake2b.Sum256([]byte("hello world"))
  • 使用建议:推荐使用,BLAKE2提供了比MD5和SHA-1更高的安全性,同时保持与SHA-2和SHA-3相当的强度,安全性高且速度快。

4.1.2 md4

  • 功能:实现MD4(Message Digest Algorithm 4)哈希算法
  • 用途:生成128位哈希值
  • 示例:
import "golang.org/x/crypto/md4"
h := md4.New()
h.Write([]byte("hello world"))
hash := h.Sum(nil)
  • 使用建议:不推荐用于安全相关用途,MD4已被证明不安全,容易受到碰撞攻击和其他类型的攻击。已经被更安全的哈希函数所取代,如SHA-2和SHA-3等。

4.1.3 ripemd160

  • 功能:实现RIPEMD-160(RACE Integrity Primitives Evaluation Message Digest 160)哈希算法。
  • 用途:生成160位哈希值
  • 示例:
import "golang.org/x/crypto/ripemd160"
h := ripemd160.New()
h.Write([]byte("hello world"))
hash := h.Sum(nil)
  • 使用建议:RIPEMD-160提供了比MD5和SHA-1更高的安全性,尽管它不像SHA-2和SHA-3那样被广泛研究和使用。但它仍然在某些特定场景(如比特币地址生成)中使用,但一般情况下推荐使用更现代的哈希函数(如SHA-256和SHA-512)。

4.1.4 sha3

  • 功能:实现SHA-3(Secure Hash Algorithm 3)哈希算法族。SHA-3是由美国国家标准与技术研究院(NIST)在2015年发布的一种加密哈希函数,作为SHA-2的后继者。SHA-3的设计基于Keccak算法,由Guido Bertoni、Joan Daemen、Michaël Peeters和Gilles Van Assche开发。
  • 用途:生成不同长度的哈希值。SHA-3包括多种变体,如SHA3-224、SHA3-256、SHA3-384和SHA3-512,分别生成224位、256位、384位和512位的哈希值。
  • 示例:
import "golang.org/x/crypto/sha3"
hash := sha3.Sum256([]byte("hello world"))
  • 使用建议:强烈推荐使用,是最新的NIST标准哈希函数。

4.2 加密和解密

4.2.1 blowfish

  • 功能:实现Blowfish(设计者Bruce Schneier)加密算法
  • 用途:数据的对称加密和解密
  • 示例:
import "golang.org/x/crypto/blowfish"
cipher, _ := blowfish.NewCipher([]byte("key"))
  • 使用建议:不推荐用于新系统,其密钥长度上限为448位,不如更现代的算法安全,建议使用AES。

4.2.2 cast5

  • 功能:实现CAST5(又名CAST-128)加密算法
  • 用途:数据对称加密和解密
  • 示例:
import "golang.org/x/crypto/cast5"
cipher, _ := cast5.NewCipher([]byte("16-byte key"))
  • 使用建议:不推荐用于新系统,建议使用AES。

4.2.3 chacha20

  • 功能:实现ChaCha20流加密算法(ChaCha20 stream cipher)
  • 用途:流数据的对称加密和解密
  • 示例:
import "golang.org/x/crypto/chacha20"
cipher, _ := chacha20.NewUnauthenticatedCipher(key, nonce)
  • 使用建议:推荐使用,特别是在移动设备上性能优于AES。它被广泛用于各种安全协议和应用中,包括TLS(Transport Layer Security)、SSH(Secure Shell)和QUIC(Quick UDP Internet Connections)等。

4.2.4 salsa20

  • 功能:实现Salsa20流加密算法(Salsa20 stream cipher)
  • 用途:流数据的对称加密和解密
  • 示例:
import "golang.org/x/crypto/salsa20"
salsa20.XORKeyStream(dst, src, nonce, key)
  • 使用建议:推荐使用,但ChaCha20可能因其性能优势和更广泛的标准支持而成为更受欢迎的选择。

4.2.4 tea

  • 功能:实现TEA(Tiny Encryption Algorithm)加密算法
  • 用途:轻量级数据加密
  • 示例:
import "golang.org/x/crypto/tea"
cipher, _ := tea.NewCipher([]byte("16-byte key"))
  • 使用建议:尽管TEA算法在过去被认为是安全的,但它已经出现了一些已知的安全漏洞,如密钥相关攻击和差分攻击。因此,TEA算法可能不适合需要高安全性的应用。不推荐将它用于新系统,建议使用AES。

4.2.5 twofish

  • 功能:实现Twofish(Twofish block cipher)加密算法
  • 用途:数据对称加密和解密
  • 示例:
import "golang.org/x/crypto/twofish"
cipher, _ := twofish.NewCipher([]byte("16, 24, or 32 byte key"))
  • 使用建议:不推荐将它用于新系统,建议使用AES。

4.2.6 xtea

  • 功能:实现XTEA(eXtended Tiny Encryption Algorithm)加密算法
  • 用途:轻量级对称数据加密
  • 示例:
import "golang.org/x/crypto/xtea"
cipher, _ := xtea.NewCipher([]byte("16-byte key"))
  • 使用建议:尽管XTEA修复了TEA的一些安全漏洞,但它仍然可能存在其他安全问题,特别是在面对现代计算能力和攻击技术时。因此,不推荐用于新系统,建议使用AES。

4.2.7 xts

  • 功能:实现XTS (XEX-based tweaked-codebook mode with ciphertext stealing) 模式
  • 用途:是一种块加密的标准操作模式,主要用于全磁盘加密
  • 示例:
import "golang.org/x/crypto/xts"
cipher, _ := xts.NewCipher(aes.NewCipher, []byte("32-byte key"))
  • 使用建议:在全磁盘加密场景,即需要对存储设备进行加密的应用中推荐使用。

4.3 认证加密

4.3.1 chacha20poly1305

  • 功能:实现ChaCha20-Poly1305(ChaCha20流加密算法和Poly1305消息认证码) AEAD(认证加密与关联数据)。
  • 用途:提供加密和认证的组合
  • 示例:
import "golang.org/x/crypto/chacha20poly1305"
aead, _ := chacha20poly1305.New(key)
  • 使用建议:ChaCha20-Poly1305是一个高效且安全的组合加密算法,在许多现代安全应用中被推荐使用。这里也强烈推荐使用,提供了高安全性和高性能。

4.4 密钥派生和密码哈希

4.4.1 argon2

  • 功能:实现Argon2(Argon2 memory-hard key derivation function)密码哈希算法
  • 用途:安全地存储密码
  • 示例:
import "golang.org/x/crypto/argon2"
hash := argon2.IDKey([]byte("password"), salt, 1, 64*1024, 4, 32)
  • 使用建议:强烈推荐使用,是最新的密码哈希标准。

4.4.2 bcrypt

  • 功能:实现bcrypt(Blowfish-based password hashing function)密码哈希算法
  • 用途:安全地存储密码
  • 示例:
import "golang.org/x/crypto/bcrypt"
hash, _ := bcrypt.GenerateFromPassword([]byte("password"), bcrypt.DefaultCost)
  • 使用建议:推荐使用,广泛应用于密码存储

4.4.3 hkdf

  • 功能:实现HMAC-based Key Derivation Function (HKDF)
  • 用途:HKDF是基于HMAC(Hash-based Message Authentication Code)的一种变体,专门用于从较短的输入密钥材料(如共享密钥或密码)派生出更长的、安全的密钥。
  • 示例:
import "golang.org/x/crypto/hkdf"
hkdf := hkdf.New(sha256.New, secret, salt, info)
  • 使用建议:推荐使用,是标准的密钥派生函数。

4.4.4 pbkdf2

  • 功能:实现PBKDF2(Password-Based Key Derivation Function 2, 基于密码的密钥派生函数2)
  • 用途:从密码派生密钥
  • 示例:
import "golang.org/x/crypto/pbkdf2"
dk := pbkdf2.Key([]byte("password"), salt, 4096, 32, sha1.New)
  • 使用建议:对于需要高安全性和抵抗暴力破解攻击的应用,PBKDF2是一个很好的选择。然而,对于更现代的应用,特别是那些对安全性有极高要求的应用,可能更推荐使用更现代的密码哈希算法,如Argon2。

4.4.5 scrypt

  • 功能:实现scrypt(Scrypt key derivation function)密钥派生函数
  • 用途:从密码派生密钥,特别适合抵抗硬件暴力破解
  • 示例:
import "golang.org/x/crypto/scrypt"
dk, _ := scrypt.Key([]byte("password"), salt, 32768, 8, 1, 32)

4.5 公钥密码学

4.5.1 bn256

  • 功能:实现256位Barreto-Naehrig曲线
  • 用途:支持双线性对运算,用于某些高级密码协议
  • 示例:
import "golang.org/x/crypto/bn256"
g1 := new(bn256.G1).ScalarBaseMult(k)
  • 使用建议:该包已作废并冻结,不推荐使用。github.com/cloudflare/bn256有更完整的实现,但对于新的应用,特别是那些对安全性有极高要求的应用,不推荐使用bn256。

4.5.2 nacl

  • 功能:提供NaCl(Networking and Cryptography library)的Go实现
  • 用途:NaCl主要用于需要高效加密和安全通信的应用。它提供了各种加密原语,包括对称加密、公钥加密、哈希函数、消息认证码(MAC)和密钥协商协议等。
  • 示例:
import "golang.org/x/crypto/nacl/box"
publicKey, privateKey, _ := box.GenerateKey(rand.Reader)
  • 使用建议:推荐使用,提供了易用的高级加密接口

4.6 协议和标准

4.6.1 acme

  • 功能:实现ACME(Automatic Certificate Management Environment)协议,该协议旨在自动化证书的颁发、更新和管理。它允许服务器自动请求和接收TLS/SSL证书,而无需人工干预。
  • 用途:自动化证书管理,如Let’s Encrypt
  • 示例:使用较复杂,通常通过更高级的库如golang.org/x/crypto/acme/autocert使用,鉴于篇幅,这里就不贴代码了。
  • 使用建议:在需要自动化证书管理的场景中推荐使用

4.6.2 ocsp

  • 功能:实现在线证书状态协议(OCSP, Online Certificate Status Protocol),该协议提供了一种实时查询数字证书状态的方法。它允许客户端在建立安全连接之前,向证书颁发机构(CA)查询特定证书的有效性。
  • 用途:检查X.509数字证书的撤销状态
  • 示例:
import "golang.org/x/crypto/ocsp"
resp, _ := ocsp.ParseResponse(responseBytes, issuer)
  • 使用建议:在需要证书状态检查的应用中推荐使用

4.6.3 openpgp

  • 功能:实现OpenPGP(Open Pretty Good Privacy)标准。OpenPGP是一种加密标准,旨在提供数据加密和解密、数字签名和数据完整性保护。
  • 用途:主要用于保护电子邮件通信、文件存储和数据传输的安全。它支持对称加密、公钥加密、哈希函数和消息认证码(MAC),以及生成和验证数字签名。
  • 示例:
import "golang.org/x/crypto/openpgp"
entity, _ := openpgp.NewEntity("name", "comment", "email", nil)
  • 使用建议:OpenPGP是一个强大、灵活和安全的加密标准,被广泛用于各种安全协议和应用中,包括电子邮件加密、文件加密和数据传输加密。在许多现代安全应用中被推荐使用。

4.6.4 otr

  • 功能:实现Off-The-Record Messaging (OTR) 离线消息传递协议
  • 用途:提供即时通讯场景的端到端加密,确保通信内容只能被预期的接收者阅读,而不会被第三方窃听或篡改。
  • 示例:(使用较复杂,通常需要结合具体的即时通讯应用)
  • 使用建议:在开发加密即时通讯应用时可以考虑使用

4.6.5 pkcs12

  • 功能:实现PKCS#12标准(Public-Key Cryptography Standards #12),PKCS#12是由RSA Laboratories设计的,旨在定义一种标准格式,用于存储和传输私钥、公钥和证书链。PKCS#12文件通常以.p12或.pfx扩展名结尾。
  • 用途:存储和传输服务器证书、中间证书和私钥
  • 示例:
import "golang.org/x/crypto/pkcs12"
blocks, _ := pkcs12.ToPEM(pfxData, "password")
  • 使用建议:PKCS#12是一个强大、安全和标准化的密钥和证书存储格式,在需要安全存储和传输加密密钥和证书的应用中被推荐使用。不过该包已经冻结,如需要,可考虑software.sslmate.com/src/go-pkcs12的实现(github.com/SSLMate/go-pkcs12)。

4.6.6 ssh

  • 功能:实现SSH客户端和服务器
  • 用途:提供安全的远程登录和其他安全网络服务
  • 示例:
import "golang.org/x/crypto/ssh"
config := &ssh.ClientConfig{User: "user", Auth: []ssh.AuthMethod{ssh.Password("password")}}
  • 使用建议:强烈推荐用于实现SSH功能

4.7 其他

4.7.1 poly1305

  • 功能:实现Poly1305消息认证码。Poly1305是一种高速的消息认证码(MAC)算法, 通常与ChaCha20流加密算法结合使用,形成ChaCha20-Poly1305组合,用于提供加密和消息认证的完整解决方案。
  • 用途:用于消息认证,确保消息在传输过程中的完整性和真实性,未被篡改。
  • 示例:
import "golang.org/x/crypto/poly1305"
var key [32]byte
var out [16]byte
poly1305.Sum(&out, msg, &key)
  • 使用建议:这个包的实现已作废,推荐使用golang.org/x/crypto/chacha20poly1305

5. Go密码学库的现状与后续方向

Gotime在2023年末和今年年初对Go密码学库的前负责人Filippo Valsorda和现负责人Roland Shoemaker进行了三期访谈(见参考资料),通过这三次访谈我们大约可以梳理出Go密码学库的现状与后续方向:

  • RSA后端实现的改进,提高了安全性和性能。
  • 引入godebug机制,允许在不破坏兼容性的情况下逐步引入新的安全改进。
  • 正在考虑对一些密码学包进行v2版本的设计,以提供更高级和更易用的API。
  • 正在逐步弃用一些不安全的算法,如SHA1和MD5。
  • 简化配置选项,减少用户需要做的选择,提供更多默认安全设置。
  • 正在将golang.org/x/crypto中的重要包移入标准库,以减少混淆,包括继TLS之后的另外一个重要协议包ssh库。
  • 使用BoringSSL的BoGo测试套件来全面测试Go的TLS实现。
  • Go密码学库正在实现这些新的后量子密码算法,但目前还没有完全集成到标准库中。

总的来说,Go密码学库(包括golang.org/x/crypto)正在积极发展和改进,同时也在为后量子密码学时代做准备。虽然后量子算法的完全集成和广泛应用还需要一段时间,但Go团队正在积极跟进这一领域的发展,努力在保持兼容性的同时提升安全性和性能。

6. 小结

在这篇文章中,我们对Go生态中密码学功能的核心:Go crypto库(包括标准库crypto相关包以及golang.org/x/crypto相关包)进行了全面的了解,包括两者的关系、整体结构设计原则以及每个库的子包概览。

我们看到:Go crypto库以其安全性、全面性、易用性、高性能以及与Go生态系统的高度集成而著称。它不仅涵盖了广泛的加密算法和协议,还通过统一且直观的API降低了使用门槛。

相信通过上述的了解,大家都已经理解了Go crypto库的架构与设计思想,并建立起了一张crypto库的“地图”。按照这幅图的指示,大家可以根据具体需求,快速找到合适的密码学包,并利用这些包构建安全可靠的Go应用。

7. 参考资料


Gopher部落知识星球在2024年将继续致力于打造一个高品质的Go语言学习和交流平台。我们将继续提供优质的Go技术文章首发和阅读体验。同时,我们也会加强代码质量和最佳实践的分享,包括如何编写简洁、可读、可测试的Go代码。此外,我们还会加强星友之间的交流和互动。欢迎大家踊跃提问,分享心得,讨论技术。我会在第一时间进行解答和交流。我衷心希望Gopher部落可以成为大家学习、进步、交流的港湾。让我相聚在Gopher部落,享受coding的快乐! 欢迎大家踊跃加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

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

Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite
  • Gopher Daily归档 – https://github.com/bigwhite/gopherdaily
  • Gopher Daily Feed订阅 – https://gopherdaily.tonybai.com/feed

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

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 Go语言编程指南
商务合作请联系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
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats