Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
skip to main content
10.1145/3576915.3623097acmconferencesArticle/Chapter ViewAbstractPublication PagesccsConference Proceedingsconference-collections
research-article
Open access

Greybox Fuzzing of Distributed Systems

Published: 21 November 2023 Publication History

Abstract

Grey-box fuzzing is the lightweight approach of choice for finding bugs in sequential programs. It provides a balance between efficiency and effectiveness by conducting a biased random search over the domain of program inputs using a feedback function from observed test executions. For distributed system testing, however, the state-of-practice is represented today by only black-box tools that do not attempt to infer and exploit any knowledge of the system's past behaviours to guide the search for bugs.
In this work, we present MALLORY: the first framework for grey-box fuzz-testing of distributed systems. Unlike popular black-box distributed system fuzzers, such as JEPSEN, that search for bugs by randomly injecting network partitions and node faults or by following human-defined schedules, MALLORY is adaptive. It exercises a novel metric to learn how to maximize the number of observed system behaviors by choosing different sequences of faults, thus increasing the likelihood of finding new bugs. Our approach relies on timeline-driven testing. MALLORY dynamically constructs Lamport timelines of the system behaviour and further abstracts these timelines into happens-before summaries, which serve as a feedback function guiding the fuzz campaign. Subsequently, MALLORY reactively learns a policy using Q-learning, enabling it to introduce faults guided by its real-time observation of the summaries.
We have evaluated MALLORY on a diverse set of widely-used industrial distributed systems. Compared to the start-of-the-art black-box fuzzer JEPSEN, MALLORY explores 54.27% more distinct states within 24 hours while achieving a speed-up of 2.24X. At the same time, MALLORY finds bugs 1.87X faster, thereby finding more bugs within the given time budget. MALLORY discovered 22 zero-day bugs (of which 18 were confirmed by developers), including 10 new vulnerabilities, in rigorously tested distributed systems such as Braft, Dqlite and Redis. 6 new CVEs have been assigned.

References

[1]
2023. Namazu. https://github.com/osrg/namazu Accessed on 10 April 2023.
[2]
Peter Alvaro and Severine Tymon. 2018. Abstracting the geniuses away from failure testing. Communication ACM, Vol. 61, 1 (2018), 54--61. https://doi.org/10.1145/3152483
[3]
Cornelius Aschermann, Sergej Schumilo, Ali Abbasi, and Thorsten Holz. 2020. IJON: Exploring Deep State Spaces via Fuzzing. In IEEE Symposium on Security and Privacy.
[4]
Jinsheng Ba, Marcel Böhme, Zahra Mirzamomen, and Abhik Roychoudhury. 2022. Stateful Greybox Fuzzing. In Proceedings of the 31st USENIX Security Symposium. USENIX Association, 3255--3272. https://www.usenix.org/conference/usenixsecurity22/presentation/ba
[5]
Shehar Bano, Alberto Sonnino, Andrey Chursin, Dmitri Perelman, Zekun Li, Avery Ching, and Dahlia Malkhi. 2021. Twins: BFT Systems Made Robust. In Proceedings of the 2021 Conference on Principles of Distributed Systems (LIPIcs, Vol. 217). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 7:1--7:29. https://doi.org/10.4230/LIPIcs.OPODIS.2021.7
[6]
Nathalie Bertrand, Vincent Gramoli, Igor Konnov, Marijana Lazic, Pierre Tholoniat, and Josef Widder. 2022. Holistic Verification of Blockchain Consensus. In Proceedings of the 36th International Symposium on Distributed Computing (LIPIcs, Vol. 246). Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 10:1-10:24. https://doi.org/10.4230/LIPIcs.DISC.2022.10
[7]
Ivan Beschastnikh, Perry Liu, Albert Xing, Patty Wang, Yuriy Brun, and Michael D. Ernst. 2020. Visualizing Distributed System Executions. ACM Transactions on Software Engineering and Methodology, Vol. 29, 2 (2020), 9:1--9:38. https://doi.org/10.1145/3375633
[8]
Marcel Böhme, Cristian Cadar, and Abhik Roychoudhury. 2021. Fuzzing: Challenges and Reflections. IEEE Software, Vol. 38, 3 (2021), 79--86. https://doi.org/10.1109/MS.2020.3016773
[9]
Marcel Böhme, Van-Thuan Pham, and Abhik Roychoudhury. 2016. Coverage-based Greybox Fuzzing as Markov Chain. In Proceedings of the 23rd ACM Conference on Computer and Communications Security, Edgar R. Weippl, Stefan Katzenbeisser, Christopher Kruegel, Andrew C. Myers, and Shai Halevi (Eds.). ACM, 1032--1043. https://doi.org/10.1145/2976749.2978428
[10]
Hongxu Chen, Shengjian Guo, Yinxing Xue, Yulei Sui, Cen Zhang, Yuekang Li, Haijun Wang, and Yang Liu. 2020. MUZZ: Thread-aware Grey-box Fuzzing for Effective Bug Hunting in Multithreaded Programs. In Proceedings of the 29th USENIX Security Symposium. USENIX Association, 2325--2342. https://www.usenix.org/conference/usenixsecurity20/presentation/chen-hongxu
[11]
Pantazis Deligiannis et al. 2016. Uncovering Bugs in Distributed Storage Systems during Testing (Not in Production!). In Proceedings of the 14th Usenix Conference on File and Storage Technologies. USENIX Association, 249--262. https://www.usenix.org/conference/fast16/technical-sessions/presentation/deligiannis
[12]
Ankush Desai, Amar Phanishayee, Shaz Qadeer, and Sanjit A. Seshia. 2018. Compositional programming and testing of dynamic distributed systems. Proceedings of the ACM on Programming Languages, Vol. 2, OOPSLA (2018), 159:1--159:30. https://doi.org/10.1145/3276529
[13]
Cezara Dragoi, Constantin Enea, Burcu Kulahcioglu Ozkan, Rupak Majumdar, and Filip Niksic. 2020. Testing consensus implementations using communication closure. Proceedings of ACM on Programming Languages, Vol. 4, OOPSLA (2020), 210:1--210:29. https://doi.org/10.1145/3428278
[14]
Rafael Dutra, Rahul Gopinath, and Andreas Zeller. 2021. FormatFuzzer: Effective Fuzzing of Binary File Formats. CoRR, Vol. abs/2109.11277 (2021). [arXiv]2109.11277 https://arxiv.org/abs/2109.11277
[15]
Pedro Fonseca, Kaiyuan Zhang, Xi Wang, and Arvind Krishnamurthy. 2017. An Empirical Study on the Correctness of Formally Verified Distributed Systems. In Proceedings of the 12th European Conference on Computer Systems. ACM, 328--343. https://doi.org/10.1145/3064176.3064183
[16]
Chris Hawblitzel, Jon Howell, Manos Kapritsos, Jacob R. Lorch, Bryan Parno, Michael L. Roberts, Srinath T. V. Setty, and Brian Zill. 2015. IronFleet: proving practical distributed systems correct. In Proceedings of the 25th ACM Symposium on Operating Systems Principles. ACM, 1--17. https://doi.org/10.1145/2815400.2815428
[17]
Maurice Herlihy and Jeannette M. Wing. 1990. Linearizability: A Correctness Condition for Concurrent Objects. ACM Transactions on Programming Languages and Systems, Vol. 12, 3 (1990), 463--492. https://doi.org/10.1145/78969.78972
[18]
Johansen Hu. 2021. Membership Rollback Issue in Canonical Raft. GitHub issue available at https://github.com/canonical/raft/issues/250.
[19]
Ranjit Jhala and Rupak Majumdar. 2009. Software model checking. Comput. Surveys, Vol. 41, 4 (2009), 21:1--21:54. https://doi.org/10.1145/1592434.1592438
[20]
Charles Edwin Killian, James W. Anderson, Ryan Braud, Ranjit Jhala, and Amin Vahdat. 2007. Mace: language support for building distributed systems. In Proceedings of the 2007 ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM, 179--188. https://doi.org/10.1145/1250734.1250755
[21]
Kyle Kingsbury. 2021. Elle: Finding Isolation Violations in Real-World Databases. In Proceedings of the 40th ACM Symposium on Principles of Distributed Computing. ACM, 7. https://doi.org/10.1145/3465084.3467483
[22]
Kyle Kingsbury. 2023. Jepsen. https://jepsen.io/ Accessed on 10 April 2023.
[23]
Leslie Lamport. 1978. Time, Clocks, and the Ordering of Events in a Distributed System. Communication ACM, Vol. 21, 7 (1978), 558--565. https://doi.org/10.1145/359545.359563
[24]
Leslie Lamport and Stephan Merz. 1994. Specifying and Verifying Fault-Tolerant Systems. In Proceedings of the 3rd International Symposium on Formal Techniques in Real-Time and Fault-Tolerant Systems (LNCS, Vol. 863). Springer, 41--76. https://doi.org/10.1007/3-540-58468-4_159
[25]
Leslie Lamport, Robert E. Shostak, and Marshall C. Pease. 1982. The Byzantine Generals Problem. ACM Trans. Program. Lang. Syst., Vol. 4, 3 (1982), 382--401. https://doi.org/10.1145/357172.357176
[26]
Tanakorn Leesatapornwongsa, Mingzhe Hao, Pallavi Joshi, Jeffrey F. Lukman, and Haryadi S. Gunawi. 2014. SAMC: Semantic-Aware Model Checking for Fast Discovery of Deep Bugs in Cloud Systems. In Proceedings of the 11th USENIX Symposium on Operating Systems Design and Implementation, Jason Flinn and Hank Levy (Eds.). USENIX Association, 399--414. https://www.usenix.org/conference/osdi14/technical-sessions/presentation/leesatapornwongsa
[27]
Jeffrey F. Lukman et al. 2019. FlyMC: Highly Scalable Testing of Complex Interleavings in Distributed Systems. In Proceedings of the 14th European Conference on Computer Systems. ACM, 20:1--20:16. https://doi.org/10.1145/3302424.3303986
[28]
Rupak Majumdar and Filip Niksic. 2018. Why is Random Testing Effective for Partition Tolerance Bugs? Proc. ACM Program. Lang., Vol. 2, Proceedings of the 45th ACM SIGPLAN Symposium on Principles of Programming Languages, Article 46 (2018), 24 pages. https://doi.org/10.1145/3158134
[29]
Valentin J. M. Manè s, Soomin Kim, and Sang Kil Cha. 2020. Ankou: guiding grey-box fuzzing towards combinatorial difference. In Proceedings of the 42nd International Conference on Software Engineering. ACM, 1024--1036. https://doi.org/10.1145/3377811.3380421
[30]
Friedemann Mattern. 1989. Virtual Time and Global States of Distributed Systems. In Proc. Workshop on Parallel and Distributed Algorithms. 215--226.
[31]
Ruijie Meng, Zhen Dong, Jialin Li, Ivan Beschastnikh, and Abhik Roychoudhury. 2022. Linear-time Temporal Logic guided Greybox Fuzzing. In Proceedings of the 44th International Conference on Software Engineering. ACM, 1343--1355. https://doi.org/10.1145/3510003.3510082
[32]
Roberto Natella. 2022. StateAFL: Greybox Fuzzing for Stateful Network Servers. Empirical Software Engineering, Vol. 27, 191 (2022). https://doi.org/10.1007/s10664-022-10233-3
[33]
Diego Ongaro and John K. Ousterhout. 2014. In Search of an Understandable Consensus Algorithm. In Proceedings of the 2014 USENIX Annual Technical Conference. USENIX Association, 305--319. https://www.usenix.org/conference/atc14/technical-sessions/presentation/ongaro
[34]
Burcu Kulahcioglu Ozkan, Rupak Majumdar, Filip Niksic, Mitra Tabaei Befrouei, and Georg Weissenbacher. 2018. Randomized testing of distributed systems with probabilistic guarantees. Proceedings of ACM on Programming Languages, Vol. 2, OOPSLA (2018), 160:1--160:28. https://doi.org/10.1145/3276530
[35]
Burcu Kulahcioglu Ozkan, Rupak Majumdar, and Simin Oraee. 2019. Trace aware random testing for distributed systems. Proc. ACM Program. Lang., Vol. 3, OOPSLA (2019), 180:1--180:29. https://doi.org/10.1145/3360606
[36]
Oded Padon, Kenneth L. McMillan, Aurojit Panda, Mooly Sagiv, and Sharon Shoham. 2016. Ivy: safety verification by interactive generalization. In Proceedings of the 37th annual ACM SIGPLAN conference on Programming Language Design and Implementation. ACM, 614--630. https://doi.org/10.1145/2908080.2908118
[37]
Van-Thuan Pham, Marcel Böhme, and Abhik Roychoudhury. 2020. AFLNet: a greybox fuzzer for network protocols. In ICST. 460--465. https://doi.org/10.1109/ICST46399.2020.00062
[38]
Sanjay Rawat, Vivek Jain, Ashish Kumar, Lucian Cojocar, Cristiano Giuffrida, and Herbert Bos. 2017. VUzzer: Application-aware Evolutionary Fuzzing. In Proceedings of the 24th Network and Distributed System Security Symposium. The Internet Society. https://www.ndss-symposium.org/ndss2017/ndss-2017-programme/vuzzer-application-aware-evolutionary-fuzzing/
[39]
Ilya Sergey, James R. Wilcox, and Zachary Tatlock. 2018. Programming and proving with distributed protocols. Proc. ACM Program. Lang., Vol. 2, POPL (2018), 28:1--28:30. https://doi.org/10.1145/3158116
[40]
Dominic Steinhö fel and Andreas Zeller. 2022. Input invariants. In ESEC/FSE. ACM, 583--594. https://doi.org/10.1145/3540250.3549139
[41]
Marcelo Taube, Giuliano Losa, Kenneth L. McMillan, Oded Padon, Mooly Sagiv, Sharon Shoham, James R. Wilcox, and Doug Woos. 2018. Modularity for decidability of deductive verification with applications to distributed systems. In Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation. ACM, 662--677. https://doi.org/10.1145/3192366.3192414
[42]
Christopher J.C.H Watkins. 1989. Learning from delayed rewards. Ph.,D. Dissertation. King's College, Cambridge United Kingdom.
[43]
Christopher J.C.H. Watkins and Peter Dayan. 1992. Q-learning. Machine learning, Vol. 8 (1992), 279--292.
[44]
Doug Woos, James R. Wilcox, Steve Anton, Zachary Tatlock, Michael D. Ernst, and Thomas E. Anderson. 2016. Planning for change in a formal verification of the Raft consensus protocol. In Proceedings of the 5th ACM SIGPLAN Conference on Certified Programs and Proofs. ACM, 154--165. https://doi.org/10.1145/2854065.2854081
[45]
Junfeng Yang, Tisheng Chen, Ming Wu, Zhilei Xu, Xuezheng Liu, Haoxiang Lin, Mao Yang, Fan Long, Lintao Zhang, and Lidong Zhou. 2009. MODIST: Transparent Model Checking of Unmodified Distributed Systems. In Proceedings of the 6th USENIX Symposium on Networked Systems Design and Implementation. USENIX Association, 213--228. http://www.usenix.org/events/nsdi09/tech/full_papers/yang/yang.pdf
[46]
Ding Yuan, Yu Luo, Xin Zhuang, Guilherme Renna Rodrigues, Xu Zhao, Yongle Zhang, Pranay Jain, and Michael Stumm. 2014. Simple Testing Can Prevent Most Critical Failures: An Analysis of Production Failures in Distributed Data-Intensive Systems. In Proceedings of the 11th USENIX Symposium on Operating Systems Design and Implementation. USENIX Association, 249--265. https://www.usenix.org/conference/osdi14/technical-sessions/presentation/yuan
[47]
Xinhao Yuan and Junfeng Yang. 2020. Effective Concurrency Testing for Distributed Systems. In Proceedings of the 25th International Conference on Architectural Support for Programming Languages and Operating Systems. ACM, 1141--1156. https://doi.org/10.1145/3373376.3378484
[48]
Michał Zalewski. 2023. american fuzzy lop (2.52b). https://lcamtuf.coredump.cx/afl/ Accessed on 10 April 2023.
[49]
Jingyu Zhou et al. 2021. FoundationDB: A Distributed Unbundled Transactional Key Value Store. In Proceedings of the 2021 ACM SIGMOD/PODS International Conference on Management of Data. ACM, 2653--2666. https://doi.org/10.1145/3448016.3457559

Cited By

View all
  • (2025)Unveiling the microservices testing methods, challenges, solutions, and solutions gaps: A systematic mapping studyJournal of Systems and Software10.1016/j.jss.2024.112232220(112232)Online publication date: Feb-2025
  • (2024)MONARCHProceedings of the 2024 USENIX Conference on Usenix Annual Technical Conference10.5555/3691992.3692025(529-543)Online publication date: 10-Jul-2024
  • (2024)A Survey of Protocol FuzzingACM Computing Surveys10.1145/369678857:2(1-36)Online publication date: 10-Oct-2024
  • Show More Cited By

Recommendations

Comments

Information & Contributors

Information

Published In

cover image ACM Conferences
CCS '23: Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security
November 2023
3722 pages
ISBN:9798400700507
DOI:10.1145/3576915
This work is licensed under a Creative Commons Attribution International 4.0 License.

Sponsors

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 21 November 2023

Check for updates

Author Tags

  1. distributed systems
  2. greybox fuzzing
  3. reactive system testing

Qualifiers

  • Research-article

Funding Sources

Conference

CCS '23
Sponsor:

Acceptance Rates

Overall Acceptance Rate 1,261 of 6,999 submissions, 18%

Upcoming Conference

CCS '25

Contributors

Other Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

  • Downloads (Last 12 months)1,179
  • Downloads (Last 6 weeks)88
Reflects downloads up to 25 Jan 2025

Other Metrics

Citations

Cited By

View all
  • (2025)Unveiling the microservices testing methods, challenges, solutions, and solutions gaps: A systematic mapping studyJournal of Systems and Software10.1016/j.jss.2024.112232220(112232)Online publication date: Feb-2025
  • (2024)MONARCHProceedings of the 2024 USENIX Conference on Usenix Annual Technical Conference10.5555/3691992.3692025(529-543)Online publication date: 10-Jul-2024
  • (2024)A Survey of Protocol FuzzingACM Computing Surveys10.1145/369678857:2(1-36)Online publication date: 10-Oct-2024
  • (2024)Reward Augmentation in Reinforcement Learning for Testing Distributed SystemsProceedings of the ACM on Programming Languages10.1145/36897798:OOPSLA2(1928-1954)Online publication date: 8-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)An Empirical Study on Kubernetes Operator BugsProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis10.1145/3650212.3680396(1746-1758)Online publication date: 11-Sep-2024
  • (2024)Multi-Dimensional and Message-Guided Fuzzing for Robotic Programs in Robot Operating SystemProceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 210.1145/3620665.3640425(763-778)Online publication date: 27-Apr-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)JFuzzer: Detecting Optimization Errors in JavaScript Just-In-Time Compilers2024 IEEE 24th International Conference on Software Quality, Reliability, and Security Companion (QRS-C)10.1109/QRS-C63300.2024.00054(373-382)Online publication date: 1-Jul-2024

View Options

View options

PDF

View or Download as a PDF file.

PDF

eReader

View online with eReader.

eReader

Login options

Figures

Tables

Media

Share

Share

Share this Publication link

Share on social media