/src/boringssl/crypto/bytestring/unicode.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* Copyright (c) 2018, Google Inc. |
2 | | * |
3 | | * Permission to use, copy, modify, and/or distribute this software for any |
4 | | * purpose with or without fee is hereby granted, provided that the above |
5 | | * copyright notice and this permission notice appear in all copies. |
6 | | * |
7 | | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
8 | | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
9 | | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
10 | | * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
11 | | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
12 | | * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
13 | | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ |
14 | | |
15 | | #include <openssl/bytestring.h> |
16 | | |
17 | | #include "internal.h" |
18 | | |
19 | | |
20 | 0 | static int is_valid_code_point(uint32_t v) { |
21 | | // References in the following are to Unicode 15.0.0. |
22 | 0 | if (// The Unicode space runs from zero to 0x10ffff (3.4 D9). |
23 | 0 | v > 0x10ffff || |
24 | | // Values 0x...fffe, 0x...ffff, and 0xfdd0-0xfdef are permanently reserved |
25 | | // as noncharacters (3.4 D14). See also 23.7. As our APIs are intended for |
26 | | // "open interchange", such as ASN.1, we reject them. |
27 | 0 | (v & 0xfffe) == 0xfffe || |
28 | 0 | (v >= 0xfdd0 && v <= 0xfdef) || |
29 | | // Surrogate code points are invalid (3.2 C1). |
30 | 0 | (v >= 0xd800 && v <= 0xdfff)) { |
31 | 0 | return 0; |
32 | 0 | } |
33 | 0 | return 1; |
34 | 0 | } |
35 | | |
36 | | // BOTTOM_BITS returns a byte with the bottom |n| bits set. |
37 | 0 | #define BOTTOM_BITS(n) (uint8_t)((1u << (n)) - 1) |
38 | | |
39 | | // TOP_BITS returns a byte with the top |n| bits set. |
40 | 0 | #define TOP_BITS(n) ((uint8_t)~BOTTOM_BITS(8 - (n))) |
41 | | |
42 | 0 | int CBS_get_utf8(CBS *cbs, uint32_t *out) { |
43 | 0 | uint8_t c; |
44 | 0 | if (!CBS_get_u8(cbs, &c)) { |
45 | 0 | return 0; |
46 | 0 | } |
47 | 0 | if (c <= 0x7f) { |
48 | 0 | *out = c; |
49 | 0 | return 1; |
50 | 0 | } |
51 | 0 | uint32_t v, lower_bound; |
52 | 0 | size_t len; |
53 | 0 | if ((c & TOP_BITS(3)) == TOP_BITS(2)) { |
54 | 0 | v = c & BOTTOM_BITS(5); |
55 | 0 | len = 1; |
56 | 0 | lower_bound = 0x80; |
57 | 0 | } else if ((c & TOP_BITS(4)) == TOP_BITS(3)) { |
58 | 0 | v = c & BOTTOM_BITS(4); |
59 | 0 | len = 2; |
60 | 0 | lower_bound = 0x800; |
61 | 0 | } else if ((c & TOP_BITS(5)) == TOP_BITS(4)) { |
62 | 0 | v = c & BOTTOM_BITS(3); |
63 | 0 | len = 3; |
64 | 0 | lower_bound = 0x10000; |
65 | 0 | } else { |
66 | 0 | return 0; |
67 | 0 | } |
68 | 0 | for (size_t i = 0; i < len; i++) { |
69 | 0 | if (!CBS_get_u8(cbs, &c) || |
70 | 0 | (c & TOP_BITS(2)) != TOP_BITS(1)) { |
71 | 0 | return 0; |
72 | 0 | } |
73 | 0 | v <<= 6; |
74 | 0 | v |= c & BOTTOM_BITS(6); |
75 | 0 | } |
76 | 0 | if (!is_valid_code_point(v) || |
77 | 0 | v < lower_bound) { |
78 | 0 | return 0; |
79 | 0 | } |
80 | 0 | *out = v; |
81 | 0 | return 1; |
82 | 0 | } |
83 | | |
84 | 0 | int CBS_get_latin1(CBS *cbs, uint32_t *out) { |
85 | 0 | uint8_t c; |
86 | 0 | if (!CBS_get_u8(cbs, &c)) { |
87 | 0 | return 0; |
88 | 0 | } |
89 | 0 | *out = c; |
90 | 0 | return 1; |
91 | 0 | } |
92 | | |
93 | 0 | int CBS_get_ucs2_be(CBS *cbs, uint32_t *out) { |
94 | | // Note UCS-2 (used by BMPString) does not support surrogates. |
95 | 0 | uint16_t c; |
96 | 0 | if (!CBS_get_u16(cbs, &c) || |
97 | 0 | !is_valid_code_point(c)) { |
98 | 0 | return 0; |
99 | 0 | } |
100 | 0 | *out = c; |
101 | 0 | return 1; |
102 | 0 | } |
103 | | |
104 | 0 | int CBS_get_utf32_be(CBS *cbs, uint32_t *out) { |
105 | 0 | return CBS_get_u32(cbs, out) && is_valid_code_point(*out); |
106 | 0 | } |
107 | | |
108 | 0 | size_t CBB_get_utf8_len(uint32_t u) { |
109 | 0 | if (u <= 0x7f) { |
110 | 0 | return 1; |
111 | 0 | } |
112 | 0 | if (u <= 0x7ff) { |
113 | 0 | return 2; |
114 | 0 | } |
115 | 0 | if (u <= 0xffff) { |
116 | 0 | return 3; |
117 | 0 | } |
118 | 0 | return 4; |
119 | 0 | } |
120 | | |
121 | 0 | int CBB_add_utf8(CBB *cbb, uint32_t u) { |
122 | 0 | if (!is_valid_code_point(u)) { |
123 | 0 | return 0; |
124 | 0 | } |
125 | 0 | if (u <= 0x7f) { |
126 | 0 | return CBB_add_u8(cbb, (uint8_t)u); |
127 | 0 | } |
128 | 0 | if (u <= 0x7ff) { |
129 | 0 | return CBB_add_u8(cbb, TOP_BITS(2) | (u >> 6)) && |
130 | 0 | CBB_add_u8(cbb, TOP_BITS(1) | (u & BOTTOM_BITS(6))); |
131 | 0 | } |
132 | 0 | if (u <= 0xffff) { |
133 | 0 | return CBB_add_u8(cbb, TOP_BITS(3) | (u >> 12)) && |
134 | 0 | CBB_add_u8(cbb, TOP_BITS(1) | ((u >> 6) & BOTTOM_BITS(6))) && |
135 | 0 | CBB_add_u8(cbb, TOP_BITS(1) | (u & BOTTOM_BITS(6))); |
136 | 0 | } |
137 | 0 | if (u <= 0x10ffff) { |
138 | 0 | return CBB_add_u8(cbb, TOP_BITS(4) | (u >> 18)) && |
139 | 0 | CBB_add_u8(cbb, TOP_BITS(1) | ((u >> 12) & BOTTOM_BITS(6))) && |
140 | 0 | CBB_add_u8(cbb, TOP_BITS(1) | ((u >> 6) & BOTTOM_BITS(6))) && |
141 | 0 | CBB_add_u8(cbb, TOP_BITS(1) | (u & BOTTOM_BITS(6))); |
142 | 0 | } |
143 | 0 | return 0; |
144 | 0 | } |
145 | | |
146 | 0 | int CBB_add_latin1(CBB *cbb, uint32_t u) { |
147 | 0 | return u <= 0xff && CBB_add_u8(cbb, (uint8_t)u); |
148 | 0 | } |
149 | | |
150 | 0 | int CBB_add_ucs2_be(CBB *cbb, uint32_t u) { |
151 | 0 | return u <= 0xffff && is_valid_code_point(u) && CBB_add_u16(cbb, (uint16_t)u); |
152 | 0 | } |
153 | | |
154 | 0 | int CBB_add_utf32_be(CBB *cbb, uint32_t u) { |
155 | 0 | return is_valid_code_point(u) && CBB_add_u32(cbb, u); |
156 | 0 | } |