1 //-*****************************************************************************
2 //
3 // Copyright (c) 2020,
4 // Sony Pictures Imageworks Inc. and
5 // Industrial Light & Magic, a division of Lucasfilm Entertainment Company Ltd.
6 //
7 // All rights reserved.
8 //
9 // Redistribution and use in source and binary forms, with or without
10 // modification, are permitted provided that the following conditions are
11 // met:
12 // * Redistributions of source code must retain the above copyright
13 // notice, this list of conditions and the following disclaimer.
14 // * Redistributions in binary form must reproduce the above
15 // copyright notice, this list of conditions and the following disclaimer
16 // in the documentation and/or other materials provided with the
17 // distribution.
18 // * Neither the name of Sony Pictures Imageworks, nor
19 // Industrial Light & Magic, nor the names of their contributors may be used
20 // to endorse or promote products derived from this software without specific
21 // prior written permission.
22 //
23 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 //
35 //-*****************************************************************************
36
37 #include <Alembic/AbcCoreAbstract/All.h>
38 #include <Alembic/AbcCoreOgawa/All.h>
39 #include <Alembic/Util/All.h>
40
41 #include <Alembic/AbcCoreAbstract/Tests/Assert.h>
42
43 #include <fstream>
44 #include <sstream>
45 #include <vector>
46
47 // for our scalar properties
48 std::vector<std::string> sampStrVec;
49 std::vector<std::wstring> sampWStrVec;
50 char samp[4096];
51
52 namespace ABCA = Alembic::AbcCoreAbstract;
53
walkProps(ABCA::CompoundPropertyReaderPtr parent)54 void walkProps(ABCA::CompoundPropertyReaderPtr parent)
55 {
56 for (std::size_t i = 0; i < parent->getNumProperties(); ++i)
57 {
58 ABCA::CompoundPropertyReaderPtr childCompound = parent->getCompoundProperty(i);
59 if (childCompound)
60 {
61 walkProps(childCompound);
62 }
63
64 ABCA::ScalarPropertyReaderPtr childScalar = parent->getScalarProperty(i);
65 if (childScalar)
66 {
67 if (childScalar->getDataType().getPod() ==
68 Alembic::AbcCoreAbstract::kStringPOD)
69 {
70 sampStrVec.resize(childScalar->getDataType().getExtent());
71 }
72 else if (childScalar->getDataType().getPod() ==
73 Alembic::AbcCoreAbstract::kWstringPOD)
74 {
75 sampWStrVec.resize(childScalar->getDataType().getExtent());
76 }
77
78 for (std::size_t i = 0; i < childScalar->getNumSamples(); ++i)
79 {
80 if (childScalar->getDataType().getPod() ==
81 Alembic::AbcCoreAbstract::kStringPOD)
82 {
83 childScalar->getSample(i, &sampStrVec.front());
84 }
85 else if (childScalar->getDataType().getPod() ==
86 Alembic::AbcCoreAbstract::kWstringPOD)
87 {
88 childScalar->getSample(i, &sampWStrVec.front());
89 }
90 else
91 {
92 childScalar->getSample(i, samp);
93 }
94 }
95 }
96
97 ABCA::ArrayPropertyReaderPtr childArray = parent->getArrayProperty(i);
98 if (childArray)
99 {
100 ABCA::ArraySamplePtr samp;
101 for (std::size_t i = 0; i < childArray->getNumSamples(); ++i)
102 {
103 childArray->getSample(i, samp);
104 }
105 }
106 }
107 }
108
walkObj(ABCA::ObjectReaderPtr parent)109 void walkObj(ABCA::ObjectReaderPtr parent)
110 {
111 walkProps(parent->getProperties());
112 for(std::size_t i = 0; i < parent->getNumChildren(); ++i)
113 {
114 ABCA::ObjectReaderPtr child = parent->getChild(i);
115 walkObj(child);
116 }
117 }
118
walkJustObj(ABCA::ObjectReaderPtr parent)119 void walkJustObj(ABCA::ObjectReaderPtr parent)
120 {
121 for(std::size_t i = 0; i < parent->getNumChildren(); ++i)
122 {
123 ABCA::ObjectReaderPtr child = parent->getChild(i);
124 walkJustObj(child);
125 }
126 }
127
testIssue254(bool iUseMMap)128 void testIssue254(bool iUseMMap)
129 {
130 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
131 ABCA::ArchiveReaderPtr ar = r("issue254.abc");
132 walkJustObj(ar->getTop());
133
134 try
135 {
136 walkObj(ar->getTop());
137 }
138 catch(const std::exception& e)
139 {
140 std::string msg = "Ogawa IData illegal size.";
141 TESTING_ASSERT(msg == e.what());
142 return;
143 }
144
145 TESTING_ASSERT(0);
146 }
147
testIssue255(bool iUseMMap)148 void testIssue255(bool iUseMMap)
149 {
150 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
151 ABCA::ArchiveReaderPtr ar = r("issue255.abc");
152 walkJustObj(ar->getTop());
153
154 try
155 {
156 walkObj(ar->getTop());
157 }
158 catch(const std::exception& e)
159 {
160 std::string msg = "ReadData invalid: Null IDataPtr.";
161 TESTING_ASSERT(msg == e.what());
162 return;
163 }
164 TESTING_ASSERT(0);
165 }
166
testIssue256(bool iUseMMap)167 void testIssue256(bool iUseMMap)
168 {
169 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
170 try
171 {
172 r("issue256.abc");
173 }
174 catch(const std::exception& e)
175 {
176 std::string msg = "Read invalid: TimeSamples sample times.";
177 TESTING_ASSERT(msg == e.what());
178 return;
179 }
180
181 TESTING_ASSERT(0);
182 }
183
testIssue257(bool iUseMMap)184 void testIssue257(bool iUseMMap)
185 {
186 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
187 ABCA::ArchiveReaderPtr ar = r("issue257.abc");
188 try
189 {
190 walkObj(ar->getTop());
191 }
192 catch(const std::exception& e)
193 {
194 std::string msg = "Read invalid: Object Headers name and MetaData index.";
195 TESTING_ASSERT(msg == e.what());
196 return;
197 }
198
199 TESTING_ASSERT(0);
200 }
201
testIssue258(bool iUseMMap)202 void testIssue258(bool iUseMMap)
203 {
204 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
205 try
206 {
207 r("issue258.abc");
208 }
209 catch(const std::exception& e)
210 {
211 std::string msg = "Read invalid: Indexed MetaData string.";
212 TESTING_ASSERT(msg == e.what());
213 return;
214 }
215
216 TESTING_ASSERT(0);
217 }
218
testIssue269(bool iUseMMap)219 void testIssue269(bool iUseMMap)
220 {
221 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
222 ABCA::ArchiveReaderPtr ar = r("issue269.abc");
223 try
224 {
225 walkJustObj(ar->getTop());
226 }
227 catch(const std::exception& e)
228 {
229 std::string msg = "Read invalid: Object Headers name size.";
230 TESTING_ASSERT(msg == e.what());
231 }
232
233 try
234 {
235 walkObj(ar->getTop());
236 }
237 catch(const std::exception& e)
238 {
239 std::string msg = "ReadData invalid: Null IDataPtr.";
240 TESTING_ASSERT(msg == e.what());
241 return;
242 }
243
244 TESTING_ASSERT(0);
245 }
246
testIssue270(bool iUseMMap)247 void testIssue270(bool iUseMMap)
248 {
249 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
250 ABCA::ArchiveReaderPtr ar = r("issue270.abc");
251 walkJustObj(ar->getTop());
252 try
253 {
254 walkObj(ar->getTop());
255 }
256 catch(const std::exception& e)
257 {
258 std::string msg = "Read invalid: Property Headers name.";
259 TESTING_ASSERT(msg == e.what());
260 return;
261 }
262
263 }
264
testIssue271(bool iUseMMap)265 void testIssue271(bool iUseMMap)
266 {
267 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
268 ABCA::ArchiveReaderPtr ar = r("issue271.abc");
269 walkJustObj(ar->getTop());
270 try
271 {
272 walkObj(ar->getTop());
273 }
274 catch(const std::exception& e)
275 {
276 std::string msg = "Read invalid: Property Header MetaData index.";
277 TESTING_ASSERT(msg == e.what());
278 return;
279 }
280
281 TESTING_ASSERT(0);
282 }
283
testIssue272(bool iUseMMap)284 void testIssue272(bool iUseMMap)
285 {
286 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
287 ABCA::ArchiveReaderPtr ar = r("issue272.abc");
288 try
289 {
290 walkObj(ar->getTop());
291 }
292 catch(const std::exception& e)
293 {
294 std::string msg = "Read invalid: Object Headers MetaData index.";
295 TESTING_ASSERT(msg == e.what());
296 return;
297 }
298
299 TESTING_ASSERT(0);
300 }
301
testIssue282(bool iUseMMap)302 void testIssue282(bool iUseMMap)
303 {
304 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
305 ABCA::ArchiveReaderPtr ar = r("issue282.abc");
306 walkJustObj(ar->getTop());
307 try
308 {
309 walkObj(ar->getTop());
310 }
311 catch(const std::exception& e)
312 {
313 std::string msg = "Ogawa IStreams::read failed.";
314 TESTING_ASSERT(msg == e.what());
315 return;
316 }
317
318 TESTING_ASSERT(0);
319 }
320
testIssue283(bool iUseMMap)321 void testIssue283(bool iUseMMap)
322 {
323 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
324 try
325 {
326 ABCA::ArchiveReaderPtr ar = r("issue283.abc");
327 }
328 catch(const std::exception& e)
329 {
330 std::string msg = "Invalid Alembic file.";
331 TESTING_ASSERT(msg == e.what());
332 return;
333 }
334
335 TESTING_ASSERT(0);
336 }
337
testFuzzer24846(bool iUseMMap)338 void testFuzzer24846(bool iUseMMap)
339 {
340 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
341 try
342 {
343 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue24846.abc");
344 }
345 catch(const std::exception& e)
346 {
347 std::string msg = "Ogawa IData illegal size.";
348 TESTING_ASSERT(msg == e.what());
349 return;
350 }
351
352 TESTING_ASSERT(0);
353 }
354
testFuzzer24853(bool iUseMMap)355 void testFuzzer24853(bool iUseMMap)
356 {
357 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
358 try
359 {
360 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue24853.abc");
361 }
362 catch(const std::exception& e)
363 {
364 std::string msg = "Ogawa IData illegal size.";
365 TESTING_ASSERT(msg == e.what());
366 return;
367 }
368
369 TESTING_ASSERT(0);
370 }
371
372
testFuzzer24598(bool iUseMMap)373 void testFuzzer24598(bool iUseMMap)
374 {
375 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
376 try
377 {
378 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue24598.abc");
379 }
380 catch(const std::exception& e)
381 {
382 std::string msg = "Invalid object data group";
383 TESTING_ASSERT(msg == e.what());
384 return;
385 }
386
387 TESTING_ASSERT(0);
388 }
389
testFuzzer25051(bool iUseMMap)390 void testFuzzer25051(bool iUseMMap)
391 {
392 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
393 try
394 {
395 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue25051.abc");
396 }
397 catch(const std::exception& e)
398 {
399 std::string msg = "Ogawa IData illegal size.";
400 TESTING_ASSERT(msg == e.what());
401 return;
402 }
403
404 TESTING_ASSERT(0);
405 }
406
testFuzzer25081(bool iUseMMap)407 void testFuzzer25081(bool iUseMMap)
408 {
409 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
410 ABCA::ArchiveReaderPtr ar;
411
412 try
413 {
414 ar = r("fuzzer_issue25081.abc");
415 }
416 catch(const std::exception& e)
417 {
418 std::string msg = "Invalid object data group";
419 TESTING_ASSERT(msg == e.what());
420 return;
421 }
422 TESTING_ASSERT(0);
423
424 }
425
testFuzzer25166(bool iUseMMap)426 void testFuzzer25166(bool iUseMMap)
427 {
428 // found issue with illegal meta data index
429 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
430 try
431 {
432 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue25166.abc");
433 }
434 catch(const std::exception& e)
435 {
436 std::string msg = "Read invalid: Property Header MetaData index.";
437 TESTING_ASSERT(msg == e.what());
438 return;
439 }
440 TESTING_ASSERT(0);
441 }
442
testFuzzer25175(bool iUseMMap)443 void testFuzzer25175(bool iUseMMap)
444 {
445 // seems to be fixed by fix for 25166 (bad meta data index)
446 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
447
448 try
449 {
450 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue25175.abc");
451 }
452 catch(const std::exception& e)
453 {
454 std::string msg = "Read invalid: Property Header MetaData index.";
455 TESTING_ASSERT(msg == e.what());
456 return;
457 }
458 TESTING_ASSERT(0);
459 }
460
testFuzzer25185(bool iUseMMap)461 void testFuzzer25185(bool iUseMMap)
462 {
463 // seems to be fixed by fix for 25166 (bad meta data index)
464 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
465 try
466 {
467 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue25185.abc");
468 }
469 catch(const std::exception& e)
470 {
471 std::string msg = "Read invalid: Property Header MetaData index.";
472 TESTING_ASSERT(msg == e.what());
473 return;
474 }
475 TESTING_ASSERT(0);
476 }
477
testFuzzer25192(bool iUseMMap)478 void testFuzzer25192(bool iUseMMap)
479 {
480 // found leak in AbcOgawa::OrData with raw pointer
481 // to m_children
482 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
483 try
484 {
485 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue25192.abc");
486 }
487 catch(const std::exception& e)
488 {
489 // In Issue 346 it was reported that on 32 bit systems
490 // we got the second error message, for now guard
491 // against it as well
492 std::string msg = e.what();
493 TESTING_ASSERT(msg == "Ogawa IStreams::read failed." ||
494 msg == "Ogawa IData illegal size.");
495 return;
496 }
497 TESTING_ASSERT(0);
498
499 }
500
testFuzzer25204(bool iUseMMap)501 void testFuzzer25204(bool iUseMMap)
502 {
503 // seems to be fixed by fix for 25166 (bad meta data index)
504 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
505 try
506 {
507 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue25204.abc");
508 }
509 catch(const std::exception& e)
510 {
511 std::string msg = "Read invalid: Property Header MetaData index.";
512 TESTING_ASSERT(msg == e.what());
513 return;
514 }
515 TESTING_ASSERT(0);
516 }
517
testFuzzer25236(bool iUseMMap)518 void testFuzzer25236(bool iUseMMap)
519 {
520 // seems to be fixed by fix for 25166 (bad meta data index)
521 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
522 try
523 {
524 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue25236.abc");
525 }
526 catch(const std::exception& e)
527 {
528 std::string msg = "Read invalid: Property Header MetaData index.";
529 TESTING_ASSERT(msg == e.what());
530 return;
531 }
532 TESTING_ASSERT(0);
533 }
534
testFuzzer25351(bool iUseMMap)535 void testFuzzer25351(bool iUseMMap)
536 {
537 // seems to be fixed by fix for 25166 (bad meta data index)
538 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
539 try
540 {
541 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue25351.abc");
542 }
543 catch(const std::exception& e)
544 {
545 std::string msg = "Read invalid: Property Header MetaData index.";
546 TESTING_ASSERT(msg == e.what());
547 return;
548 }
549 TESTING_ASSERT(0);
550 }
551
testFuzzer25502(bool iUseMMap)552 void testFuzzer25502(bool iUseMMap)
553 {
554 // leak on reading archive metadata because of throw
555 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
556 try
557 {
558 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue25502.abc");
559 }
560 catch(const std::exception& e)
561 {
562 std::string msg = "Invalid object data group";
563 TESTING_ASSERT(msg == e.what());
564 return;
565 }
566 TESTING_ASSERT(0);
567 }
568
testFuzzer25695(bool iUseMMap)569 void testFuzzer25695(bool iUseMMap)
570 {
571 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
572 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue25695.abc");
573 walkJustObj(ar->getTop());
574 try
575 {
576 walkObj(ar->getTop());
577 }
578 catch(const std::exception& e)
579 {
580 std::string msg = "ScalarPropertyReader::getSample size is not correct expected: 3 got: 9";
581 TESTING_ASSERT(msg == e.what());
582 return;
583 }
584 TESTING_ASSERT(0);
585 }
586
testFuzzer26125(bool iUseMMap)587 void testFuzzer26125(bool iUseMMap)
588 {
589 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
590 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue26125.abc");
591
592 try
593 {
594 walkJustObj(ar->getTop());
595 }
596 catch(const std::exception& e)
597 {
598 std::string msg = "Invalid object data group";
599 TESTING_ASSERT(msg == e.what());
600 }
601
602 try
603 {
604 walkObj(ar->getTop());
605 }
606 catch(const std::exception& e)
607 {
608 std::string msg = "Invalid object data group";
609 TESTING_ASSERT(msg == e.what());
610 return;
611 }
612
613 TESTING_ASSERT(0);
614 }
615
testFuzzer33685(bool iUseMMap)616 void testFuzzer33685(bool iUseMMap)
617 {
618 Alembic::AbcCoreOgawa::ReadArchive r(1, iUseMMap);
619 ABCA::ArchiveReaderPtr ar = r("fuzzer_issue33685.abc");
620
621 try
622 {
623 walkJustObj(ar->getTop());
624 }
625 catch(const std::exception& e)
626 {
627 std::string msg = "Invalid object data group";
628 TESTING_ASSERT(msg == e.what());
629 }
630
631 try
632 {
633 walkObj(ar->getTop());
634 }
635 catch(const std::exception& e)
636 {
637 std::string msg = "Invalid data in CprImpl(Object)";
638 TESTING_ASSERT(msg == e.what());
639 return;
640 }
641 }
642
main(int argc,char * argv[])643 int main ( int argc, char *argv[] )
644 {
645 testIssue254(true);
646 testIssue254(false);
647
648 testIssue255(true);
649 testIssue255(false);
650
651 testIssue256(true);
652 testIssue256(false);
653
654 testIssue257(true);
655 testIssue257(false);
656
657 testIssue258(true);
658 testIssue258(false);
659
660 testIssue269(true);
661 testIssue269(false);
662
663 testIssue270(true);
664 testIssue270(false);
665
666 testIssue271(true);
667 testIssue271(false);
668
669 testIssue272(true);
670 testIssue272(false);
671
672 testIssue282(true);
673 testIssue282(false);
674
675 testIssue283(true);
676 testIssue283(false);
677
678 testFuzzer24846(true);
679 testFuzzer24846(false);
680
681 testFuzzer24853(true);
682 testFuzzer24853(false);
683
684 testFuzzer24598(true);
685 testFuzzer24598(false);
686
687 testFuzzer25051(true);
688 testFuzzer25051(false);
689
690 testFuzzer25081(true);
691 testFuzzer25081(false);
692
693 testFuzzer25166(true);
694 testFuzzer25166(false);
695
696 testFuzzer25175(true);
697 testFuzzer25175(false);
698
699 testFuzzer25185(true);
700 testFuzzer25185(false);
701
702 testFuzzer25192(true);
703 testFuzzer25192(false);
704
705 testFuzzer25204(true);
706 testFuzzer25204(false);
707
708 testFuzzer25236(true);
709 testFuzzer25236(false);
710
711 testFuzzer25351(true);
712 testFuzzer25351(false);
713
714 testFuzzer25502(true);
715 testFuzzer25502(false);
716
717 testFuzzer25695(true);
718 testFuzzer25695(false);
719
720 testFuzzer26125(true);
721 testFuzzer26125(false);
722
723 testFuzzer33685(true);
724 testFuzzer33685(false);
725
726 return 0;
727 }
728