[go: up one dir, main page]
More Web Proxy on the site http://driver.im/ skip to main content
10.1145/3611643.3616277acmconferencesArticle/Chapter ViewAbstractPublication PagesfseConference Proceedingsconference-collections
research-article

SJFuzz: Seed and Mutator Scheduling for JVM Fuzzing

Published: 30 November 2023 Publication History

Abstract

While the Java Virtual Machine (JVM) plays a vital role in ensuring correct executions of Java applications, testing JVMs via generating and running class files on them can be rather challenging. The existing techniques, e.g., ClassFuzz and Classming, attempt to leverage the power of fuzzing and differential testing to cope with JVM intricacies by exposing discrepant execution results among different JVMs, i.e., inter-JVM discrepancies, for testing analytics. However, their adopted fuzzers are insufficiently guided since they include no well-designed seed and mutator scheduling mechanisms, leading to inefficient differential testing. To address such issues, in this paper, we propose SJFuzz, the first JVM fuzzing framework with seed and mutator scheduling mechanisms for automated JVM differential testing. Overall, SJFuzz aims to mutate class files via control flow mutators to facilitate the exposure of inter-JVM discrepancies. To this end, SJFuzz schedules seeds (class files) for mutations based on the discrepancy and diversity guidance. SJFuzz also schedules mutators for diversifying class file generation. To evaluate SJFuzz, we conduct an extensive study on multiple representative real-world JVMs, and the experimental results show that SJFuzz significantly outperforms the state-of-the-art mutation-based and generation-based JVM fuzzers in terms of the inter-JVM discrepancy exposure and the class file diversity. Moreover, SJFuzz successfully reported 46 potential JVM issues, and 20 of them have been confirmed as bugs and 16 have been fixed by the JVM developers.

Supplementary Material

Video (fse23main-p296-p-video.mp4)
"Automation testing is widely used in the functional testing of web applications. However, during the evolution of web applications, such web test scripts tend to break. It is essential to repair such broken test scripts to make regression testing run successfully. As manual repairing is time-consuming and expensive, researchers focus on automatic repairing techniques. Empirical study shows that the web element locator is the leading cause of web test breakages. Most existing repair techniques utilize Document Object Model attributes or visual appearances of elements to find their location but neglect their semantic information. This paper proposes a novel semantic repair technique called textbf{Sem}antic textbf{Te}st textbf{R}epair (Semter) for web test repair. Our approach captures relevant semantic information from test executions on the application’s basic version and locates target elements by calculating semantic similarity between elements to repair tests. Our approach can also repair test workflow due to web page additions or deletions by a local exploration in the updated version. We evaluated the efficacy of our technique on six real-world web applications compared with three baselines. Experimental results show that Semter achieves an 84% average repair ratio within an acceptable time cost, significantly outperforming the state-of-the-art web test repair techniques."

References

[1]
2020. JIt Bug. https://github.com/eclipse/openj9/issues/9381
[2]
2020. Spring Verify Error. https://github.com/eclipse/openj9/issues/5676
[3]
2020. Structured Locking Issue. https://github.com/eclipse/openj9/issues/9276
[4]
2020. Verify Bug. https://github.com/eclipse/openj9/issues/9385
[5]
2021. Motivate Examples. https://github.com/eclipse/openj9/issues/11683
[6]
2021. Motivate Examples. https://github.com/eclipse/openj9/issues/11684
[7]
2022. AFL. https://lcamtuf.coredump.cx/afl/
[8]
2022. Apache Project. https://projects.apache.org/projects.html?language
[9]
2022. Coevolutionary Algorithm. https://wiki.ece.cmu.edu/ddl/index.php/Coevolutionary_algorithms
[10]
2022. Definition of Distinct Discrepancy. https://github.com/fuzzy000/SJFuzz/blob/main/src/com/djfuzz/solver/JVMOutputParser.java
[11]
2022. DragonWell11. https://github.com/alibaba/dragonwell11
[12]
2022. DragonWell8. https://github.com/alibaba/dragonwell8
[13]
2022. Gestalt Pattern Matching Distance. https://en.wikipedia.org/wiki/Gestalt_pattern_matching
[14]
2022. GIJ. https://gcc.gnu.org/onlinedocs/gcc-6.5.0/gcj/
[15]
2022. HotSpot. http://openjdk.java.net
[16]
2022. J9. http://www.ibm.com/developerworks/java/ jdk
[17]
2022. Jaro Distance. https://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance
[18]
2022. The Java Virtual Machine Specification. https://docs.oracle.com/javase/specs/index.html
[19]
2022. JUnit Official Website. https://junit.org/
[20]
2022. JVM. https://en.wikipedia.org/wiki/Java_virtual_machine
[21]
2022. Main Repo for SJFuzz. https://github.com/fuzzy000/SJFuzz
[22]
2022. Monte Carlo Method. https://en.wikipedia.org/wiki/Monte_Carlo_method
[23]
2022. Zulu. http://www.azulsystems.com/products/zulu
[24]
2023. Complement (set theory). https://en.wikipedia.org/wiki/Complement_(set_theory)
[25]
Cornelius Aschermann, Sergej Schumilo, Tim Blazytko, Robert Gawlik, and Thorsten Holz. 2019. REDQUEEN: Fuzzing with Input-to-State Correspondence. In NDSS. 19, 1–15. https://doi.org/10.14722/ndss.2019.23371
[26]
Peter Auer, Nicolo Cesa-Bianchi, and Paul Fischer. 2002. Finite-time analysis of the multiarmed bandit problem. Machine learning, 47, 2 (2002), 235–256.
[27]
Ilaria Bartolini, Paolo Ciaccia, and Marco Patella. 2002. String matching with metric trees using an approximate distance. In String Processing and Information Retrieval: 9th International Symposium, SPIRE 2002 Lisbon, Portugal, September 11–13, 2002 Proceedings 9. 271–283.
[28]
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
[29]
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
[30]
A. Calvagna and E. Tramontana. 2013. Automated Conformance Testing of Java Virtual Machines. In 2013 Seventh International Conference on Complex, Intelligent, and Software Intensive Systems. 547–552. https://doi.org/10.1109/CISIS.2013.99
[31]
Junjie Chen, Haoyang Ma, and Lingming Zhang. 2020. Enhanced compiler bug isolation via memoized search. In Proceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering. 78–89. https://doi.org/10.1145/3324884.3416570
[32]
Junjie Chen, Jibesh Patra, Michael Pradel, Yingfei Xiong, Hongyu Zhang, Dan Hao, and Lu Zhang. 2020. A survey of compiler testing. Comput. Surveys, 53, 1 (2020), 1–36. https://doi.org/10.1145/3363562
[33]
Junjie Chen, Chenyao Suo, Jiajun Jiang, Peiqi Chen, and Xingjian Li. 2023. Compiler Test-Program Generation via Memoized Configuration Search. In 45th IEEE/ACM International Conference on Software Engineering. IEEE, 2035–2047. https://doi.org/10.1109/ICSE48619.2023.00172
[34]
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.
[35]
Yang Chen, Alex Groce, Chaoqiang Zhang, Weng-Keen Wong, Xiaoli Fern, Eric Eide, and John Regehr. 2013. Taming Compiler Fuzzers. SIGPLAN Not., 48, 6 (2013), jun, 197–208. issn:0362-1340 https://doi.org/10.1145/2499370.2462173
[36]
Yuanliang Chen, Yu Jiang, Fuchen Ma, Jie Liang, Mingzhe Wang, Chijin Zhou, Xun Jiao, and Zhuo Su. 2019. $EnFuzz$: Ensemble Fuzzing with Seed Synchronization among Diverse Fuzzers. In 28th USENIX Security Symposium (USENIX Security 19). 1967–1983. https://www.usenix.org/conference/usenixsecurity19/presentation/chen-yuanliang
[37]
Yaohui Chen, Peng Li, Jun Xu, Shengjian Guo, Rundong Zhou, Yulong Zhang, Tao Wei, and Long Lu. 2020. Savior: Towards bug-driven hybrid testing. In 2020 IEEE Symposium on Security and Privacy (SP). 1580–1596. https://doi.org/10.1109/SP40000.2020.00002
[38]
Yuting Chen, Ting Su, and Zhendong Su. 2019. Deep differential testing of JVM implementations. In 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). 1257–1268. https://doi.org/10.1109/ICSE.2019.00127
[39]
Yuting Chen, Ting Su, Chengnian Sun, Zhendong Su, and Jianjun Zhao. 2016. Coverage-directed differential testing of JVM implementations. In proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation. 85–99. https://doi.org/10.1145/2908080.2908095
[40]
Chris Cummins, Pavlos Petoumenos, Alastair Murray, and Hugh Leather. 2018. Compiler fuzzing through deep learning. In Proceedings of the 27th ACM SIGSOFT International Symposium on Software Testing and Analysis. 95–105. https://doi.org/10.1145/3213846.3213848
[41]
Alastair F Donaldson, Hugues Evrard, Andrei Lascu, and Paul Thomson. 2017. Automated testing of graphics shader compilers. Proceedings of the ACM on Programming Languages, 1, OOPSLA (2017), 1–29. https://doi.org/10.1145/3133917
[42]
Russell Eberhart and James Kennedy. 1995. A new optimizer using particle swarm theory. In MHS’95. Proceedings of the sixth international symposium on micro machine and human science. 39–43.
[43]
Robert B. Evans and Alberto Savoia. 2007. Differential Testing: A New Approach to Change Detection. In Proceedings of the the 6th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on The Foundations of Software Engineering (ESEC-FSE ’07). Association for Computing Machinery, New York, NY, USA. 549–552. isbn:9781595938114 https://doi.org/10.1145/1287624.1287707
[44]
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). USENIX Association. https://www.usenix.org/conference/woot20/presentation/fioraldi
[45]
Stephen N Freund and John C Mitchell. 2003. A type system for the Java bytecode language and verifier. Journal of Automated Reasoning, 30, 3-4 (2003), 271–321.
[46]
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
[47]
Patrice Godefroid. 2020. Fuzzing: Hack, Art, and Science. Commun. ACM, 63, 2 (2020), jan, 70–76. issn:0001-0782 https://doi.org/10.1145/3363824
[48]
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
[49]
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
[50]
Vu Le, Chengnian Sun, and Zhendong Su. 2015. Finding deep compiler bugs via guided stochastic program mutation. ACM SIGPLAN Notices, 50, 10 (2015), 386–399. https://doi.org/10.1145/2858965.2814319
[51]
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
[52]
Vladimir I Levenshtein. 1966. Binary codes capable of correcting deletions, insertions, and reversals. In Soviet physics doklady. 10, 707–710.
[53]
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
[54]
Yuekang Li, Yinxing Xue, Hongxu Chen, Xiuheng Wu, Cen Zhang, Xiaofei Xie, Haijun Wang, and Yang Liu. 2019. Cerebro: Context-Aware Adaptive Fuzzing for Effective Vulnerability Detection. In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE 2019). Association for Computing Machinery, New York, NY, USA. 533–544. isbn:9781450355728 https://doi.org/10.1145/3338906.3338975
[55]
Xiao Liu, Xiaoting Li, Rupesh Prajapati, and Dinghao Wu. 2019. Deepfuzz: Automatic generation of syntax valid c programs for fuzz testing. In Proceedings of the AAAI Conference on Artificial Intelligence. 33, 1044–1051. https://doi.org/10.1609/aaai.v33i01.33011044
[56]
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.
[57]
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.
[58]
Rohan Padhye, Caroline Lemieux, Koushik Sen, Mike Papadakis, and Yves Le Traon. 2019. Semantic fuzzing with zest. In Proceedings of the 28th ACM SIGSOFT International Symposium on Software Testing and Analysis. 329–340. https://doi.org/10.1145/3293882.3330576
[59]
Sebastian Poeplau and Aurélien Francillon. 2020. Symbolic execution with SymCC: Don’ t interpret, compile!. In 29th USENIX Security Symposium (USENIX Security 20). USENIX Association, 181–198. isbn:978-1-939133-17-5 https://www.usenix.org/conference/usenixsecurity20/presentation/poeplau
[60]
A. Savary, M. Frappier, and J. Lanet. 2011. Automatic Generation of Vulnerability Tests for the Java Card Byte Code Verifier. In 2011 Conference on Network and Information Systems Security. 1–7. https://doi.org/10.1109/SAR-SSI.2011.5931379
[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/3368089.3409723
[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]
D. She, A. Shah, and S. Jana. 2022. Effective Seed Scheduling for Fuzzing with Graph Centrality Analysis. In 2022 2022 IEEE Symposium on Security and Privacy (SP) (SP). IEEE Computer Society, Los Alamitos, CA, USA. 1558–1558. issn:2375-1207 https://doi.org/10.1109/SP46214.2022.9833761
[64]
E. G. Sirer and B. N. Bershad. 1999. Testing Java Virtual Machines, An Experience Report on Automatically Testing Java Virtual Machines. Proc. Int. Conf. on Software Testing And Review.
[65]
Nick Stephens, John Grosen, Christopher Salls, Andrew Dutcher, Ruoyu Wang, Jacopo Corbetta, Yan Shoshitaishvili, Christopher Krügel, and Giovanni Vigna. 2016. Driller: Augmenting Fuzzing Through Selective Symbolic Execution. In NDSS.
[66]
Raja Vallée-Rai, Phong Co, Etienne Gagnon, Laurie Hendren, Patrick Lam, and Vijay Sundaresan. 1999. Soot - a Java Bytecode Optimization Framework. In Proceedings of the 1999 Conference of the Centre for Advanced Studies on Collaborative Research (CASCON ’99). IBM Press, 13.
[67]
Raja Vallee-Rai and Laurie J. Hendren. 1998. Jimple: Simplifying Java Bytecode for Analyses and Transformations.
[68]
Mingyuan Wu, Kunqiu Chen, Qi Luo, Jiahong Xiang, Ji Qi, Junjie Chen, Heming Cui, and Yuqun Zhang. 2023. Enhancing Coverage-guided Fuzzing via Phantom Program. 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.3616294
[69]
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
[70]
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
[71]
Mingyuan Wu, Minghai Lu, Heming Cui, Junjie Chen, Yuqun Zhang, and Lingming Zhang. [n. d.]. Jitfuzz: Coverage-guided fuzzing for jvm just-in-time compilers. In Proceedings of the 45th International Conference on Software Engineering, ser. ICSE. 23, https://doi.org/10.1109/ICSE48619.2023.00017
[72]
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
[73]
Xiaofei Xie, Lei Ma, Felix Juefei-Xu, Minhui Xue, Hongxu Chen, Yang Liu, Jianjun Zhao, Bo Li, Jianxiong Yin, and Simon See. 2019. Deephunter: a coverage-guided fuzz testing framework for deep neural networks. In Proceedings of the 28th ACM SIGSOFT International Symposium on Software Testing and Analysis. 146–157. https://doi.org/10.1145/3293882.3330579
[74]
Xuejun Yang, Yang Chen, Eric Eide, and John Regehr. 2011. Finding and Understanding Bugs in C Compilers. In Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’11). isbn:9781450306638 https://doi.org/10.1145/3293882.3330579
[75]
Takahide Yoshikawa, Kouya Shimura, and Toshihiro Ozawa. 2003. Random program generator for Java JIT compiler test system. In Third International Conference on Quality Software, 2003. Proceedings. 20–23.
[76]
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). 745–761. https://www.usenix.org/conference/usenixsecurity18/presentation/yun
[77]
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 Proceedings of the 44th International Conference on Software Engineering (ICSE ’22). Association for Computing Machinery, New York, NY, USA. 1658–1668. isbn:9781450392211 https://doi.org/10.1145/3510003.3510063
[78]
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). https://doi.org/10.1145/3510003.3510063
[79]
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
[80]
Lei Zhao, Yue Duan, Heng Yin, and Jifeng Xuan. 2019. Send hardest problems my way: Probabilistic path prioritization for hybrid fuzzing. In NDSS.
[81]
Yingquan Zhao, Junjie Chen, Ruifeng Fu, Haojie Ye, and Zan Wang. 2023. Testing the Compiler for a New-Born Programming Language: An Industrial Case Study (Experience Paper). In Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis. 551–563. https://doi.org/10.1145/3597926.3598077
[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 (ICSE ’22). Association for Computing Machinery, New York, NY, USA. 1133–1144. isbn:9781450392211 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
  • (2024)Program Ingredients Abstraction and Instantiation for Synthesis-based JVM TestingProceedings of the 2024 on ACM SIGSAC Conference on Computer and Communications Security10.1145/3658644.3690366(3943-3957)Online publication date: 2-Dec-2024
  • (2024)Wapplique: Testing WebAssembly Runtime via Execution Context-Aware Bytecode MutationProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3650212.3680340(1035-1047)Online publication date: 11-Sep-2024
  • (2024)Java JIT Testing with Template ExtractionProceedings of the ACM on Software Engineering10.1145/36437771:FSE(1129-1151)Online publication date: 12-Jul-2024
  • Show More Cited By

Recommendations

Comments

Please enable JavaScript to view thecomments powered by Disqus.

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. JVM Testing
  2. Mutation-based Fuzzing

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)182
  • Downloads (Last 6 weeks)18
Reflects downloads up to 03 Jan 2025

Other Metrics

Citations

Cited By

View all
  • (2024)Program Ingredients Abstraction and Instantiation for Synthesis-based JVM TestingProceedings of the 2024 on ACM SIGSAC Conference on Computer and Communications Security10.1145/3658644.3690366(3943-3957)Online publication date: 2-Dec-2024
  • (2024)Wapplique: Testing WebAssembly Runtime via Execution Context-Aware Bytecode MutationProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3650212.3680340(1035-1047)Online publication date: 11-Sep-2024
  • (2024)Java JIT Testing with Template ExtractionProceedings of the ACM on Software Engineering10.1145/36437771:FSE(1129-1151)Online publication date: 12-Jul-2024
  • (2024)SoK: Prudent Evaluation Practices for Fuzzing2024 IEEE Symposium on Security and Privacy (SP)10.1109/SP54263.2024.00137(1974-1993)Online publication date: 19-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)Enhancing Coverage-Guided Fuzzing via Phantom ProgramProceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering10.1145/3611643.3616294(1037-1049)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

Media

Figures

Other

Tables

Share

Share

Share this Publication link

Share on social media