为什么需要检查 UTF-8 编码
根据 WebSocket 协议的要求 5.6 数据帧，如果 Frame 的 Opcode 是 0x1 的话，则表示这是一个文本帧，即其 “Application Data” 是使用 UTF-8 编码的字符串。不过由于消息也可以使用多个 Frame 进行分片传输，所以在验证文本消息的编码时，需要收集到消息的所有 Frames 后，提取所有的 Frame 中的 “Application Data” 组成一个大的 “Application Data”，然后验证这个大的 “Application Data” 中的字节是不是合法的 UTF-8 编码。
既然协议中要求了文本消息必须使用 UTF-8 编码，那么反过来，验证编码是否是 UTF-8就可以一定程度上确定消息的完整性。
Unicode
简单的说 Unicode 就是一种字符的编码方式，此编码方式一般使用两个字节（UCS-2）去表示一个字符，比如“汉”这个中文字符，其 unicode 编码的十六进制表示就是 0x6c49。
UTF-8
UTF-8 的全称是 8-bit Unicode Transformation Format 中文就是 “8 位的 unicode 转换格式”。UTF-8 是具体的 Unicode 实现方式中的一种，套用 wiki 上的一段话：
但是在实际传输过程中，由于不同系统平台的设计不一定一致，以及出于节省空间的目的，对Unicode编码的实现方式有所不同。Unicode的实现方式称为Unicode转换格式（Unicode Transformation Format，简称为UTF）
UTF-8 的编码方式
UTF-8使用一至六个字节为每个字符编码（尽管如此，2003年11月UTF-8被RFC 3629重新规范，只能使用原来Unicode定义的区域，U+0000到U+10FFFF，也就是说最多四个字节）
Char. number range | UTF-8 octet sequence
(hexadecimal) | (binary)
--------------------+---------------------------------------------
0000 0000-0000 007F | 0xxxxxxx
0000 0080-0000 07FF | 110xxxxx 10xxxxxx
0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
复制代码- 对于 UTF-8 编码中的任意字节B，如果B的第一位为0，则B为ASCII码，并且B独立的表示一个字符；
- 如果B的第一位为1，第二位为0，则B为一个非ASCII字符（该字符由多个字节表示）中的一个字节，并且不是字符的第一个字节编码；
- 如果B的前两位为1，第三位为0，则B为一个非ASCII字符（该字符由多个字节表示）中的第一个字节，并且该字符由两个字节表示；
- 如果B的前三位为1，第四位为0，则B为一个非ASCII字符（该字符由多个字节表示）中的第一个字节，并且该字符由三个字节表示；
- 如果B的前四位为1，第五位为0，则B为一个非ASCII字符（该字符由多个字节表示）中的第一个字节，并且该字符由四个字节表示；
所以我们只需要兼容最新的标准即可。如果你还没有明白 UTF-8 编码的含义，我们可以看一个具体的例子，比如中文的 “汉”，其 Unicode 编码的十六进制表示是 0x6c49，那么很明显，它必然落在 0x00000800 – 0x0000FFFF 这个区间内，而这个区间的字符必须使用 3 个字节的 UTF-8 编码，表示成 1110xxxx 10xxxxxx 10xxxxxx 的形式。
所以对于 0x6c49 要转成 UTF-8 编码：
- 将
0x6c49右移 12 位，取出最高的 4 位，然后或上11100000（即0xE0），得到第一个字节0xE6 - 将
0x6c49与上0000111111000000（即0xFC0） 后、右移 6 位，这样得到中间的 6 位，然后或上10000000（即0x80） 得到第二个字节0xB1 - 将
0x6c49与上0000000000111111（即0x3F） 后，或上10000000（即0x80） 得到第三个字节0x89
于是中文字符 “汉” 的 UTF-8 编码就是 0xE6 0xB1 0x89，是不是 so easy。
现在，假设现在我们得到一串数据，它包含 3 个字节，其内容是 0xE6 0xB1 0x89，并且我们知道这串数据采用的是 UTF-8 编码，我们怎么得知其对应的 unicode 编码是什么呢？一种一种的情况试啊！
- 取出第一个字节，检查其最高位是不是 0，如果是0，那么当前字节即表示一个字符，如果不是，进行下一步
- 检查最高 3 位是不是
110，如果是的话，那么接下来的一个字节和当前字节合起来表示一个字符，如果不是，进行下一步 - 检查最高 4 位是不是
1110，如果是的话，那么接下来的两个字节和当前字节合起来表示一个字符，如果不是，进行下一步 - 检查最高 5 位是不是
11110，如果是的话，那么接下来的三个字节和当前字节合起来表示一个字符，如果不是，进行下一步 - 根据最新的标准，UTF-8 编码最多只使用四个字节去表示一个字符，所以到了这一步就说明编码错误了
- 另外除了表示剩余字节数的那个字节外，其余字节的最高两位都必须是
10 U+0000不可以使用两个字节进行编码U+D800~U+DFFF（左右边界不可取）是保留段，不可以使用
那么看看刚才的例子，我们取出第一个字节 0xE6（即 1110 0110），我要逐一的尝试每一种情况，最后我们发现它的最高 4 位是 1110 那么它之后的两个字节和它一起表示一个字符。
- 首先我们先将第一个字节与上
0xF，这样可以得到实际的 4 位 - 取出紧随的第二个字节，将其与上
0x3F，这样可以得到实际的 6 位 - 取出紧随的第三个字节，将其与上
0x3F，这样可以得到实际的 6 位
最后将这 16 个数位按照取出的顺序从左往右放存放到三个字节中。
代码
先放 javascript 的，注意这里使用了 ES6 中的 String.prototype.codePointAt 方法，因为在 ES5 中对于超过了 0xFFFF 的字符使用 String.prototype.charCodeAt 并不能正确的获取其 unicode 编码:
"use strict";
console.assert(typeof String.prototype.codePointAt == 'function', "Current env doesn't support ECMAScript 6!");
Array.prototype.equal = function (b) {
return this.every(function (e, i) {
return e === b[i];
});
};
var unicode2utf8 = function (unicode) {
unicode = typeof unicode == 'string' ? unicode.codePointAt(0) : unicode;
if (unicode <= 0x7F) {
return [unicode]
} else if (unicode >= 0x80 && unicode <= 0x7FF) {
return [
unicode >> 6 | 0xC0,
unicode & 0x3F | 0x80
];
} else if (unicode >= 0x800 && unicode <= 0xFFFF) {
return [
unicode >> 12 | 0xE0,
(unicode & 0xFC0) >> 6 | 0x80,
unicode & 0x3F | 0x80
];
} else if (unicode >= 0x10000 && unicode <= 0x10FFFF) {
return [
unicode >> 18 | 0xF0,
(unicode & 0x3F000) >> 12 | 0x80,
(unicode & 0xFC0) >> 6 | 0x80,
unicode & 0x3F | 0x80
];
} else {
throw new Error('deformed unicode: ' + unicode);
}
};
console.assert(unicode2utf8('u').equal([0x75]), "unicode2utf8 not pass 'u'");
console.assert(unicode2utf8('©').equal([0xC2, 0xA9]), "unicode2utf8 not pass '©'");
console.assert(unicode2utf8('汉').equal([0xE6, 0xB1, 0x89]), "unicode2utf8 not pass '汉'");
console.assert(unicode2utf8('?').equal([0xF0, 0x9F, 0x98, 0x84]), "unicode2utf8 not pass '?'");
var utf82unicode = function (utf8) {
var ul = utf8.length, byte = utf8[0];
if (ul == 0) {
throw new Error('empty utf8');
}
if (byte <= 127) {
return byte;
} else if (byte >> 5 == 0x6 && ul == 2) {
return ((byte & 0x1F) << 6) |
utf8[1] & 0x3F;
} else if (byte >> 4 == 0xE && ul == 3) {
return ((byte & 0xF) << 12) |
((utf8[1] & 0x3F) << 6) |
(utf8[2] & 0x3F)
} else if (byte >> 3 == 0x1E && ul == 4) {
return ((byte & 0x7) << 18) |
((utf8[1] & 0x3F) << 12) |
((utf8[2] & 0x3F) << 6) |
(utf8[3] & 0x3F)
} else {
throw new Error('deformed utf8: ' + utf8);
}
};
console.assert(utf82unicode([0x75]) == 'u'.codePointAt(0), "utf82unicode not pass 'u'");
console.assert(utf82unicode([0xC2, 0xA9]) == '©'.codePointAt(0), "utf82unicode not pass '©'");
console.assert(utf82unicode([0xE6, 0xB1, 0x89]) == '汉'.codePointAt(0), "utf82unicode not pass '汉'");
console.assert(utf82unicode([0xF0, 0x9F, 0x98, 0x84]) == '?'.codePointAt(0), "utf82unicode not pass '?'");
复制代码接下来是 golang 的，其中的 IsIntactUtf8 函数就是本文讨论的主题 - 检查UTF-8编码的完整性：
func Unicode2utf8(u uint32) (u8 []byte, err error) {
if u <= 0x7F {
return []byte{byte(u)}, nil
} else if u >= 0x80 && u <= 0x7FF {
return []byte{
byte(u>>6 | 0xC0),
byte(u&0x3F | 0x80),
}, nil
} else if u >= 0x800 && u <= 0xFFFF {
return []byte{
byte(u>>12 | 0xE0),
byte((u&0xFC0)>>6 | 0x80),
byte(u&0x3F | 0x80),
}, nil
} else if u >= 0x10000 && u <= 0x10FFFF {
return []byte{
byte(u>>18 | 0xF0),
byte((u&0x3F000)>>12 | 0x80),
byte((u&0xFC0)>>6 | 0x80),
byte(u&0x3F | 0x80),
}, nil
}
return nil, errors.New(fmt.Sprintf("deformed unicode: %d", u))
}
func TestUnicode2utf8(t *testing.T) {
u8, _ := Unicode2utf8(0x75)
if !reflect.DeepEqual(u8, []byte{0x75}) {
t.Fatal("not pass 'u'")
}
u8, _ = Unicode2utf8(0xA9)
if !reflect.DeepEqual(u8, []byte{0xC2, 0xA9}) {
t.Fatal("not pass '©'")
}
u8, _ = Unicode2utf8(0x6C49)
if !reflect.DeepEqual(u8, []byte{0xE6, 0xB1, 0x89}) {
t.Fatal("not pass '汉'")
}
u8, _ = Unicode2utf8(0x1F604)
if !reflect.DeepEqual(u8, []byte{0xF0, 0x9F, 0x98, 0x84}) {
t.Fatal("not pass '?'")
}
}
func Utf82unicode(u8 []byte) (u uint32, err error) {
u8l := len(u8)
if u8l == 0 {
return 0, errors.New("empty utf8")
}
b1 := u8[0]
if b1 <= 0x7F {
return uint32(b1), nil
} else if b1>>5 == 0x6 && u8l == 2 {
return uint32(b1&0x1F)<<6 |
uint32(u8[1]&0x3F), nil
} else if b1>>4 == 0xE && u8l == 3 {
return uint32(b1&0xF)<<12 |
uint32(u8[1]&0x3F)<<6 |
uint32(u8[2]&0x3F), nil
} else if b1>>3 == 0x1E && u8l == 4 {
return uint32(b1&0x7)<<18 |
uint32(u8[1]&0x3F)<<12 |
uint32(u8[2]&0x3F)<<6 |
uint32(u8[3]&0x3F), nil
}
return 0, errors.New(fmt.Sprintf("deformed utf8: %d", u8))
}
func TestUtf82unicode(t *testing.T) {
u, _ := Utf82unicode([]byte{0x75})
if u != 0x75 {
t.Fatal("not pass 'u'")
}
u, _ = Utf82unicode([]byte{0xC2, 0xA9})
if u != 0xA9 {
t.Fatal("not pass '©'")
}
u, _ = Utf82unicode([]byte{0xE6, 0xB1, 0x89})
if u != 0x6C49 {
t.Fatalf("not pass '汉': %x", u)
}
u, _ = Utf82unicode([]byte{0xF0, 0x9F, 0x98, 0x84})
if u != 0x1F604 {
t.Fatal("not pass '?'")
}
}
func IsIntactUtf8(u8 []byte) bool {
i := 0
u8l := len(u8)
for {
if i == u8l {
break
}
b1 := u8[i]
var tu uint32
switch {
case b1 <= 0x7F:
case b1>>5 == 0x6:
if u8l-i >= 2 &&
u8[i+1]&0xC0 == 0x80 &&
// U+0000 encoded in two bytes: incorrect
(u8[i] > 0xC0 || u8[i+1] > 0x80) {
i++
} else {
return false
}
case b1>>4 == 0xE:
if u8l-i >= 3 {
tu = uint32(b1&0xF)<<12 |
uint32(u8[i+1]&0x3F)<<6 |
uint32(u8[i+2]&0x3F)
// UTF-8 prohibits encoding character numbers between U+D800 and U+DFFF
if tu >= 0x800 && tu <= 0xFFFF && !(tu >= 0xD800 && tu <= 0xDFFF) {
i += 2
} else {
return false
}
} else {
return false
}
case b1>>3 == 0x1E:
if u8l-i >= 4 &&
u8[i]&0x7 <= 0x4 &&
u8[i+1]&0xC0 == 0x80 && u8[i+1]&0x3F <= 0xF &&
u8[i+2]&0xC0 == 0x80 &&
u8[i+3]&0xC0 == 0x80 {
i += 3
} else {
return false
}
default:
return false
}
i++
}
return i == u8l
}
type ValidTest struct {
in string
out bool
}
var validTests = []ValidTest{
{"", true},
{"a", true},
{"abc", true},
{"Ж", true},
{"ЖЖ", true},
{"брэд-ЛГТМ", true},
{"☺☻☹", true},
{string([]byte{66, 250}), false},
{string([]byte{66, 250, 67}), false},
{"a\uFFFDb", true},
{string("\xF4\x8F\xBF\xBF"), true}, // U+10FFFF
{string("\xF4\x90\x80\x80"), false}, // U+10FFFF+1; out of range
{string("\xF7\xBF\xBF\xBF"), false}, // 0x1FFFFF; out of range
{string("\xFB\xBF\xBF\xBF\xBF"), false}, // 0x3FFFFFF; out of range
{string("\xc0\x80"), false}, // U+0000 encoded in two bytes: incorrect
{string("\xed\xa0\x80"), false}, // U+D800 high surrogate (sic)
{string("\xed\xbf\xbf"), false}, // U+DFFF low surrogate (sic)
}
func TestIsIntactUtf8(t *testing.T) {
for i, tt := range validTests {
if IsIntactUtf8([]byte(tt.in)) != tt.out {
t.Fatalf("[CASE %d] IsIntactUtf8(%q) = %v; want %v", i, tt.in, !tt.out, tt.out)
}
}
}
复制代码原理以及代码都给出来了，应该会对 UTF-8 以及 UTF-8 与 Unicode 之间的关系不明了的同学有些帮助吧。
扫一扫
604
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
