Coverage Report

Created: 2023-06-07 06:04

/src/libyaml_dumper_fuzzer.c
Line
Count
Source (jump to first uncovered line)
1
// Copyright 2020 Google LLC
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//      http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14
15
#include "yaml.h"
16
#include "yaml_write_handler.h"
17
#include <assert.h>
18
#include <stdbool.h>
19
#include <stdint.h>
20
#include <stdio.h>
21
#include <stdlib.h>
22
#include <string.h>
23
24
#ifdef NDEBUG
25
#undef NDEBUG
26
#endif
27
28
6.05k
#define MAX_DOCUMENTS 16
29
30
bool nodes_equal(yaml_document_t *document1, int index1,
31
0
                 yaml_document_t *document2, int index2, int level) {
32
0
  const bool equal = true;
33
34
0
  if (level++ > 1000)
35
0
    return !equal;
36
0
  yaml_node_t *node1 = yaml_document_get_node(document1, index1);
37
38
0
  if (!node1)
39
0
    return !equal;
40
41
0
  yaml_node_t *node2 = yaml_document_get_node(document2, index2);
42
43
0
  if (!node2)
44
0
    return !equal;
45
46
0
  if (node1->type != node2->type)
47
0
    return !equal;
48
49
0
  if (strcmp((char *)node1->tag, (char *)node2->tag) != 0)
50
0
    return !equal;
51
52
0
  switch (node1->type) {
53
0
  case YAML_SCALAR_NODE:
54
0
    if (node1->data.scalar.length != node2->data.scalar.length)
55
0
      return !equal;
56
0
    if (strncmp((char *)node1->data.scalar.value,
57
0
                (char *)node2->data.scalar.value,
58
0
                node1->data.scalar.length) != 0)
59
0
      return !equal;
60
0
    break;
61
0
  case YAML_SEQUENCE_NODE:
62
0
    if ((node1->data.sequence.items.top - node1->data.sequence.items.start) !=
63
0
        (node2->data.sequence.items.top - node2->data.sequence.items.start))
64
0
      return !equal;
65
0
    for (int k = 0; k < (node1->data.sequence.items.top -
66
0
                         node1->data.sequence.items.start);
67
0
         k++) {
68
0
      if (!nodes_equal(document1, node1->data.sequence.items.start[k],
69
0
                       document2, node2->data.sequence.items.start[k], level))
70
0
        return !equal;
71
0
    }
72
0
    break;
73
0
  case YAML_MAPPING_NODE:
74
0
    if ((node1->data.mapping.pairs.top - node1->data.mapping.pairs.start) !=
75
0
        (node2->data.mapping.pairs.top - node2->data.mapping.pairs.start))
76
0
      return !equal;
77
0
    for (int k = 0;
78
0
         k < (node1->data.mapping.pairs.top - node1->data.mapping.pairs.start);
79
0
         k++) {
80
0
      if (!nodes_equal(document1, node1->data.mapping.pairs.start[k].key,
81
0
                       document2, node2->data.mapping.pairs.start[k].key,
82
0
                       level))
83
0
        return !equal;
84
0
      if (!nodes_equal(document1, node1->data.mapping.pairs.start[k].value,
85
0
                       document2, node2->data.mapping.pairs.start[k].value,
86
0
                       level))
87
0
        return !equal;
88
0
    }
89
0
    break;
90
0
  default:
91
0
    return !equal;
92
0
  }
93
0
  return equal;
94
0
}
95
96
0
bool documents_equal(yaml_document_t *document1, yaml_document_t *document2) {
97
98
0
  const bool equal = true;
99
100
0
  if ((document1->version_directive && !document2->version_directive) ||
101
0
      (!document1->version_directive && document2->version_directive) ||
102
0
      (document1->version_directive && document2->version_directive &&
103
0
       (document1->version_directive->major !=
104
0
            document2->version_directive->major ||
105
0
        document1->version_directive->minor !=
106
0
            document2->version_directive->minor)))
107
0
    return !equal;
108
109
0
  if ((document1->tag_directives.end - document1->tag_directives.start) !=
110
0
      (document2->tag_directives.end - document2->tag_directives.start))
111
0
    return !equal;
112
0
  for (int k = 0;
113
0
       k < (document1->tag_directives.end - document1->tag_directives.start);
114
0
       k++) {
115
0
    if ((strcmp((char *)document1->tag_directives.start[k].handle,
116
0
                (char *)document2->tag_directives.start[k].handle) != 0) ||
117
0
        (strcmp((char *)document1->tag_directives.start[k].prefix,
118
0
                (char *)document2->tag_directives.start[k].prefix) != 0))
119
0
      return !equal;
120
0
  }
121
122
0
  if ((document1->nodes.top - document1->nodes.start) !=
123
0
      (document2->nodes.top - document2->nodes.start))
124
0
    return !equal;
125
126
0
  if (document1->nodes.top != document1->nodes.start) {
127
0
    if (!nodes_equal(document1, 1, document2, 1, 0))
128
0
      return !equal;
129
0
  }
130
131
0
  return equal;
132
0
}
133
134
bool copy_document(yaml_document_t *document_to,
135
6.05k
                   yaml_document_t *document_from) {
136
6.05k
  bool error = true;
137
138
6.05k
  yaml_node_t *node;
139
6.05k
  yaml_node_item_t *item;
140
6.05k
  yaml_node_pair_t *pair;
141
142
6.05k
  if (!yaml_document_initialize(document_to, document_from->version_directive,
143
6.05k
                                document_from->tag_directives.start,
144
6.05k
                                document_from->tag_directives.end,
145
6.05k
                                document_from->start_implicit,
146
6.05k
                                document_from->end_implicit))
147
7
    return !error;
148
149
7.72M
  for (node = document_from->nodes.start; node < document_from->nodes.top;
150
7.72M
       node++) {
151
7.72M
    switch (node->type) {
152
5.09M
    case YAML_SCALAR_NODE:
153
5.09M
      if (!yaml_document_add_scalar(
154
5.09M
              document_to, node->tag, node->data.scalar.value,
155
5.09M
              node->data.scalar.length, node->data.scalar.style))
156
25
        goto out;
157
5.09M
      break;
158
5.09M
    case YAML_SEQUENCE_NODE:
159
692k
      if (!yaml_document_add_sequence(document_to, node->tag,
160
692k
                                      node->data.sequence.style))
161
1
        goto out;
162
692k
      break;
163
1.93M
    case YAML_MAPPING_NODE:
164
1.93M
      if (!yaml_document_add_mapping(document_to, node->tag,
165
1.93M
                                     node->data.mapping.style))
166
1
        goto out;
167
1.93M
      break;
168
1.93M
    default:
169
0
      goto out;
170
7.72M
    }
171
7.72M
  }
172
173
7.72M
  for (node = document_from->nodes.start; node < document_from->nodes.top;
174
7.72M
       node++) {
175
7.72M
    switch (node->type) {
176
692k
    case YAML_SEQUENCE_NODE:
177
692k
      for (item = node->data.sequence.items.start;
178
2.40M
           item < node->data.sequence.items.top; item++) {
179
1.70M
        if (!yaml_document_append_sequence_item(
180
1.70M
                document_to, node - document_from->nodes.start + 1, *item))
181
0
          goto out;
182
1.70M
      }
183
692k
      break;
184
1.93M
    case YAML_MAPPING_NODE:
185
1.93M
      for (pair = node->data.mapping.pairs.start;
186
5.08M
           pair < node->data.mapping.pairs.top; pair++) {
187
3.14M
        if (!yaml_document_append_mapping_pair(
188
3.14M
                document_to, node - document_from->nodes.start + 1, pair->key,
189
3.14M
                pair->value))
190
0
          goto out;
191
3.14M
      }
192
1.93M
      break;
193
5.09M
    default:
194
5.09M
      break;
195
7.72M
    }
196
7.72M
  }
197
6.01k
  return error;
198
199
27
out:
200
27
  yaml_document_delete(document_to);
201
27
  return !error;
202
6.01k
}
203
204
10.1k
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
205
10.1k
  if (size < 2)
206
1
    return 0;
207
208
10.1k
  yaml_parser_t parser;
209
10.1k
  yaml_emitter_t emitter;
210
211
10.1k
  yaml_document_t document;
212
10.1k
  yaml_document_t documents[MAX_DOCUMENTS];
213
10.1k
  size_t document_number = 0;
214
10.1k
  int count = 0;
215
10.1k
  bool done = false;
216
10.1k
  bool equal = false;
217
10.1k
  bool is_canonical = data[0] & 1;
218
10.1k
  bool is_unicode = data[1] & 1;
219
10.1k
  data += 2;
220
10.1k
  size -= 2;
221
222
10.1k
  if (!yaml_parser_initialize(&parser))
223
0
    return 0;
224
225
10.1k
  yaml_parser_set_input_string(&parser, data, size);
226
10.1k
  if (!yaml_emitter_initialize(&emitter))
227
0
    return 0;
228
229
10.1k
  yaml_emitter_set_canonical(&emitter, is_canonical);
230
10.1k
  yaml_emitter_set_unicode(&emitter, is_unicode);
231
232
10.1k
  yaml_output_buffer_t out = {/*buf=*/NULL, /*size=*/0};
233
10.1k
  yaml_emitter_set_output(&emitter, yaml_write_handler, &out);
234
10.1k
  yaml_emitter_open(&emitter);
235
236
10.3k
  while (!done) {
237
10.1k
    if (!yaml_parser_load(&parser, &document)) {
238
3.95k
      equal = 1;
239
3.95k
      break;
240
3.95k
    }
241
242
6.23k
    done = (!yaml_document_get_root_node(&document));
243
6.23k
    if (!done) {
244
6.05k
      if (document_number >= MAX_DOCUMENTS) {
245
0
        yaml_document_delete(&document);
246
0
        equal = true;
247
0
        break;
248
0
      }
249
250
6.05k
      if (!copy_document(&documents[document_number++], &document)) {
251
34
        yaml_document_delete(&document);
252
34
        equal = true;
253
34
        break;
254
34
      }
255
6.01k
      if (!(yaml_emitter_dump(&emitter, &document) ||
256
6.01k
            (yaml_emitter_flush(&emitter) && 0))) {
257
6.01k
        equal = true;
258
6.01k
        break;
259
6.01k
      }
260
261
0
      count++;
262
182
    } else {
263
182
      yaml_document_delete(&document);
264
182
    }
265
6.23k
  }
266
267
10.1k
  yaml_parser_delete(&parser);
268
10.1k
  yaml_emitter_close(&emitter);
269
10.1k
  yaml_emitter_delete(&emitter);
270
271
10.1k
  if (!equal) {
272
182
    count = 0;
273
182
    done = false;
274
182
    if (!yaml_parser_initialize(&parser))
275
0
      goto error;
276
277
182
    if (!out.buf) {
278
182
      yaml_parser_delete(&parser);
279
182
      goto error;
280
182
    }
281
282
0
    yaml_parser_set_input_string(&parser, out.buf, out.size);
283
284
0
    while (!done) {
285
0
      if (!yaml_parser_load(&parser, &document)) {
286
0
        yaml_parser_delete(&parser);
287
0
        goto error;
288
0
      }
289
290
0
      done = (!yaml_document_get_root_node(&document));
291
0
      if (!done) {
292
0
        if (!documents_equal(documents + count, &document)) {
293
0
          yaml_parser_delete(&parser);
294
0
          goto error;
295
0
        }
296
0
        count++;
297
0
      }
298
0
      yaml_document_delete(&document);
299
0
    }
300
0
    yaml_parser_delete(&parser);
301
0
  }
302
303
16.0k
  for (int k = 0; k < document_number; k++) {
304
6.05k
    yaml_document_delete(documents + k);
305
6.05k
  }
306
307
10.1k
error:
308
309
10.1k
  free(out.buf);
310
10.1k
  return 0;
311
10.0k
}