skip to main content
10.1145/3611643.3616294acmconferencesArticle/Chapter ViewAbstractPublication PagesfseConference Proceedingsconference-collections
research-article

Enhancing Coverage-Guided Fuzzing via Phantom Program

Published: 30 November 2023 Publication History

Abstract

For coverage-guided fuzzers, many of their adopted seeds are usually underused by exploring limited program states since essentially all their executions have to abide by rigorous program dependencies while only limited seeds are capable of accessing dependencies. Moreover, even when iteratively executing such limited seeds, the fuzzers have to repeatedly access the covered program states before uncovering new states. Such facts indicate that exploration power on program states of seeds has not been sufficiently leveraged by the existing coverage-guided fuzzing strategies. To tackle these issues, we propose a coverage-guided fuzzer, namely MirageFuzz, to mitigate the program dependencies when executing seeds for enhancing their exploration power on program states. Specifically, MirageFuzz first creates a “phantom” program of the target program by reducing its program dependencies corresponding to conditional statements while retaining their original semantics. Accordingly, MirageFuzz performs dual fuzzing, i.e., the source fuzzing to fuzz the original program and the phantom fuzzing to fuzz the phantom program simultaneously. Then, MirageFuzz applies the taint-based mutation mechanism to generate a new seed by updating the target conditional statement of a given seed from the source fuzzing with the corresponding condition value derived by the phantom fuzzing. To evaluate the effectiveness of MirageFuzz, we build a benchmark suite with 18 projects commonly adopted by recent fuzzing papers, and select seven open-source fuzzers as baselines for performance comparison with MirageFuzz. The experiment results suggest that MirageFuzz outperforms our baseline fuzzers from 13.42% to 77.96% averagely. Furthermore, MirageFuzz exposes 29 previously unknown bugs where 4 of them have been confirmed and 3 have been fixed by the corresponding developers.

Supplementary Material

Video (fse23main-p437-p-video.mp4)
"For coverage-guided fuzzers, many of their adopted seeds are usually underused by exploring limited program states since essentially all their executions have to abide by rigorous program dependencies while only limited seeds are capable of accessing dependencies. Moreover, even when iteratively executing such limited seeds, the fuzzers have to repeatedly access the covered program states before uncovering new states. Such facts indicate that exploration power on program states of seeds has not been sufficiently leveraged by the existing coverage-guided fuzzing strategies. To tackle these issues, we propose a coverage-guided fuzzer, namely MirageFuzz, to mitigate the program dependencies when executing seeds for enhancing their exploration power on program states. Specifically, MirageFuzz first creates a “phantom” program of the target program by reducing its program dependencies corresponding to conditional statements while retaining their original semantics. Accordingly, MirageFuzz performs dual fuzzing, i.e., the source fuzzing to fuzz the original program and the phantom fuzzing to fuzz the phantom program simultaneously. Then, MirageFuzz applies the taint-based mutation mechanism to generate a new seed by updating the target conditional statement of a given seed from the source fuzzing with the corresponding condition value derived by the phantom fuzzing. To evaluate the effectiveness of MirageFuzz, we build a benchmark suite with 18 projects commonly adopted by recent fuzzing papers, and select seven open-source fuzzers as baselines for performance comparison with MirageFuzz. The experiment results suggest that MirageFuzz outperforms our baseline fuzzers from 13.42% to 77.96% averagely. Furthermore, MirageFuzz exposes 29 previously unknown bugs where 4 of them have been confirmed and 3 have been fixed by the corresponding developers."

References

[1]
2022. All experiments detail in the paper. https://github.com/WorldExecute/exprs
[2]
2022. Control-flow graph generating pass of LLVM. https://llvm.org/docs/Passes.html##dot-cfg-print-cfg-of-function-to-dot-file
[3]
2022. Dominator and Immediate dominator, WiKipedia. https://en.wikipedia.org/wiki/Dominator_(graph_theory)
[4]
2022. Github Repository. 2022. MirageFuzz. https://github.com/WorldExecute/fuzzer
[5]
2022. jhead: a simple command line tool for displaying and some manipulation of EXIF header data embedded in Jpeg images from digital cameras. https://github.com/Matthias-Wandel/jhead
[6]
2022. jhead bug issue. https://github.com/Matthias-Wandel/jhead/issues/53
[7]
2022. laf-intel instrumentation. https://github.com/AFLplusplus/AFLplusplus/blob/stable/instrumentation/README.laf-intel.md
[8]
2022. libpng - library for use in applications that read, create, and manipulate PNG. https://github.com/glennrp/libpng
[9]
2022. Memory SSA in LLVM. https://llvm.org/docs/MemorySSA.html
[10]
2022. PCRE2 - Perl-Compatible Regular Expressions. https://github.com/PCRE2Project/pcre2
[11]
2022. pcre2 bug issue. https://github.com/PCRE2Project/pcre2/issues/141
[12]
2022. Perl - a highly capable, feature-rich programming language. https://www.perl.org/
[13]
2022. pngfix bug issue. https://github.com/glennrp/libpng/issues/424
[14]
2022. strip bug issue. https://sourceware.org/bugzilla/show_bug.cgi?id=29495
[15]
2023. LibFuzzer – a library for coverage-guided fuzz testing. https://llvm.org/docs/LibFuzzer.html
[16]
David F. Bacon, Susan L. Graham, and Oliver J. Sharp. 1994. Compiler Transformations for High-Performance Computing. ACM Comput. Surv., 26, 4 (1994), dec, 345–420. issn:0360-0300 https://doi.org/10.1145/197405.197406
[17]
Marcel Böhme, Van-Thuan Pham, Manh-Dung Nguyen, and Abhik Roychoudhury. 2017. Directed greybox fuzzing. In Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security. 2329–2344. https://doi.org/10.1145/3133956.3134020
[18]
Marcel Böhme, Van-Thuan Pham, and Abhik Roychoudhury. 2016. Coverage-Based Greybox Fuzzing as Markov Chain. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communications Security (CCS ’16). Association for Computing Machinery, New York, NY, USA. 1032–1043. isbn:9781450341394 https://doi.org/10.1145/2976749.2978428
[19]
Cristian Cadar, Daniel Dunbar, and Dawson R Engler. 2008. Klee: unassisted and automatic generation of high-coverage tests for complex systems programs. In OSDI. 8, 209–224. https://doi.org/10.5555/1855741.1855756
[20]
Thierry Titcheu Chekam, Mike Papadakis, Yves Le Traon, and Mark Harman. 2017. An Empirical Study on Mutation, Statement and Branch Coverage Fault Revelation That Avoids the Unreliable Clean Program Assumption. In Proceedings of the 39th International Conference on Software Engineering (ICSE ’17). IEEE Press, 597–608. isbn:9781538638682 https://doi.org/10.1109/ICSE.2017.61
[21]
Junjie Chen, Wenxiang Hu, Lingming Zhang, Dan Hao, Sarfraz Khurshid, and Lu Zhang. 2018. Learning to accelerate symbolic execution via code transformation. In 32nd European Conference on Object-Oriented Programming (ECOOP 2018).
[22]
Ju Chen, Jinghan Wang, Chengyu Song, and Heng Yin. 2022. JIGSAW: Efficient and Scalable Path Constraints Fuzzing. In 2022 IEEE Symposium on Security and Privacy (SP). 18–35. https://doi.org/10.1109/SP46214.2022.9833796
[23]
Peng Chen and Hao Chen. 2018. Angora: Efficient fuzzing by principled search. In 2018 IEEE Symposium on Security and Privacy (SP). 711–725. https://doi.org/10.1109/SP.2018.00046
[24]
Peng Chen, Jianzhong Liu, and Hao Chen. 2019. Matryoshka: fuzzing deeply nested branches. In Proceedings of the 2019 ACM SIGSAC Conference on Computer and Communications Security. 499–513. https://doi.org/10.1145/3319535.3363225
[25]
Yaohui Chen, Mansour Ahmadi, Boyu Wang, and Long Lu. 2020. $MEUZZ$: Smart Seed Scheduling for Hybrid Fuzzing. In 23rd International Symposium on Research in Attacks, Intrusions and Defenses (RAID 2020). 77–92.
[26]
Sushant Dinesh, Nathan Burow, Dongyan Xu, and Mathias Payer. 2020. RetroWrite: Statically Instrumenting COTS Binaries for Fuzzing and Sanitization. In 2020 IEEE Symposium on Security and Privacy, SP 2020, San Francisco, CA, USA, May 18-21, 2020. IEEE, 1497–1511. https://doi.org/10.1109/SP40000.2020.00009
[27]
Zhengjie Du, Yuekang Li, Yang Liu, Bing Mao, Ligeng Chen, Jian Guo, Zhongling He, Dongliang Mu, C Pang, and R Yu. 2022. WindRanger: A Directed Greybox Fuzzer driven by Deviation Basic Blocks. In 2022 IEEE/ACM 44st International Conference on Software Engineering: Companion Proceedings (ICSE-Companion). https://doi.org/10.1145/3510003.3510197
[28]
Andrea Fioraldi, Dominik Maier, Heiko Eiß feldt, and Marc Heuse. 2020. AFL++: Combining incremental steps of fuzzing research. In 14th $USENIX$ Workshop on Offensive Technologies ($WOOT$ 20).
[29]
Tianchang Gao, Junjie Chen, Yingquan Zhao, Yuqun Zhang, and Lingming Zhang. 2023. Vectorizing Program Ingredients for Better JVM Testing. In Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis. 526–537. https://doi.org/10.1145/3597926.3598075
[30]
Matheus E Garbelini, Vaibhav Bedi, Sudipta Chattopadhyay, Sumei Sun, and Ernest Kurniawan. 2022. $BrakTooth$: Causing Havoc on Bluetooth Link Manager via Directed Fuzzing. In 31st USENIX Security Symposium (USENIX Security 22). 1025–1042. https://www.usenix.org/conference/usenixsecurity22/presentation/garbelini
[31]
Alex Groce, Goutamkumar Tulajappa Kalburgi, Claire Le Goues, Kush Jain, and Rahul Gopinath. 2022. Registered report: First, fuzz the mutants. In International Fuzzing Workshop, ser. FUZZING. 22.
[32]
Mark Harman, André Baresel, David Binkley, Robert Hierons, Lin Hu, Bogdan Korel, Phil McMinn, and Marc Roper. 2008. Testability transformation–program transformation to improve testability. In Formal methods and testing. Springer, 320–344.
[33]
Adrian Herrera, Hendra Gunadi, Shane Magrath, Michael Norrish, Mathias Payer, and Antony L. Hosking. 2021. Seed Selection for Successful Fuzzing. In Proceedings of the 30th ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA 2021). Association for Computing Machinery, New York, NY, USA. 230–243. isbn:9781450384599 https://doi.org/10.1145/3460319.3464795
[34]
Chin-Chia Hsu, Che-Yu Wu, Hsu-Chun Hsiao, and Shih-Kun Huang. 2018. Instrim: Lightweight instrumentation for coverage-guided fuzzing. In Symposium on Network and Distributed System Security (NDSS), Workshop on Binary Analysis Research. https://doi.org/10.14722/bar.2018.23014
[35]
Ling Jiang, Hengchen Yuan, Mingyuan Wu, Lingming Zhang, and Yuqun Zhang. 2023. Evaluating and Improving Hybrid Fuzzing. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). 410–422. https://doi.org/10.1109/ICSE48619.2023.00045
[36]
Vasileios P Kemerlis, Georgios Portokalidis, Kangkook Jee, and Angelos D Keromytis. 2012. libdft: Practical dynamic data flow tracking for commodity systems. In Proceedings of the 8th ACM SIGPLAN/SIGOPS conference on Virtual Execution Environments. 121–132. https://doi.org/10.1145/2365864.2151042
[37]
George Klees, Andrew Ruef, Benji Cooper, Shiyi Wei, and Michael Hicks. 2018. Evaluating fuzz testing. In Proceedings of the 2018 ACM SIGSAC Conference on Computer and Communications Security. 2123–2138. https://doi.org/10.1145/3243734.3243804
[38]
B. Korel, M. Harman, S. Chung, P. Apirukvorapinit, R. Gupta, and Q. Zhang. 2005. Data dependence based testability transformation in automated test generation. In 16th IEEE International Symposium on Software Reliability Engineering (ISSRE’05). 10 pp.–254. https://doi.org/10.1109/ISSRE.2005.16
[39]
James Kukucka, Lu&''x00ED, s Pina, Paul Ammann, and Jonathan Bell. 2022. CONFETTI: Amplifying Concolic Guidance for Fuzzers. In 2022 IEEE/ACM 44th International Conference on Software Engineering (ICSE). 438–450. https://doi.org/10.1145/3510003.3510628
[40]
Chris Lattner. 2008. LLVM and Clang: Next generation compiler technology. In The BSD conference. 5, 1–20.
[41]
Chris Lattner and Vikram Adve. 2004. LLVM: A compilation framework for lifelong program analysis & transformation. In International Symposium on Code Generation and Optimization, 2004. CGO 2004. 75–86.
[42]
Caroline Lemieux and Koushik Sen. 2018. Fairfuzz: A targeted mutation strategy for increasing greybox fuzz testing coverage. In Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering. 475–485. https://doi.org/10.1145/3238147.3238176
[43]
Yuekang Li, Bihuan Chen, Mahinthan Chandramohan, Shang-Wei Lin, Yang Liu, and Alwen Tiu. 2017. Steelix: program-state based binary fuzzing. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering. 627–637. https://doi.org/10.1145/3106237.3106295
[44]
Hongliang Liang, Xiaoxiao Pei, Xiaodong Jia, Wuwei Shen, and Jian Zhang. 2018. Fuzzing: State of the art. IEEE Transactions on Reliability, 67, 3 (2018), 1199–1218. https://doi.org/10.1109/TR.2018.2834476
[45]
Jie Liang, Mingzhe Wang, Chijin Zhou, Zhiyong Wu, Yu Jiang, Jianzhong Liu, Zhe Liu, and Jiaguang Sun. 2022. PATA: Fuzzing with Path Aware Taint Analysis. In 2022 IEEE Symposium on Security and Privacy (SP). 1–17. https://doi.org/10.1109/SP46214.2022.9833594
[46]
Yuwei Liu, Yanhao Wang, Purui Su, Yuanping Yu, and Xiangkun Jia. 2021. InstruGuard: Find and Fix Instrumentation Errors for Coverage-based Greybox Fuzzing. In 2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE). 568–580. https://doi.org/10.1109/ASE51524.2021.9678671
[47]
Chenyang Lyu, Shouling Ji, Chao Zhang, Yuwei Li, Wei-Han Lee, Yu Song, and Raheem Beyah. 2019. $MOPT$: Optimized mutation scheduling for fuzzers. In 28th $USENIX$ Security Symposium ($USENIX$ Security 19). 1949–1966. https://www.usenix.org/conference/usenixsecurity19/presentation/lyu
[48]
Thomas W MacFarland and Jan M Yates. 2016. Mann–whitney u test. In Introduction to nonparametric statistics for the biological sciences using R. Springer, 103–132.
[49]
Hector D. Menendez and David Clark. 2021. Hashing Fuzzing: Introducing Input Diversity to Improve Crash Detection. IEEE Transactions on Software Engineering, 1–1. https://doi.org/10.1109/TSE.2021.3100858
[50]
Jonathan Metzman, László Szekeres, Laurent Simon, Read Sprabery, and Abhishek Arya. 2021. Fuzzbench: an open fuzzer benchmarking platform and service. In Proceedings of the 29th ACM joint meeting on European software engineering conference and symposium on the foundations of software engineering. 1393–1403. https://doi.org/10.1145/3468264.3473932
[51]
Leonardo de Moura and Nikolaj Bjørner. 2008. Z3: An efficient SMT solver. In International conference on Tools and Algorithms for the Construction and Analysis of Systems. 337–340. https://doi.org/10.1007/978-3-540-78800-3_24
[52]
Stefan Nagy and Matthew Hicks. 2019. Full-Speed Fuzzing: Reducing Fuzzing Overhead through Coverage-Guided Tracing. In 2019 IEEE Symposium on Security and Privacy, SP 2019, San Francisco, CA, USA, May 19-23, 2019. IEEE, 787–802. https://doi.org/10.1109/SP.2019.00069
[53]
Diego Novillo. 2007. Memory SSA-a unified approach for sparsely representing memory operations. In Proceedings of the GCC Developers’ Summit. 97–110.
[54]
Mike Papadakis, Marinos Kintis, Jie Zhang, Yue Jia, Yves Le Traon, and Mark Harman. 2019. Mutation testing advances: an analysis and survey. In Advances in Computers. 112, Elsevier, 275–378. https://doi.org/10.1016/bs.adcom.2018.03.015
[55]
Mike Papadakis, Donghwan Shin, Shin Yoo, and Doo-Hwan Bae. 2018. Are mutation scores correlated with real fault detection? a large scale empirical study on the relationship between mutants and real faults. In Proceedings of the 40th International Conference on Software Engineering. 537–548. https://doi.org/10.1145/3180155.3180183
[56]
Hui Peng, Yan Shoshitaishvili, and Mathias Payer. 2018. T-Fuzz: Fuzzing by Program Transformation. In 2018 IEEE Symposium on Security and Privacy (SP). 697–710. https://doi.org/10.1109/SP.2018.00056
[57]
Ruixiang Qian, Quanjun Zhang, Chunrong Fang, and Lihua Guo. 2022. Investigating Coverage Guided Fuzzing with Mutation Testing. In Proceedings of the 13th Asia-Pacific Symposium on Internetware (Internetware ’22). Association for Computing Machinery, New York, NY, USA. 272–281. isbn:9781450397803 https://doi.org/10.1145/3545258.3545285
[58]
Sanjay Rawat, Vivek Jain, Ashish Kumar, Lucian Cojocar, Cristiano Giuffrida, and Herbert Bos. 2017. VUzzer: Application-aware Evolutionary Fuzzing. In 24th Annual Network and Distributed System Security Symposium, NDSS 2017, San Diego, California, USA, February 26 - March 1, 2017. The Internet Society. https://doi.org/10.14722/ndss.2017.23404
[59]
Barry K Rosen, Mark N Wegman, and F Kenneth Zadeck. 1988. Global value numbers and redundant computations. In Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. 12–27. https://doi.org/10.1145/73560.73562
[60]
Edward J. Schwartz, Thanassis Avgerinos, and David Brumley. 2010. All You Ever Wanted to Know about Dynamic Taint Analysis and Forward Symbolic Execution (but Might Have Been Afraid to Ask). In 2010 IEEE Symposium on Security and Privacy. 317–331. https://doi.org/10.1109/SP.2010.26
[61]
Dongdong She, Rahul Krishna, Lu Yan, Suman Jana, and Baishakhi Ray. 2020. MTFuzz: fuzzing with a multi-task neural network. In Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering. 737–749. https://doi.org/10.1145/3410251
[62]
Dongdong She, Kexin Pei, Dave Epstein, Junfeng Yang, Baishakhi Ray, and Suman Jana. 2019. Neuzz: Efficient fuzzing with neural program smoothing. In 2019 IEEE Symposium on Security and Privacy (SP). 803–817. https://doi.org/10.1109/SP.2019.00052
[63]
Dongdong She, Abhishek Shah, and Suman Jana. 2022. Effective Seed Scheduling for Fuzzing with Graph Centrality Analysis. In 2022 IEEE Symposium on Security and Privacy (SP). 2194–2211. https://doi.org/10.1109/SP46214.2022.9833761
[64]
Zekun Shen, Ritik Roongta, and Brendan Dolan-Gavitt. 2022. Drifuzz: Harvesting Bugs in Device Drivers from Golden Seeds. In 31st USENIX Security Symposium (USENIX Security 22). USENIX Association, 1275–1290. https://www.usenix.org/conference/usenixsecurity22/presentation/shen-zekun
[65]
Chaofan Shou, Ismet Burak Kadron, Qi Su, and Tevfik Bultan. 2021. Corbfuzz: Checking browser security policies with fuzzing. In 2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE). 215–226. https://doi.org/10.1109/ASE51524.2021.9678636
[66]
Abraham Silberschatz, Peter B Galvin, and Greg Gagne. 2018. Operating System Concepts, 10e Abridged Print Companion. John Wiley & Sons.
[67]
Evgeniy Stepanov and Konstantin Serebryany. 2015. MemorySanitizer: fast detector of uninitialized memory use in C++. In 2015 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). 46–55. https://doi.org/10.1109/CGO.2015.7054186
[68]
Zhao Tian, Junjie Chen, Qihao Zhu, Junjie Yang, and Lingming Zhang. 2022. Learning to construct better mutation faults. In Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering. 1–13. https://doi.org/10.1145/3551349.3556949
[69]
Mingzhe Wang, Jie Liang, Chijin Zhou, Yu Jiang, Rui Wang, Chengnian Sun, and Jiaguang Sun. 2021. RIFF: Reduced Instruction Footprint for Coverage-Guided Fuzzing. In 2021 USENIX Annual Technical Conference (USENIX ATC 21). USENIX Association, 147–159. https://www.usenix.org/conference/atc21/presentation/wang-mingzhe
[70]
Yanhao Wang, Xiangkun Jia, Yuwei Liu, Kyle Zeng, Tiffany Bao, Dinghao Wu, and Purui Su. 2020. Not All Coverage Measurements Are Equal: Fuzzing by Coverage Accounting for Input Prioritization. In NDSS. https://doi.org/10.14722/ndss.2020.24422
[71]
Mark Weiser. 1984. Program slicing. IEEE Transactions on software engineering, 352–357. https://doi.org/10.1109/TSE.1984.5010248
[72]
Mingyuan Wu, Ling Jiang, Jiahong Xiang, Yanwei Huang, Heming Cui, Lingming Zhang, and Yuqun Zhang. 2022. One Fuzzing Strategy to Rule Them All. In 2022 IEEE/ACM 44th International Conference on Software Engineering (ICSE). https://doi.org/10.1145/3510003.3510174
[73]
Mingyuan Wu, Ling Jiang, Jiahong Xiang, Yuqun Zhang, Guowei Yang, Huixin Ma, Sen Nie, Shi Wu, Heming Cui, and Lingming Zhang. 2022. Evaluating and Improving Neural Program-Smoothing-based Fuzzing. In 2022 IEEE/ACM 44th International Conference on Software Engineering (ICSE). 847–858. https://doi.org/10.1145/3510003.3510089
[74]
Mingyuan Wu, Minghai Lu, Heming Cui, Junjie Chen, Yuqun Zhang, and Lingming Zhang. 2023. JITfuzz: Coverage-guided Fuzzing for JVM Just-in-Time Compilers. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). 56–68. https://doi.org/10.1109/ICSE48619.2023.00017
[75]
Mingyuan Wu, Yicheng Ouyang, Minghai Lu, Junjie Chen, Yingquan Zhao, Heming Cui, Yangwei Guo, and Yuqun Zhang. 2023. SJFuzz: Seed & Mutator Scheduling for JVM Fuzzing. In 2023 The ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE). https://doi.org/10.1145/3611643.3616277
[76]
Mingyuan Wu, Lingming Zhang, Cong Liu, Shin Hwei Tan, and Yuqun Zhang. 2019. Automating CUDA synchronization via program transformation. In 2019 34th IEEE/ACM International Conference on Automated Software Engineering (ASE). 748–759. https://doi.org/10.1109/ASE.2019.00075
[77]
Insu Yun, Sangho Lee, Meng Xu, Yeongjin Jang, and Taesoo Kim. 2018. $QSYM$: A practical concolic execution engine tailored for hybrid fuzzing. In 27th $USENIX$ Security Symposium ($USENIX$ Security 18). USENIX Association, 745–761. https://www.usenix.org/conference/usenixsecurity18/presentation/yun
[78]
Michał Zalewski. 2020. American Fuzz Lop. https://github.com/google/AFL
[79]
G Zhang, P Wang, T Yue, X Kong, S Huang, X Zhou, and K Lu. 2022. Mobfuzz: Adaptive multi-objective optimization in gray-box fuzzing. In Network and Distributed Systems Security (NDSS) Symposium 2022. https://doi.org/10.14722/ndss.2022.24314
[80]
Kunpeng Zhang, Xi Xiao, Xiaogang Zhu, Ruoxi Sun, Minhui Xue, and Sheng Wen. 2022. Path Transitions Tell More: Optimizing Fuzzing Schedules via Runtime Program States. In 2022 IEEE/ACM 44th International Conference on Software Engineering (ICSE). 1658–1668. https://doi.org/10.1145/3510003.3510063
[81]
Mengshi Zhang, Yuqun Zhang, Lingming Zhang, Cong Liu, and Sarfraz Khurshid. 2018. DeepRoad: GAN-Based Metamorphic Testing and Input Validation Framework for Autonomous Driving Systems. In 2018 33rd IEEE/ACM International Conference on Automated Software Engineering (ASE). 132–142. https://doi.org/10.1145/3238147.3238187
[82]
Yingquan Zhao, Zan Wang, Junjie Chen, Mengdi Liu, Mingyuan Wu, Yuqun Zhang, and Lingming Zhang. 2022. History-driven test program synthesis for JVM testing. In Proceedings of the 44th International Conference on Software Engineering. 1133–1144. https://doi.org/10.1145/3510003.3510059
[83]
Husheng Zhou, Wei Li, Zelun Kong, Junfeng Guo, Yuqun Zhang, Bei Yu, Lingming Zhang, and Cong Liu. 2020. DeepBillboard: Systematic Physical-World Testing of Autonomous Driving Systems. In 2020 IEEE/ACM 42nd International Conference on Software Engineering (ICSE). 347–358. https://doi.org/10.1145/3377811.3380422

Cited By

View all
  • (2025)Novelty Not Found: Exploring Input Shadowing in Fuzzing through Adaptive Fuzzer RestartsACM Transactions on Software Engineering and Methodology10.1145/371218634:3(1-32)Online publication date: 16-Jan-2025
  • (2024)Visualizing and Understanding the Internals of FuzzingProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering10.1145/3691620.3695284(2199-2204)Online publication date: 27-Oct-2024
  • (2024)My Fuzzers Won’t Build: An Empirical Study of Fuzzing Build FailuresACM Transactions on Software Engineering and Methodology10.1145/368884234:2(1-30)Online publication date: 21-Aug-2024
  • Show More Cited By

Recommendations

Comments

Information & Contributors

Information

Published In

cover image ACM Conferences
ESEC/FSE 2023: Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering
November 2023
2215 pages
ISBN:9798400703270
DOI:10.1145/3611643
Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than the author(s) must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected].

Sponsors

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 30 November 2023

Permissions

Request permissions for this article.

Check for updates

Author Tags

  1. Coverage Guidance
  2. Fuzzing
  3. Phantom Program

Qualifiers

  • Research-article

Funding Sources

Conference

ESEC/FSE '23
Sponsor:

Acceptance Rates

Overall Acceptance Rate 112 of 543 submissions, 21%

Contributors

Other Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

  • Downloads (Last 12 months)125
  • Downloads (Last 6 weeks)9
Reflects downloads up to 05 Mar 2025

Other Metrics

Citations

Cited By

View all
  • (2025)Novelty Not Found: Exploring Input Shadowing in Fuzzing through Adaptive Fuzzer RestartsACM Transactions on Software Engineering and Methodology10.1145/371218634:3(1-32)Online publication date: 16-Jan-2025
  • (2024)Visualizing and Understanding the Internals of FuzzingProceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering10.1145/3691620.3695284(2199-2204)Online publication date: 27-Oct-2024
  • (2024)My Fuzzers Won’t Build: An Empirical Study of Fuzzing Build FailuresACM Transactions on Software Engineering and Methodology10.1145/368884234:2(1-30)Online publication date: 21-Aug-2024
  • (2024)BinaryAI: Binary Software Composition Analysis via Intelligent Binary Source Code MatchingProceedings of the IEEE/ACM 46th International Conference on Software Engineering10.1145/3597503.3639100(1-13)Online publication date: 20-May-2024
  • (2024)History-driven Compiler Fuzzing via Assembling and Scheduling Bug-triggering Code Segments2024 IEEE 35th International Symposium on Software Reliability Engineering (ISSRE)10.1109/ISSRE62328.2024.00040(331-342)Online publication date: 28-Oct-2024
  • (2023)SJFuzz: Seed and Mutator Scheduling for JVM FuzzingProceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering10.1145/3611643.3616277(1062-1074)Online publication date: 30-Nov-2023

View Options

Login options

View options

PDF

View or Download as a PDF file.

PDF

eReader

View online with eReader.

eReader

Figures

Tables

Media

Share

Share

Share this Publication link

Share on social media