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