golang之不安全编程

KilluaZoldyck 2020-01-19

楔子

不安全编程?用golang以来也没发现有啥不安全的啊,而且golang有垃圾回收,也不需要我们来管理内存。当听到不安全编程这几个字,唯一能想到的也就是指针了,只有指针才可能导致不安全问题。我们知道golang中是有指针的,但是golang的指针并不能像C语言中的指针一样,可以进行运算,所以golang中的指针既提供了指针的便利性,又保证了安全。但是在golang中,可以通过一个叫做unsafe的包让指针突破限制,从而进行运算,一旦用不好会导致很严重的问题,但是用好了在某些场景下能够带来很大的便利,所以我们说这是不安全编程。但即便如此,我们还是可以使用的,而且golang的内部也在大量的使用unsafe这个包。

golang中的指针

尽管golang的指针没有C的指针那么强大,但是能够获取一个变量的地址,并且能通过地址来改变存储的值,我个人认为已经足够了。

package main

import "fmt"

func pass_by_value(num int){
    num = 3
}

func pass_by_pointer(num *int){
    *num = 3
    num = nil
}

func main() {

    num := 1
    pass_by_value(num)
    fmt.Println("传递值:", num)  //传递值: 1
    pass_by_pointer(&num)
    fmt.Println("传递指针:", num)  //传递指针: 3

我们知道golang的函数传递方式是值传递,不管传递什么,都是拷贝一份出来。而且函数里面形参叫什么是无所谓,这里我们函数的形参不叫num,叫其他的也无所谓。

pass_by_value中接收一个整型,当我们传递num的时候,会把num的值拷贝一份出来传进去,此时函数里面无论做什么修改,都不会影响外面的num,因为不是一个东西。

pass_by_pointer中接收一个指针,那么传递&num的时候,依旧会把指针拷贝一份,我们说golang只有值传递,传递指针的话也是把指针拷贝一份。由于是拷贝,所以两者没有任何关系,只不过它们存储的地址是一样的,但就pass_by_pointer来说,里面的num这个*?int类型的变量和我们传递的&num来说是没有关系的。由于存储的地址是一样的,所以两者操作的都是同一片内存,因此*?num?=?3之后是会影响外面的num的,但是指针也是拷贝,所以函数里面的num?= nil跟外面没关系。

golang之不安全编程

所以golang中的指针在改变内存的值的时候和C是一样的,但是它和C中的指针相比,又弱化了许多。

弱化一:golang中的指针不能进行数学运算。

package main

func main() {
    arr := [...]int{1, 2, 3}
    //获取数组首元素的地址
    p := &arr[0]
    //如果是C中,我们可以通过p++,获取当前元素的下一个元素的地址
    //但是在golang中不行,p++这种做法是不会通过编译的
    p++
}

//invalid operation: p++ (non-numeric type *int)

弱化二:golang中不同类型的指针不能进行转化或者赋值。

package main

func main() {
    var a int
    var b *float64
    b = &a
    
    //cannot use &a (type *int) as type *float64 in assignment
}

弱化三:golang中不同类型的指针不能进行比较。

只有在两个指针类型相同或者可以相互转化的情况下才可以比较,比较两个地址是否一样。另外所有指针都可以通过==!=和nil进行比较,来判断这个指针是否为空。

package main

import "fmt"

func main() {
    var a = 1
    var b = 1
    //值相同,为true
    fmt.Println(a == b)  // true
    //但是地址不一样,为false
    fmt.Println(&a == &b)  // false

    //但是不同类型的指针是无法比较的,别说指针了,就是值也是无法比较的
    //golang对于类型的要求是非常严格的
    var c float64
    /*
    fmt.Println(&a == &c)

    //invalid operation: &a == &c (mismatched types *int and *float64)
    */

    //但是它们都可以和nil进行比较
    fmt.Println(&c == nil, &c != nil)  // false true

    var m map[int]int
    //map是指针类型,对于slice、channel、map这种数据结构,我们一般使用make创建,会申请对应的内存,然后返回指针
    //如果只是这种声明的话,那么是没有所谓的0值的,直接会返回一个空指针
    //别看打印m的结果是map[],但是这只是表示m是一个map类型的数据,但是它还没有被分配内存,所以结果nil
    fmt.Println(m == nil, m) // true map[]
}

unsafe:不安全编程

什么是unsafe

通过以上我们看到golang中的指针实际上是类型安全的,因为golang对类型的检测是十分的严格,让你在享受指针带来的便利时,又给指针施加了很多制约来保证安全。但是保证安全是需要以牺牲效率为代价的,如果你能保证写出的程序就是安全的,那么你可以使用golang中的不安全指针,从而绕过类型系统的检测,让你的程序运行的更快。

如果是一个高阶golang程序员的话,怎么能不会unsafe包呢?它可以绕过golang的类型系统的检测,直接访问内存,增加效率。golang中的很多限制,比如不能操作结构体中的未导出成员等等,但是有了unsafe包,就可以直接突破这些限制。所以这个包叫做unsafe,我们称使用unsafe为不安全编程,因为它很危险,官方也不推荐使用,估计正因为如此也设计了这么个名字吧。但是你底层都在大量使用,那我们为什么不能用。

unsafe实现原理

我们刚才提到了不安全指针,那么我们先来看看什么是不安全指针。

package unsafe
type ArbitraryType int
type Pointer *ArbitraryType

func Sizeof(x ArbitraryType) uintptr
func Offsetof(x ArbitraryType) uintptr
func Alignof(x ArbitraryType) uintptr

unsafe包下面只有一个unsafe.go文件,这个文件里面把注释去掉就上面6行代码,是的你没有看错。当然功能肯定都内嵌在编译器里面,至于怎么实现的我们就不管啦,看看怎么用就行了。我们先来看看这两行:

type ArbitraryType int
type Pointer *ArbitraryType

Arbitrary表示任意的,所以这个Pointer可以是任何类型的指针,比如:*int、*string、*float64等等。也就是说任何类型的指针都可以传递给它。

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var a int
    var s string
    var f float64
    fmt.Println(unsafe.Pointer(&a))  //0xc000062080
    fmt.Println(unsafe.Pointer(&s))  //0xc00004e1c0
    fmt.Println(unsafe.Pointer(&f))  //0xc000062088
}

unsafe.Pointer()是有返回值的,返回的当然也是一个指针,但是这个指针同样是无法进行运算的。如果无法运算,那么我们还是无法实现通过指针自增的方式,访问数组的下一个元素啊。别急,所以还有一个整数类型:uintptr,我们unsafe.Pointer()是可以和uintptr互相转化的,而这个uintptr是可以运算的,并且它还足够大。因此我们目前看到了两个功能:

1.任何类型的指针都可以和unsafe.Pointer相互转化

2.unsafe.Pointer可以和uintptr互相转化

golang之不安全编程

但是需要注意的是,uintptr并没有指针的含义,所以它指向的内存是会被回收的,而unsafe.Pointer有指针的含义,可以确保其指向的对象不会被回收。

使用unsafe带你突破限制

像C语言一样访问数组或切片

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    //这里把数字弄成没有规律的,就不用1 2 3 4 5 6了
    var arr = []int{177, 123, 3, 221, 5, 1211}

    //获取第二个元素的指针,我们也不从头获取
    //因为从中间获取都可以的话,那么从头获取肯定可以
    //然后传给unsafe.Pointer(),将*int转化成Pointer类型
    pointer := unsafe.Pointer(&arr[1])

    //注意了:下面要将Pointer转成uintptr,因为Pointer是不能运算的
    u_pointer := uintptr(pointer)
    //此时的u_pointer就相当于C中的指针了,但是还有一点不同
    //C中的指针直接++即可,指针会自动移到到下一个元素的位置
    //而golang中的uintptr相当于一个整型,我们不能++,而是需要+8,因为一个int占8个字节,所以golang中需要加上元素所占的大小
    //所以我们发现C中的+n是从当前元素开始,移动n个元素,不管元素是什么类型。
    //但是golang的+n是移动n个字节。
    //所以C中的指针+2 等于 golang中uintptr + 2 * (元素类型所占的字节)
    u_pointer += 16 //移动两个元素

    //然后再转回来,要先转成Pointer,再转成对应的指针类型
    pointer = unsafe.Pointer(u_pointer)

    //这个pointer我们通过&arr[1]也就是*int类型的指针得到了,那么结果也要转成*int
    int_pointer := (*int)(pointer)
    // 打印了221,结果是正确的
    fmt.Println(*int_pointer) // 221

    //这里也可以转成*string,即便我们的pointer是通过*int得到的
    //因为Pointer可以是任何指针类型
    string_pointer := (*string)(pointer)
    //也是可以打印的,但是通过*来访问内存的话就会报错,panic: runtime error: invalid memory address or nil pointer dereference
    fmt.Println(string_pointer) //0xc00008c048

    //这里我们再加上1,不加8,那么会出现什么后果
    //我们知道再加上8,就会访问221后面的5
    u_pointer += 1
    fmt.Println(*(*int)(unsafe.Pointer(u_pointer))) // 360287970189639680
    //我们看到此时得到的是一个我们也不知道从哪里来的脏数据,所以一定要加上对应的字节
}

所以我们发现unsafe.Pointer就类似于一座桥,*T通过Pointer转成uintptr,然后进行指针运算,运算完成之后,再通过Pointer转回*T,此时的*T就是我们想要的了。

指针访问结构体

我们知道结构体是可以有字段的,那么我们也可以把结构体想象成数组,字段想象成数组的元素。

package main

import (
    "fmt"
    "unsafe"
)

type score struct {
    math    int
    english int
    history int
}

func main() {
    s := score{math: 90, english: 92, history: 85}

    //我们看到通过unsafe.Pointer的方式,获取结构体的指针,可以直接转换为结构体第一个字段的指针
    p := unsafe.Pointer(&s)
    fmt.Println(*(*int)(p))
    //math字段是一个整型,那么p转为uintptr之后加上8,就可以转换成第二个字段的指针
    fmt.Println(*(*int)(unsafe.Pointer(uintptr(p) + 8))) //92
    //同理加上16就是第三个
    fmt.Println(*(*int)(unsafe.Pointer(uintptr(p) + 16))) //85
    
    //这里显然就是一个乱七八糟的值了
    fmt.Println(*(*int)(unsafe.Pointer(uintptr(p) + 29))) //92
}

我们知道切片是一个结构体,有三个字段,分别是指向底层数组的指针,以及大小和容量。

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    //申请大小为5,容量为10的切片
    s := make([]int, 5, 10)

    //第一个元素显然是指向底层数组的指针,大小也是8个字节。我们来看第二个和第三个
    //虽然有些长,但是从内往外的话,还是很好看懂的。如果不习惯的话可以写成一行
    fmt.Printf("长度:%d\n", *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + 8)))  //长度:5
    fmt.Printf("容量:%d\n", *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + 16)))  //容量:10
}

我们看到unsafe包还是很强大的,之所以叫unsafe是因为如果用不好后果会很严重。但是如果能正确使用的话,能够做到很多之前做不到的事情。

获取对象的大小

我们目前可以使用unsafe做很多事情了,但是还不够,我们看到unsafe这个包除了给我们提供了Pointer这个类型之外,还给我们提供了三个函数。

func Sizeof(x ArbitraryType) uintptr
func Offsetof(x ArbitraryType) uintptr
func Alignof(x ArbitraryType) uintptr

这三个函数返回的都是uintptr类型,这个类型你就看成是整型即可,它是可以和数字进行运算的,可以转为int。我们先来看看Sizeof

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    a := 123
    b := "h"
    c := []int{1, 2, 3}
    fmt.Println(unsafe.Sizeof(a)) //8
    //关于字符串为什么是16
    //golang中的字符串在底层是一个结构体,这个结构体有两个元素
    //一个是字符串的首地址,一个是字符串的长度
    //所以是16,因为golang的字符串底层对应的是一个字符数组
    fmt.Println(unsafe.Sizeof(b)) //16

    //切片我们说过底层也是一个结构体,有三个字段,指向底层数组的指针、大小、容量,所以是24个字节
    fmt.Println(unsafe.Sizeof(c)) //24
}

golang中的Sizeof和C中的sizeof还是比较类似的,但是golang中的Sizeof不能接收类型本身, 比如你可以传入一个123,但是你不能传入一个int,这是不行的。至于获取一个字符串的大小结果是16,这个是由golang底层字符串的结构决定的。对了,当我们获取一个结构体的大小的时候,我们看到貌似是将结构体中的每一个字段的值的大小进行相加,至少目前看来是这样的。

获取结构体成员的偏移量

对于一个结构来说,可以使用Offsetof来获取结构体成员的偏移量,进而获取成员的地址,从而改变内存的值。这里提一句:结构体会被分配一块连续的内存,结构体的地址也代表了第一个成员的地址。但是你懂的,我们不可能直接通过对结构体的地址加上*来获取第一个成员的值,只能通过unsafe.Pointer转化,然后再转化成对应类型的指针,才能获取。

package main

import (
    "fmt"
    "unsafe"
)

type girl struct {
    //对应的字节数
    name string  // 16
    age int  // 8
    gender string  //16
    hobby []string //24
}

func main() {
    g := girl{"mashiro", 17, "f", []string{"画画", "开车"}}
    //首先这几步操作应该不需要解释了,直接想象成数组即可
    fmt.Println(*(*string)(unsafe.Pointer(&g))) // mashiro
    fmt.Println(*(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&g)) + 16))) // 17
    fmt.Println(*(*string)(unsafe.Pointer(uintptr(unsafe.Pointer(&g)) + 16 + 8)))  // f
    fmt.Println(*(*[]string)(unsafe.Pointer(uintptr(unsafe.Pointer(&g)) + 16 + 8 + 16)))  // [画画 开车]

    //我们看到即使对具有不同字段类型的结构体,依旧可以自由操作,只要搞清楚每个字段的大小即可
    *(*[]string)(unsafe.Pointer(uintptr(unsafe.Pointer(&g)) + 16 + 8 + 16)) =
        append(*(*[]string)(unsafe.Pointer(uintptr(unsafe.Pointer(&g)) + 16 + 8 + 16)), "料理")
    fmt.Println(g) // {mashiro 17 f [画画 开车 料理]}

    //我们看到,即便操作起来没有问题,但是有一个缺陷,就是我们必须要事先计算好每一个字段占多少个字节,尽管我们可以通过unsafe.Sizeof可以很方便的计算。
    //但是有没有不用计算的方法呢?显然有,就是我们说的Offsetof。但是这个Offsetof又有点特殊,它表示的是偏移量
    //比如我想访问hobby这个字段,那么这么做可以,直接以&g为起点,此时偏移量为0,加上unsafe.Offsetof(g.hobby),直接偏移到hobby
    fmt.Println(*(*[]string)(unsafe.Pointer(   uintptr(unsafe.Pointer(&g)) + unsafe.Offsetof(g.hobby)     ))) // [画画 开车 料理]
    
    //其余的也是一样,获取哪个字段,直接传入哪个字段即可,个人觉得这个Offsetof比自己计算要方便一些
    fmt.Println(*(*string)(unsafe.Pointer(uintptr(unsafe.Pointer(&g)) + unsafe.Offsetof(g.name)))) // mashiro
    fmt.Println(*(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&g)) + unsafe.Offsetof(g.age)))) // 17
    fmt.Println(*(*string)(unsafe.Pointer(uintptr(unsafe.Pointer(&g)) + unsafe.Offsetof(g.gender)))) // f
}

而且我们知道,如果在别的包里面,结构体里的字段没有大写,那么是无法导出的,然鹅即便如此,我们依旧可以通过unsafe包绕过这些限制。

package hahaha

type OverWatch struct {
    name   string
    age    int
    Gender string
    weapon string
}

这些字段有三个没有大写,理论上是无法导出的,因为golang会进行检测,但是使用unsafe就可以绕过这些检测。

package main

import (
    "fmt"
    "hahaha"
    "unsafe"
)

func main() {
    hero := new(hahaha.OverWatch)
    //设置name
    *(*string)(unsafe.Pointer(uintptr(unsafe.Pointer(hero)))) = "麦克雷"
    //设置age,因为Offsetof需要指定访问的字段,而字段又没有被导出,所以无法通过Offsetof的方式
    //因此需要手动计算对应类型的偏移量,因为是string类型,所以加上一个Sizeof(""),当然也可以手动填上16
    *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(hero)) + unsafe.Sizeof(""))) = 37
    //这个就可以直接设置了,因为被导出了
    hero.Gender = "男"
    //老规矩,这里是两个string加上一个int的大小
    *(*string)(unsafe.Pointer(uintptr(unsafe.Pointer(hero)) + unsafe.Sizeof("") * 2 + unsafe.Sizeof(123))) = "维和者"
    fmt.Println(*hero)  // {麦克雷 37 男 维和者}
}

字段对齐

通过unsafe.Alignof可以获取字段的对齐值,不过这里用不上,可以自己尝试一下,上面的用的比较多。

参考于:https://qcrao.com/2019/06/03/dive-into-go-unsafe/,用原文作者的话来说就是:

unsafe 包绕过了 Go 的类型系统,达到直接操作内存的目的,使用它有一定的风险性。但是在某些场景下,使用 unsafe 包提供的函数会提升代码的效率,Go 源码中也是大量使用 unsafe 包。

uintptr 可以和 unsafe.Pointer 进行相互转换,uintptr 可以进行数学运算。这样,通过 uintptr 和 unsafe.Pointer 的结合就解决了 Go 指针不能进行数学运算的限制。通过 unsafe 相关函数,可以获取结构体私有成员的地址,进而对其做进一步的读写操作,突破 Go 的类型安全限制。关于 unsafe 包,我们更多关注它的用法。

顺便说一句,unsafe 包用多了之后,也不觉得它的名字有多么地不“美观”了。相反,因为使用了官方并不提倡的东西,反而觉得有点酷炫。这就是叛逆的感觉吧。个人非常赞同,觉得真的很酷。

相关推荐

zhuxianfeng / 0评论 2020-02-09