Branch data Line data Source code
1 : : // Copyright 2014 BitPay Inc.
2 : : // Copyright (c) 2015-present The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or https://opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <univalue.h>
7 : : #include <univalue_utffilter.h>
8 : :
9 : : #include <cstdint>
10 : : #include <cstring>
11 : : #include <string>
12 : : #include <string_view>
13 : : #include <utility>
14 : : #include <vector>
15 : :
16 : : /*
17 : : * According to stackexchange, the original json test suite wanted
18 : : * to limit depth to 22. Widely-deployed PHP bails at depth 512,
19 : : * so we will follow PHP's lead, which should be more than sufficient
20 : : * (further stackexchange comments indicate depth > 32 rarely occurs).
21 : : */
22 : : static constexpr size_t MAX_JSON_DEPTH = 512;
23 : :
24 : 8411081 : static bool json_isdigit(int ch)
25 : : {
26 : 8411081 : return ((ch >= '0') && (ch <= '9'));
27 : : }
28 : :
29 : : // convert hexadecimal string to unsigned integer
30 : 673 : static const char *hatoui(const char *first, const char *last,
31 : : unsigned int& out)
32 : : {
33 : 673 : unsigned int result = 0;
34 [ + + ]: 3365 : for (; first != last; ++first)
35 : : {
36 : 2692 : int digit;
37 [ + + ]: 2692 : if (json_isdigit(*first))
38 : 1366 : digit = *first - '0';
39 : :
40 [ + + ]: 1326 : else if (*first >= 'a' && *first <= 'f')
41 : 1304 : digit = *first - 'a' + 10;
42 : :
43 [ + - ]: 22 : else if (*first >= 'A' && *first <= 'F')
44 : 22 : digit = *first - 'A' + 10;
45 : :
46 : : else
47 : : break;
48 : :
49 : 2692 : result = 16 * result + digit;
50 : : }
51 : 673 : out = result;
52 : :
53 : 673 : return first;
54 : : }
55 : :
56 : 7122194 : enum jtokentype getJsonToken(std::string& tokenVal, unsigned int& consumed,
57 : : const char *raw, const char *end)
58 : : {
59 : 7122194 : tokenVal.clear();
60 : 7122194 : consumed = 0;
61 : :
62 : 7122194 : const char *rawStart = raw;
63 : :
64 [ + + + + ]: 9118602 : while (raw < end && (json_isspace(*raw))) // skip whitespace
65 : 1996408 : raw++;
66 : :
67 [ + + ]: 7122194 : if (raw >= end)
68 : : return JTOK_NONE;
69 : :
70 [ + + + + : 6903335 : switch (*raw) {
+ + + + +
+ ]
71 : :
72 : 354866 : case '{':
73 : 354866 : raw++;
74 : 354866 : consumed = (raw - rawStart);
75 : 354866 : return JTOK_OBJ_OPEN;
76 : 354849 : case '}':
77 : 354849 : raw++;
78 : 354849 : consumed = (raw - rawStart);
79 : 354849 : return JTOK_OBJ_CLOSE;
80 : 146079 : case '[':
81 : 146079 : raw++;
82 : 146079 : consumed = (raw - rawStart);
83 : 146079 : return JTOK_ARR_OPEN;
84 : 145030 : case ']':
85 : 145030 : raw++;
86 : 145030 : consumed = (raw - rawStart);
87 : 145030 : return JTOK_ARR_CLOSE;
88 : :
89 : 1075413 : case ':':
90 : 1075413 : raw++;
91 : 1075413 : consumed = (raw - rawStart);
92 : 1075413 : return JTOK_COLON;
93 : 875366 : case ',':
94 : 875366 : raw++;
95 : 875366 : consumed = (raw - rawStart);
96 : 875366 : return JTOK_COMMA;
97 : :
98 : 18531 : case 'n':
99 : 18531 : case 't':
100 : 18531 : case 'f':
101 [ + + ]: 18531 : if (!strncmp(raw, "null", 4)) {
102 : 728 : raw += 4;
103 : 728 : consumed = (raw - rawStart);
104 : 728 : return JTOK_KW_NULL;
105 [ + + ]: 17803 : } else if (!strncmp(raw, "true", 4)) {
106 : 15631 : raw += 4;
107 : 15631 : consumed = (raw - rawStart);
108 : 15631 : return JTOK_KW_TRUE;
109 [ + + ]: 2172 : } else if (!strncmp(raw, "false", 5)) {
110 : 2167 : raw += 5;
111 : 2167 : consumed = (raw - rawStart);
112 : 2167 : return JTOK_KW_FALSE;
113 : : } else
114 : : return JTOK_ERR;
115 : :
116 : 2183365 : case '-':
117 : 2183365 : case '0':
118 : 2183365 : case '1':
119 : 2183365 : case '2':
120 : 2183365 : case '3':
121 : 2183365 : case '4':
122 : 2183365 : case '5':
123 : 2183365 : case '6':
124 : 2183365 : case '7':
125 : 2183365 : case '8':
126 : 2183365 : case '9': {
127 : : // part 1: int
128 [ + + ]: 2183365 : std::string numStr;
129 : :
130 : 2183365 : const char *first = raw;
131 : :
132 : 2183365 : const char *firstDigit = first;
133 [ + + ]: 2183365 : if (!json_isdigit(*firstDigit))
134 : 41359 : firstDigit++;
135 [ + + + + ]: 2183365 : if ((*firstDigit == '0') && json_isdigit(firstDigit[1]))
136 : : return JTOK_ERR;
137 : :
138 [ + - ]: 2183364 : numStr += *raw; // copy first char
139 : 2183364 : raw++;
140 : :
141 [ + + + - : 2183364 : if ((*first == '-') && (raw < end) && (!json_isdigit(*raw)))
+ - ]
142 : : return JTOK_ERR;
143 : :
144 [ + + + + ]: 6886305 : while (raw < end && json_isdigit(*raw)) { // copy digits
145 [ + - ]: 4702941 : numStr += *raw;
146 : 4702941 : raw++;
147 : : }
148 : :
149 : : // part 2: frac
150 [ + + + + ]: 2183364 : if (raw < end && *raw == '.') {
151 [ + - ]: 56059 : numStr += *raw; // copy .
152 : 56059 : raw++;
153 : :
154 [ + - + - ]: 56059 : if (raw >= end || !json_isdigit(*raw))
155 : : return JTOK_ERR;
156 [ + + + + ]: 598664 : while (raw < end && json_isdigit(*raw)) { // copy digits
157 [ + - ]: 542605 : numStr += *raw;
158 : 542605 : raw++;
159 : : }
160 : : }
161 : :
162 : : // part 3: exp
163 [ + + + + : 2183364 : if (raw < end && (*raw == 'e' || *raw == 'E')) {
+ + ]
164 [ + - ]: 24384 : numStr += *raw; // copy E
165 : 24384 : raw++;
166 : :
167 [ + - + + : 24384 : if (raw < end && (*raw == '-' || *raw == '+')) { // copy +/-
+ + ]
168 [ + - ]: 24377 : numStr += *raw;
169 : 24377 : raw++;
170 : : }
171 : :
172 [ + - + + ]: 24384 : if (raw >= end || !json_isdigit(*raw))
173 : : return JTOK_ERR;
174 [ + + + + ]: 73133 : while (raw < end && json_isdigit(*raw)) { // copy digits
175 [ + - ]: 48752 : numStr += *raw;
176 : 48752 : raw++;
177 : : }
178 : : }
179 : :
180 [ + - ]: 2183361 : tokenVal = numStr;
181 : 2183361 : consumed = (raw - rawStart);
182 : 2183361 : return JTOK_NUMBER;
183 : 2183365 : }
184 : :
185 : 1749810 : case '"': {
186 : 1749810 : raw++; // skip "
187 : :
188 : 1749810 : std::string valStr;
189 : 1749810 : JSONUTF8StringFilter writer(valStr);
190 : :
191 : 4949163559 : while (true) {
192 [ + + + + ]: 4949163559 : if (raw >= end || (unsigned char)*raw < 0x20)
193 : : return JTOK_ERR;
194 : :
195 [ + + ]: 4949163555 : else if (*raw == '\\') {
196 : 725 : raw++; // skip backslash
197 : :
198 [ + - ]: 725 : if (raw >= end)
199 : : return JTOK_ERR;
200 : :
201 [ + + + + : 725 : switch (*raw) {
+ + + + +
+ ]
202 [ + - ]: 15 : case '"': writer.push_back('\"'); break;
203 [ + - ]: 5 : case '\\': writer.push_back('\\'); break;
204 [ + - ]: 2 : case '/': writer.push_back('/'); break;
205 [ + - ]: 5 : case 'b': writer.push_back('\b'); break;
206 [ + - ]: 5 : case 'f': writer.push_back('\f'); break;
207 [ + - ]: 6 : case 'n': writer.push_back('\n'); break;
208 [ + - ]: 5 : case 'r': writer.push_back('\r'); break;
209 [ + - ]: 5 : case 't': writer.push_back('\t'); break;
210 : :
211 : 673 : case 'u': {
212 : 673 : unsigned int codepoint;
213 [ + - + - ]: 1346 : if (raw + 1 + 4 >= end ||
214 : 673 : hatoui(raw + 1, raw + 1 + 4, codepoint) !=
215 : : raw + 1 + 4)
216 : 0 : return JTOK_ERR;
217 [ + - ]: 673 : writer.push_back_u(codepoint);
218 : 673 : raw += 4;
219 : 673 : break;
220 : : }
221 : : default:
222 : : return JTOK_ERR;
223 : :
224 : : }
225 : :
226 : 721 : raw++; // skip esc'd char
227 : : }
228 : :
229 [ + + ]: 4949162830 : else if (*raw == '"') {
230 : 1749802 : raw++; // skip "
231 : 1749802 : break; // stop scanning
232 : : }
233 : :
234 : : else {
235 [ + - ]: 4947413028 : writer.push_back(static_cast<unsigned char>(*raw));
236 : 4947413028 : raw++;
237 : : }
238 : : }
239 : :
240 [ + + + + ]: 3499604 : if (!writer.finalize())
241 : : return JTOK_ERR;
242 [ + - ]: 1749798 : tokenVal = valStr;
243 : 1749798 : consumed = (raw - rawStart);
244 : 1749798 : return JTOK_STRING;
245 : 1749810 : }
246 : :
247 : : default:
248 : : return JTOK_ERR;
249 : : }
250 : : }
251 : :
252 : : enum expect_bits : unsigned {
253 : : EXP_OBJ_NAME = (1U << 0),
254 : : EXP_COLON = (1U << 1),
255 : : EXP_ARR_VALUE = (1U << 2),
256 : : EXP_VALUE = (1U << 3),
257 : : EXP_NOT_VALUE = (1U << 4),
258 : : };
259 : :
260 : : #define expect(bit) (expectMask & (EXP_##bit))
261 : : #define setExpect(bit) (expectMask |= EXP_##bit)
262 : : #define clearExpect(bit) (expectMask &= ~EXP_##bit)
263 : :
264 : 218931 : bool UniValue::read(std::string_view json)
265 : : {
266 [ + - ]: 218931 : UniValue parsed;
267 [ + - + + ]: 218931 : if (!parsed.read_impl(json)) {
268 [ + - ]: 78 : setNull();
269 : : return false;
270 : : }
271 : 218853 : *this = std::move(parsed);
272 : 218853 : return true;
273 : 218931 : }
274 : :
275 : 218931 : bool UniValue::read_impl(std::string_view str_in)
276 : : {
277 : 218931 : clear();
278 : :
279 : 218931 : uint32_t expectMask = 0;
280 : 218931 : std::vector<UniValue*> stack;
281 : :
282 : 218931 : std::string tokenVal;
283 : 218931 : unsigned int consumed;
284 : 218931 : enum jtokentype tok = JTOK_NONE;
285 : 218931 : enum jtokentype last_tok = JTOK_NONE;
286 : 218931 : const char* raw{str_in.data()};
287 : 218931 : const char* end{raw + str_in.size()};
288 : 5056484 : do {
289 : 5056484 : last_tok = tok;
290 : :
291 [ + - ]: 5056484 : tok = getJsonToken(tokenVal, consumed, raw, end);
292 [ + + ]: 5056484 : if (tok == JTOK_NONE || tok == JTOK_ERR)
293 : : return false;
294 : 5056438 : raw += consumed;
295 : :
296 [ + + ]: 5056438 : bool isValueOpen = jsonTokenIsValue(tok) ||
297 [ + + ]: 2951598 : tok == JTOK_OBJ_OPEN || tok == JTOK_ARR_OPEN;
298 : :
299 [ + + ]: 5056438 : if (expect(VALUE)) {
300 [ + + ]: 1075408 : if (!isValueOpen)
301 : : return false;
302 : 1075406 : clearExpect(VALUE);
303 : :
304 [ + + ]: 3981030 : } else if (expect(ARR_VALUE)) {
305 : 237772 : bool isArrValue = isValueOpen || (tok == JTOK_ARR_CLOSE);
306 [ + + ]: 237772 : if (!isArrValue)
307 : : return false;
308 : :
309 : 237770 : clearExpect(ARR_VALUE);
310 : :
311 [ + + ]: 3743258 : } else if (expect(OBJ_NAME)) {
312 : 1138510 : bool isObjName = (tok == JTOK_OBJ_CLOSE || tok == JTOK_STRING);
313 [ + + ]: 1138510 : if (!isObjName)
314 : : return false;
315 : :
316 [ + + ]: 2604748 : } else if (expect(COLON)) {
317 [ + + ]: 1075414 : if (tok != JTOK_COLON)
318 : : return false;
319 : 1075411 : clearExpect(COLON);
320 : :
321 [ + + ]: 1529334 : } else if (!expect(COLON) && (tok == JTOK_COLON)) {
322 : : return false;
323 : : }
324 : :
325 [ + + ]: 5056426 : if (expect(NOT_VALUE)) {
326 [ + + ]: 2385833 : if (isValueOpen)
327 : : return false;
328 : 2385831 : clearExpect(NOT_VALUE);
329 : : }
330 : :
331 [ + + + + : 5056424 : switch (tok) {
+ + + - ]
332 : :
333 : 500941 : case JTOK_OBJ_OPEN:
334 : 500941 : case JTOK_ARR_OPEN: {
335 [ + + ]: 500941 : VType utyp = (tok == JTOK_OBJ_OPEN ? VOBJ : VARR);
336 [ - + + + ]: 500941 : if (!stack.size()) {
337 [ + + ]: 218810 : if (utyp == VOBJ)
338 [ + - ]: 218108 : setObject();
339 : : else
340 [ + - ]: 702 : setArray();
341 [ + - ]: 218810 : stack.push_back(this);
342 : : } else {
343 : 282131 : UniValue tmpVal(utyp);
344 : 282131 : UniValue *top = stack.back();
345 [ + - ]: 282131 : top->values.push_back(tmpVal);
346 : :
347 : 282131 : UniValue *newTop = &(top->values.back());
348 [ + - ]: 282131 : stack.push_back(newTop);
349 : 282131 : }
350 : :
351 [ - + + + ]: 500941 : if (stack.size() > MAX_JSON_DEPTH)
352 : : return false;
353 : :
354 [ + + ]: 500939 : if (utyp == VOBJ)
355 : 354864 : setExpect(OBJ_NAME);
356 : : else
357 : 146075 : setExpect(ARR_VALUE);
358 : : break;
359 : : }
360 : :
361 : 499875 : case JTOK_OBJ_CLOSE:
362 : 499875 : case JTOK_ARR_CLOSE: {
363 [ - + + - : 499875 : if (!stack.size() || (last_tok == JTOK_COMMA))
+ + ]
364 : : return false;
365 : :
366 [ + + ]: 499873 : VType utyp = (tok == JTOK_OBJ_CLOSE ? VOBJ : VARR);
367 : 499873 : UniValue *top = stack.back();
368 [ + + ]: 499873 : if (utyp != top->getType())
369 : : return false;
370 : :
371 : 499872 : stack.pop_back();
372 : 499872 : clearExpect(OBJ_NAME);
373 : 499872 : setExpect(NOT_VALUE);
374 : 499872 : break;
375 : : }
376 : :
377 : 1075411 : case JTOK_COLON: {
378 [ - + + - ]: 1075411 : if (!stack.size())
379 : : return false;
380 : :
381 : 1075411 : UniValue *top = stack.back();
382 [ + - ]: 1075411 : if (top->getType() != VOBJ)
383 : : return false;
384 : :
385 : 1075411 : setExpect(VALUE);
386 : 1075411 : break;
387 : : }
388 : :
389 : 875362 : case JTOK_COMMA: {
390 [ - + ]: 875362 : if (!stack.size() ||
391 [ + - + - ]: 875362 : (last_tok == JTOK_COMMA) || (last_tok == JTOK_ARR_OPEN))
392 : : return false;
393 : :
394 : 875362 : UniValue *top = stack.back();
395 [ + + ]: 875362 : if (top->getType() == VOBJ)
396 : 783649 : setExpect(OBJ_NAME);
397 : : else
398 : 91713 : setExpect(ARR_VALUE);
399 : : break;
400 : : }
401 : :
402 : 18523 : case JTOK_KW_NULL:
403 : 18523 : case JTOK_KW_TRUE:
404 : 18523 : case JTOK_KW_FALSE: {
405 [ + + + ]: 18523 : UniValue tmpVal;
406 [ + + + ]: 18523 : switch (tok) {
407 : : case JTOK_KW_NULL:
408 : : // do nothing more
409 : : break;
410 : 15629 : case JTOK_KW_TRUE:
411 [ + - ]: 15629 : tmpVal.setBool(true);
412 : : break;
413 : 2167 : case JTOK_KW_FALSE:
414 [ + - ]: 2167 : tmpVal.setBool(false);
415 : : break;
416 : : default: /* impossible */ break;
417 : : }
418 : :
419 [ - + + + ]: 18523 : if (!stack.size()) {
420 [ + - ]: 40 : *this = tmpVal;
421 : : break;
422 : : }
423 : :
424 : 18483 : UniValue *top = stack.back();
425 [ + - ]: 18483 : top->values.push_back(tmpVal);
426 : :
427 : 18483 : setExpect(NOT_VALUE);
428 : 18483 : break;
429 : 18523 : }
430 : :
431 : 336516 : case JTOK_NUMBER: {
432 [ - + ]: 673032 : UniValue tmpVal(VNUM, tokenVal);
433 [ - + + + ]: 336516 : if (!stack.size()) {
434 [ + - ]: 58 : *this = tmpVal;
435 : : break;
436 : : }
437 : :
438 : 336458 : UniValue *top = stack.back();
439 [ + - ]: 336458 : top->values.push_back(tmpVal);
440 : :
441 : 336458 : setExpect(NOT_VALUE);
442 : 336458 : break;
443 : 336516 : }
444 : :
445 : 1749796 : case JTOK_STRING: {
446 [ + + ]: 1749796 : if (expect(OBJ_NAME)) {
447 : 1075414 : UniValue *top = stack.back();
448 [ + - ]: 1075414 : top->keys.push_back(tokenVal);
449 : 1075414 : clearExpect(OBJ_NAME);
450 : 1075414 : setExpect(COLON);
451 : : } else {
452 [ - + ]: 1348764 : UniValue tmpVal(VSTR, tokenVal);
453 [ - + + + ]: 674382 : if (!stack.size()) {
454 [ + - ]: 3 : *this = tmpVal;
455 : 3 : break;
456 : : }
457 : 674379 : UniValue *top = stack.back();
458 [ + - ]: 674379 : top->values.push_back(tmpVal);
459 : 674382 : }
460 : :
461 : 1749793 : setExpect(NOT_VALUE);
462 : 1749793 : break;
463 : : }
464 : :
465 : : default:
466 : : return false;
467 : : }
468 [ + + ]: 5056419 : } while (!stack.empty ());
469 : :
470 : : /* Check that nothing follows the initial construct (parsed above). */
471 [ + - ]: 218866 : tok = getJsonToken(tokenVal, consumed, raw, end);
472 [ + + ]: 218866 : if (tok != JTOK_NONE)
473 : 13 : return false;
474 : :
475 : : return true;
476 : 218931 : }
|
