/src/php-src/ext/pcre/pcre2lib/pcre2_serialize.c
Line | Count | Source (jump to first uncovered line) |
1 | | /************************************************* |
2 | | * Perl-Compatible Regular Expressions * |
3 | | *************************************************/ |
4 | | |
5 | | /* PCRE is a library of functions to support regular expressions whose syntax |
6 | | and semantics are as close as possible to those of the Perl 5 language. |
7 | | |
8 | | Written by Philip Hazel |
9 | | Original API code Copyright (c) 1997-2012 University of Cambridge |
10 | | New API code Copyright (c) 2016-2024 University of Cambridge |
11 | | |
12 | | ----------------------------------------------------------------------------- |
13 | | Redistribution and use in source and binary forms, with or without |
14 | | modification, are permitted provided that the following conditions are met: |
15 | | |
16 | | * Redistributions of source code must retain the above copyright notice, |
17 | | this list of conditions and the following disclaimer. |
18 | | |
19 | | * Redistributions in binary form must reproduce the above copyright |
20 | | notice, this list of conditions and the following disclaimer in the |
21 | | documentation and/or other materials provided with the distribution. |
22 | | |
23 | | * Neither the name of the University of Cambridge nor the names of its |
24 | | contributors may be used to endorse or promote products derived from |
25 | | this software without specific prior written permission. |
26 | | |
27 | | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
28 | | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
29 | | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
30 | | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
31 | | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
32 | | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
33 | | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
34 | | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
35 | | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
36 | | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
37 | | POSSIBILITY OF SUCH DAMAGE. |
38 | | ----------------------------------------------------------------------------- |
39 | | */ |
40 | | |
41 | | /* This module contains functions for serializing and deserializing |
42 | | a sequence of compiled codes. */ |
43 | | |
44 | | |
45 | | #ifdef HAVE_CONFIG_H |
46 | | #include "config.h" |
47 | | #endif |
48 | | |
49 | | |
50 | | #include "pcre2_internal.h" |
51 | | |
52 | | /* Magic number to provide a small check against being handed junk. */ |
53 | | |
54 | 0 | #define SERIALIZED_DATA_MAGIC 0x50523253u |
55 | | |
56 | | /* Deserialization is limited to the current PCRE version and |
57 | | character width. */ |
58 | | |
59 | | #define SERIALIZED_DATA_VERSION \ |
60 | 0 | ((PCRE2_MAJOR) | ((PCRE2_MINOR) << 16)) |
61 | | |
62 | | #define SERIALIZED_DATA_CONFIG \ |
63 | 0 | (sizeof(PCRE2_UCHAR) | ((sizeof(void*)) << 8) | ((sizeof(PCRE2_SIZE)) << 16)) |
64 | | |
65 | | |
66 | | |
67 | | /************************************************* |
68 | | * Serialize compiled patterns * |
69 | | *************************************************/ |
70 | | |
71 | | PCRE2_EXP_DEFN int32_t PCRE2_CALL_CONVENTION |
72 | | pcre2_serialize_encode(const pcre2_code **codes, int32_t number_of_codes, |
73 | | uint8_t **serialized_bytes, PCRE2_SIZE *serialized_size, |
74 | | pcre2_general_context *gcontext) |
75 | 0 | { |
76 | 0 | uint8_t *bytes; |
77 | 0 | uint8_t *dst_bytes; |
78 | 0 | int32_t i; |
79 | 0 | PCRE2_SIZE total_size; |
80 | 0 | const pcre2_real_code *re; |
81 | 0 | const uint8_t *tables; |
82 | 0 | pcre2_serialized_data *data; |
83 | |
|
84 | 0 | const pcre2_memctl *memctl = (gcontext != NULL) ? |
85 | 0 | &gcontext->memctl : &PRIV(default_compile_context).memctl; |
86 | |
|
87 | 0 | if (codes == NULL || serialized_bytes == NULL || serialized_size == NULL) |
88 | 0 | return PCRE2_ERROR_NULL; |
89 | | |
90 | 0 | if (number_of_codes <= 0) return PCRE2_ERROR_BADDATA; |
91 | | |
92 | | /* Compute total size. */ |
93 | 0 | total_size = sizeof(pcre2_serialized_data) + TABLES_LENGTH; |
94 | 0 | tables = NULL; |
95 | |
|
96 | 0 | for (i = 0; i < number_of_codes; i++) |
97 | 0 | { |
98 | 0 | if (codes[i] == NULL) return PCRE2_ERROR_NULL; |
99 | 0 | re = (const pcre2_real_code *)(codes[i]); |
100 | 0 | if (re->magic_number != MAGIC_NUMBER) return PCRE2_ERROR_BADMAGIC; |
101 | 0 | if (tables == NULL) |
102 | 0 | tables = re->tables; |
103 | 0 | else if (tables != re->tables) |
104 | 0 | return PCRE2_ERROR_MIXEDTABLES; |
105 | 0 | total_size += re->blocksize; |
106 | 0 | } |
107 | | |
108 | | /* Initialize the byte stream. */ |
109 | 0 | bytes = memctl->malloc(total_size + sizeof(pcre2_memctl), memctl->memory_data); |
110 | 0 | if (bytes == NULL) return PCRE2_ERROR_NOMEMORY; |
111 | | |
112 | | /* The controller is stored as a hidden parameter. */ |
113 | 0 | memcpy(bytes, memctl, sizeof(pcre2_memctl)); |
114 | 0 | bytes += sizeof(pcre2_memctl); |
115 | |
|
116 | 0 | data = (pcre2_serialized_data *)bytes; |
117 | 0 | data->magic = SERIALIZED_DATA_MAGIC; |
118 | 0 | data->version = SERIALIZED_DATA_VERSION; |
119 | 0 | data->config = SERIALIZED_DATA_CONFIG; |
120 | 0 | data->number_of_codes = number_of_codes; |
121 | | |
122 | | /* Copy all compiled code data. */ |
123 | 0 | dst_bytes = bytes + sizeof(pcre2_serialized_data); |
124 | 0 | memcpy(dst_bytes, tables, TABLES_LENGTH); |
125 | 0 | dst_bytes += TABLES_LENGTH; |
126 | |
|
127 | 0 | for (i = 0; i < number_of_codes; i++) |
128 | 0 | { |
129 | 0 | re = (const pcre2_real_code *)(codes[i]); |
130 | 0 | (void)memcpy(dst_bytes, (const char *)re, re->blocksize); |
131 | | |
132 | | /* Certain fields in the compiled code block are re-set during |
133 | | deserialization. In order to ensure that the serialized data stream is always |
134 | | the same for the same pattern, set them to zero here. We can't assume the |
135 | | copy of the pattern is correctly aligned for accessing the fields as part of |
136 | | a structure. Note the use of sizeof(void *) in the second of these, to |
137 | | specify the size of a pointer. If sizeof(uint8_t *) is used (tables is a |
138 | | pointer to uint8_t), gcc gives a warning because the first argument is also a |
139 | | pointer to uint8_t. Casting the first argument to (void *) can stop this, but |
140 | | it didn't stop Coverity giving the same complaint. */ |
141 | |
|
142 | 0 | (void)memset(dst_bytes + offsetof(pcre2_real_code, memctl), 0, |
143 | 0 | sizeof(pcre2_memctl)); |
144 | 0 | (void)memset(dst_bytes + offsetof(pcre2_real_code, tables), 0, |
145 | 0 | sizeof(void *)); |
146 | 0 | (void)memset(dst_bytes + offsetof(pcre2_real_code, executable_jit), 0, |
147 | 0 | sizeof(void *)); |
148 | |
|
149 | 0 | dst_bytes += re->blocksize; |
150 | 0 | } |
151 | |
|
152 | 0 | *serialized_bytes = bytes; |
153 | 0 | *serialized_size = total_size; |
154 | 0 | return number_of_codes; |
155 | 0 | } |
156 | | |
157 | | |
158 | | /************************************************* |
159 | | * Deserialize compiled patterns * |
160 | | *************************************************/ |
161 | | |
162 | | PCRE2_EXP_DEFN int32_t PCRE2_CALL_CONVENTION |
163 | | pcre2_serialize_decode(pcre2_code **codes, int32_t number_of_codes, |
164 | | const uint8_t *bytes, pcre2_general_context *gcontext) |
165 | 0 | { |
166 | 0 | const pcre2_serialized_data *data = (const pcre2_serialized_data *)bytes; |
167 | 0 | const pcre2_memctl *memctl = (gcontext != NULL) ? |
168 | 0 | &gcontext->memctl : &PRIV(default_compile_context).memctl; |
169 | |
|
170 | 0 | const uint8_t *src_bytes; |
171 | 0 | pcre2_real_code *dst_re; |
172 | 0 | uint8_t *tables; |
173 | 0 | int32_t i, j; |
174 | | |
175 | | /* Sanity checks. */ |
176 | |
|
177 | 0 | if (data == NULL || codes == NULL) return PCRE2_ERROR_NULL; |
178 | 0 | if (number_of_codes <= 0) return PCRE2_ERROR_BADDATA; |
179 | 0 | if (data->number_of_codes <= 0) return PCRE2_ERROR_BADSERIALIZEDDATA; |
180 | 0 | if (data->magic != SERIALIZED_DATA_MAGIC) return PCRE2_ERROR_BADMAGIC; |
181 | 0 | if (data->version != SERIALIZED_DATA_VERSION) return PCRE2_ERROR_BADMODE; |
182 | 0 | if (data->config != SERIALIZED_DATA_CONFIG) return PCRE2_ERROR_BADMODE; |
183 | | |
184 | 0 | if (number_of_codes > data->number_of_codes) |
185 | 0 | number_of_codes = data->number_of_codes; |
186 | |
|
187 | 0 | src_bytes = bytes + sizeof(pcre2_serialized_data); |
188 | | |
189 | | /* Decode tables. The reference count for the tables is stored immediately |
190 | | following them. */ |
191 | |
|
192 | 0 | tables = memctl->malloc(TABLES_LENGTH + sizeof(PCRE2_SIZE), memctl->memory_data); |
193 | 0 | if (tables == NULL) return PCRE2_ERROR_NOMEMORY; |
194 | | |
195 | 0 | memcpy(tables, src_bytes, TABLES_LENGTH); |
196 | 0 | *(PCRE2_SIZE *)(tables + TABLES_LENGTH) = number_of_codes; |
197 | 0 | src_bytes += TABLES_LENGTH; |
198 | | |
199 | | /* Decode the byte stream. We must not try to read the size from the compiled |
200 | | code block in the stream, because it might be unaligned, which causes errors on |
201 | | hardware such as Sparc-64 that doesn't like unaligned memory accesses. The type |
202 | | of the blocksize field is given its own name to ensure that it is the same here |
203 | | as in the block. */ |
204 | |
|
205 | 0 | for (i = 0; i < number_of_codes; i++) |
206 | 0 | { |
207 | 0 | CODE_BLOCKSIZE_TYPE blocksize; |
208 | 0 | memcpy(&blocksize, src_bytes + offsetof(pcre2_real_code, blocksize), |
209 | 0 | sizeof(CODE_BLOCKSIZE_TYPE)); |
210 | 0 | if (blocksize <= sizeof(pcre2_real_code)) |
211 | 0 | return PCRE2_ERROR_BADSERIALIZEDDATA; |
212 | | |
213 | | /* The allocator provided by gcontext replaces the original one. */ |
214 | | |
215 | 0 | dst_re = (pcre2_real_code *)PRIV(memctl_malloc)(blocksize, |
216 | 0 | (pcre2_memctl *)gcontext); |
217 | 0 | if (dst_re == NULL) |
218 | 0 | { |
219 | 0 | memctl->free(tables, memctl->memory_data); |
220 | 0 | for (j = 0; j < i; j++) |
221 | 0 | { |
222 | 0 | memctl->free(codes[j], memctl->memory_data); |
223 | 0 | codes[j] = NULL; |
224 | 0 | } |
225 | 0 | return PCRE2_ERROR_NOMEMORY; |
226 | 0 | } |
227 | | |
228 | | /* The new allocator must be preserved. */ |
229 | | |
230 | 0 | memcpy(((uint8_t *)dst_re) + sizeof(pcre2_memctl), |
231 | 0 | src_bytes + sizeof(pcre2_memctl), blocksize - sizeof(pcre2_memctl)); |
232 | 0 | if (dst_re->magic_number != MAGIC_NUMBER || |
233 | 0 | dst_re->name_entry_size > MAX_NAME_SIZE + IMM2_SIZE + 1 || |
234 | 0 | dst_re->name_count > MAX_NAME_COUNT) |
235 | 0 | { |
236 | 0 | memctl->free(dst_re, memctl->memory_data); |
237 | 0 | return PCRE2_ERROR_BADSERIALIZEDDATA; |
238 | 0 | } |
239 | | |
240 | | /* At the moment only one table is supported. */ |
241 | | |
242 | 0 | dst_re->tables = tables; |
243 | 0 | dst_re->executable_jit = NULL; |
244 | 0 | dst_re->flags |= PCRE2_DEREF_TABLES; |
245 | |
|
246 | 0 | codes[i] = dst_re; |
247 | 0 | src_bytes += blocksize; |
248 | 0 | } |
249 | | |
250 | 0 | return number_of_codes; |
251 | 0 | } |
252 | | |
253 | | |
254 | | /************************************************* |
255 | | * Get the number of serialized patterns * |
256 | | *************************************************/ |
257 | | |
258 | | PCRE2_EXP_DEFN int32_t PCRE2_CALL_CONVENTION |
259 | | pcre2_serialize_get_number_of_codes(const uint8_t *bytes) |
260 | 0 | { |
261 | 0 | const pcre2_serialized_data *data = (const pcre2_serialized_data *)bytes; |
262 | |
|
263 | 0 | if (data == NULL) return PCRE2_ERROR_NULL; |
264 | 0 | if (data->magic != SERIALIZED_DATA_MAGIC) return PCRE2_ERROR_BADMAGIC; |
265 | 0 | if (data->version != SERIALIZED_DATA_VERSION) return PCRE2_ERROR_BADMODE; |
266 | 0 | if (data->config != SERIALIZED_DATA_CONFIG) return PCRE2_ERROR_BADMODE; |
267 | | |
268 | 0 | return data->number_of_codes; |
269 | 0 | } |
270 | | |
271 | | |
272 | | /************************************************* |
273 | | * Free the allocated stream * |
274 | | *************************************************/ |
275 | | |
276 | | PCRE2_EXP_DEFN void PCRE2_CALL_CONVENTION |
277 | | pcre2_serialize_free(uint8_t *bytes) |
278 | 0 | { |
279 | 0 | if (bytes != NULL) |
280 | 0 | { |
281 | 0 | pcre2_memctl *memctl = (pcre2_memctl *)(bytes - sizeof(pcre2_memctl)); |
282 | 0 | memctl->free(memctl, memctl->memory_data); |
283 | 0 | } |
284 | 0 | } |
285 | | |
286 | | /* End of pcre2_serialize.c */ |