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

假如一个类型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切片值转换为string, 再把string转换为类型[]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
}