首页 Go语言 字节切片（byte slice）相关的编译器漏洞和标准库设计失误

字节切片（byte slice）相关的编译器漏洞和标准库设计失误

Author: bill · 分类： Go语言 ·    2019年10月 · tags:

以下文章来源于Go 101 ，作者老貘

假如一个类型MyByte定义如下，如何将一个[]MyByte切片值和一个[]byte切片值互相转换为对方的类型？


package main 

type MyByte byte 
var ( 
  x = []byte{1, 2, 3} 
  y = []MyByte{1, 2, 3} 
) 

func main() { 
  x = []byte(y) // error: 非法的转换 
  y = []MyByte(x) // error: 非法的转换 
}

如上例所示，在Go中，这两个类型的值之间的类型转换是非法的。因为Go规定两个切片只有在它们的类型的底层类型（underlying type）相同的情况下才能转换到对方的类型。而一个非定义类型（undefined type）的底层类型为此非定义类型本身。类型[]MyByte和[]byte均为非定义类型，所以它们的底层类型不同，从而它们的值也就不能转换到对方的类型。

难道真没有办法实现它们之间的转换了？有，而且有好几种。第一种方法是使用类型非安全指针来实现双向转换，另外两种方法只能实现单向转换。另外的这两种方法要么利用了编译器的漏洞，要么利用了reflect标准库包的设计失误。

先看使用类型非安全指针的实现。


package main 

import "unsafe" 

type MyByte byte 
var ( 
  x = []byte{1, 2, 3} 
  y = []MyByte{1, 2, 3} 
) 

func main() { 
  p := unsafe.Pointer(&y) 
  x = *(*[]byte)(p) 
  x[0] = 99 
  println(y[0]) // 99 
}

在使用类型非安全指针的实现中，转换结果和原切片共享底层元素。

利用标准编译器的bug，我们可以将一个[]byte切片值转换为类型[]MyByte。转换结果和原切片不共享底层元素。


package main 

type MyByte byte 
var ( 
  x = []byte{1, 2, 3} 
  y = []MyByte{1, 2, 3} 
) 

func main() { 
  // 下一行利用了编译器漏洞 
  y = []MyByte(string(x)) 
  y[0] = 99 
  println(x[0]) // 1 
}

Go白皮书提到一个字节切片可以转换为一个字符串，反之亦然。但是什么是字节切片类型呢？底层类型为[]byte的切片类型还是元素类型的底层类型为byte的切片类型？如果字节切片类型定义为元素类型的底层类型为byte的切片类型，则[]MyByte和[]byte都可称为字节切片类型。如果字节切片类型定义为底层类型为[]byte的切片类型，则只有[]byte可以被称为字节切片类型。我们认为标准编译器采纳了底层类型为[]byte的切片类型才称为字节切片这一定义，因为下面这个程序使用标准编译器是编译不过的。


package main 

type MyByte byte 
var ( 
  x = []byte{1, 2, 3} 
  y = []MyByte{1, 2, 3} 
) 
func main() { 
  _ = string(y) // error: 非法转换 
}

但是，标准编译器（v1.12）却认为转换[]MyByte("abc")是合法的。这显然是一个漏洞。

对于码点切片（rune slice）和字符串之间的转换，同样的情况也存在。

对于gccgo编译器来说，此漏洞是对称的，因而更严重。此更严重的漏洞使得上述两种类型的值之间的转换是双向有效的。比如，下面这段代码使用gccgo（v8.0）编译是没问题的。


package main 

type MyByte byte 
var ( 
  x = []byte{1, 2, 3} 
  y = []MyByte{1, 2, 3} 
) 

func main() { 
  // 下一行利用了编译器漏洞 
  y = []MyByte(string(x)) 
  y[0] = 99 
  println(x[0]) // 1 

  // 下一行利用了编译器漏洞 
  x = []byte(string(y)) 
  x[0] = 127 
  println(y[0]) // 99 
}

事实上，gccgo编译器在内置copy和append函数的实现中也存在着同样的漏洞。


package main 

type MyByte byte 
var ( 
  x = []byte{1, 2, 3} 
  y = []MyByte{1, 2, 3} 
) 

func main() { 
  // 下一行利用了编译器漏洞 
  copy(y, string(x)) 
  y[0] = 99 
  println(x[0]) // 1 

  // 下一行利用了编译器漏洞 
  y = append([]MyByte(nil), string(x)...) 
  y[0] = 99 
  println(x[0]) // 1 
}

第三种方法利用了reflect标准库包的设计失误。此失误导致将[]MyByte值单向转换为类型[]byte是可行的，虽然这违反了Go类型系统确定的规则。使用第三种方法得到的结果切片和原切片共享底层元素。


package main 

import "reflect" 

type MyByte byte 
var ( 
  x = []byte{1, 2, 3} 
  y = []MyByte{1, 2, 3} 
) 

func main() { 
  v := reflect.ValueOf(y) 
  x = v.Bytes() 
  x[0] = 99 
  println(y[0]) // 99 
}
9