Pith. sign in

REVIEW 2 major objections 6 minor 1 cited by

An Automated Blackbox Noncompliance Checker for QUIC Server Implementations

T0 review · 2 major / 6 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read By learning each QUIC server as a state machine, a black-box checker found 55 faults, 5 CVEs, and a DoS flaw across 19 implementations—with no formal model.

desk verdict Real findings and a genuinely new timing-aware learning idea, but the 'fully automated' differential analysis is weaker than claimed because outputs are pruned before comparison - worth a revision, not a rejection. read the letter →

arxiv 2505.12690 v1 pith:SA7JB7FN submitted 2025-05-19 cs.CR cs.NIcs.SE

Kian Kai Ang , Guy Farrelly , Cheryl Pope , Damith C. Ranasinghe This is my paper · ORCID
classification cs.CRcs.NIcs.SE
keywords QUICprotocolnoncomplianceactiveautomatalearningdifferentialanalysisstatemachineinferencedenial-of-serviceRFC9000black-boxtesting
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper claims that QUICtester, an open-source black-box testing tool, can automatically surface non-compliant and vulnerable behaviors in QUIC server implementations without a formal reference model to check against. The tool learns each server's behavior as a finite state machine by actively probing it with valid and invalid QUIC messages at different timing intervals, then compares the learned machines across many implementations so that deviations stand out. Tested on 19 open-source QUIC servers across all five handshake security configurations, it reports 55 confirmed implementation faults: 44 specification violations, eight memory-corruption bugs, and three logical flaws, many of which enable denial-of-service attacks. If correct, this reduces protocol noncompliance checking for QUIC to an automated pipeline, and the paper's curated set of conforming reference models lets developers check new implementations against a known-good behavior baseline.

What carries the argument

The working core is active automata learning paired with differential comparison of the learned state machines. A Learner implementing the TTT algorithm with Wp-method conformance testing generates input sequences from a manually curated dictionary of 30 symbols, which encode QUIC packet types, frames, cipher suites, configuration toggles, and two timing intervals; a Test Harness translates each symbol into real QUIC packets and back, maintaining encryption keys across all five handshake configurations. Each server's observable behavior is thereby abstracted into a finite state machine whose transitions are labeled by input and output symbols. An Optimizer drops self-loops and merges timing variants that lead to the same next state, removing up to 90 percent of edges in the best case, and then a Differential Analyzer using the LTS_Diff algorithm compares models pair by pair: the same server under short versus long timing, and every model against every other implementation's models, yielding the deviating input sequences for manual confirmation. A Crash Logger watches the server's process after each learning step so that crashes triggered by specific inputs are recorded even when hidden from the learned model.

What would settle it

Plant a deliberately non-conforming behavior in a QUIC server that triggers only on a message type or parameter combination outside the 30-symbol dictionary (for example, an exotic transport parameter value), run the full learning and pairwise differential pipeline with that server added to the original 19, and check whether the planted deviation produces any flagged edge; if it does not, the dictionary is shown to be the coverage ceiling. A complementary check: introduce the same bug into all 19 implementations and observe that the differential analyzer reports nothing, because its oracle is purely comparative.

Watch

Extended reading notes

Core claim

The paper's central claim is that noncompliance in QUIC implementations can be detected without a formal reference model, by treating the ecosystem of many independent implementations as the oracle. QUICtester learns a finite state machine for each server through active automata learning, then runs pairwise differential analysis on the learned models: any state or transition present in one model but absent in another is flagged as a deviation, and each deviation is then validated by hand to confirm it is a genuine fault. The method's distinctive addition is time-parameterized learning: inputs carry a short or long wait interval, chosen automatically per implementation before learning, so timing-dependent behavior such as retransmission handling and key discard appears as distinct states. Applied to 19 open-source QUIC servers under all five security configurations, the pipeline produced 186 learned models and 55 confirmed faults: 44 specification violations, eight memory-corruption bugs, and three logical flaws, including a client-authentication bypass in Quiche, a crash in Picoquic reachable only through short-timing inputs, and a specification ambiguity over connectionless first packets that lets servers be forced into creating connection contexts. The findings led to five CVE assignments and two bug bounties, and the authors curate 11 conforming reference models so that future targets can be checked against a known-good baseline.

Load-bearing premise

The tool's reach is capped by its hand-built dictionary of 30 message symbols and by the bet that among the 19 tested servers, at least one behaves per the specification for every behavior that matters; a deviation that no symbolized message can reach, or one shared by every implementation, would go undetected.

Editorial extensions

If this is right

  • Developers can run QUICtester against a new target using the 11 curated reference FSMs, and the Differential Analyzer will extract non-conforming transitions automatically, without repeating the full 19-server differential campaign.
  • Timing-varied learning is necessary for completeness: the Picoquic crash is present in the short-timeout learned model and absent from the long-timeout model, so a checker that ignores event timing would miss it.
  • The RFC 9000 ambiguity over first packets without a CRYPTO frame is exploitable in practice: 10 of the 19 servers create a connection context for a bare initial PING, memory use grows from roughly 500 MB to 3 GB under 50,000 such clients, and the Kwik server crashes; the proposed amendment requires a CRYPTO frame in the first packet.
  • Vendor responses corroborate the findings: five CVEs were assigned (Kwik, LSQUIC, PQUIC, and Quinn), two bug bounties were paid, and the reported faults were fixed or acknowledged by the respective maintainers.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The dictionary sets the discovery ceiling, which makes the completeness claim testable: re-run learning with the symbol set augmented by fuzz-discovered or newly observed message variants; if new deviations appear, the published dictionary was incomplete, and if none do, its coverage is empirically supported.
  • The purely comparative oracle has a common-mode blind spot the authors concede: a noncompliance shared by every tested implementation is invisible, so the method's assurance is relative to the diversity of the test set rather than absolute.
  • The recipe is protocol-generic: any protocol family with several independent implementations and timing-sensitive states (idle timeouts, retransmission queues, key lifetimes) could be tested with the same two-interval learning plus pairwise differencing, once a harness and symbol dictionary are built.
  • The two-interval timing choice could itself be optimized: the runtime cost of mixed timing (76.5 hours per model on average) suggests adaptively selecting intervals that maximize new-state discovery could scale the method to larger test suites.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 6 minor

Summary. The paper presents QUICtester, a black-box framework that uses active automata learning (LearnLib TTT algorithm with Wp-method conformance testing) to infer finite state machine models of 19 QUIC server implementations under five handshake security configurations. The learning alphabet is a manual symbolization of 30 QUIC messages and parameters, parameterized by short and long timeouts, and the framework includes a custom test harness, a model optimizer, a crash logger, and a differential analyzer based on LTS_Diff. The authors report 55 confirmed faults across the implementations, including 44 specification violations, 8 memory-corruption bugs, and 3 logical flaws, with 5 CVEs and two bug bounties awarded. They also identify a QUIC specification ambiguity around initial packets without a CRYPTO frame and propose an RFC amendment.

Significance. If the claims hold, this is a significant contribution: it is the first open-source black-box noncompliance checker for the ratified QUIC protocol, and it provides concrete external validation through developer-confirmed fixes, CVE assignments, bug bounties, and reproducible PoCs. The time-parameterized learning idea is genuinely novel and is essential to finding M-4, which is a compelling case study. The curated reference models and public repository are useful assets for future testing. The paper is also unusually candid about its limitations, including the unfaithful-oracle problem and possible symbolization gaps. The main weakness is that some central claims go beyond what the automated pipeline as described can actually deliver.

major comments (2)
  1. [3.3 (C6)] The automated differential analysis cannot detect output-only noncompliance. Section 3.3 states: "We prune all the output symbols from the optimized learned models and use the Labeled Transition System Differential (LTS_Diff) algorithm." Several faults in Table 2 are output-only by nature: S-11 (PQUIC does not send HANDSHAKE_DONE after the handshake is confirmed), S-15 (Quant incorrect handling of an initialPing message), and S-6 (MsQuic does not issue its initial_source_connection_id at the correct connection state). Two models that agree on all inputs and state transitions but differ only in emitted symbols are indistinguishable after output pruning, so these faults cannot be flagged by the automated analyzer. The paper needs to state, per fault or per category, which findings were produced by the differential analyzer, which by the crash logger, and which by manual model or source inspection, and either extend the comparison to output symbols or revise the abstract and contribution claims from "automated noncompliance checking" to "automated deviation discovery followed by manual confirmation."
  2. [4 and 7] The "no false positives" claim conflates automated deviation detection with manual validation. Section 4 says deviating behaviors were validated manually and that crashes, trace data, and crashing seeds were examined as a separate source; Section 7 adds that all 186 models were manually validated. Therefore the zero-false-positive statement is a property of the combined human-in-the-loop pipeline, not of the Differential Analyzer alone. Please report the raw number of candidate deviations produced by LTS_Diff and how many were discarded as benign implementation variation, such as the differing initialPing behaviors in Section 5.4. This would let the reader assess how much of the 55-fault result is automated and how much is due to the authors' subsequent manual analysis.
minor comments (6)
  1. [Abstract] The abstract contains a duplicated word: "analyze analyze 186 learned models."
  2. [Section 2] The first paragraph of Section 2 contains the typo "addbefore" in "active automata learning addbefore delving."
  3. [Section 5.1] The heading "S-18 Client Authentication Bypass in Quiche" uses S-18, but Table 2 lists the Quiche client-authentication bypass as S-12; renumber or cross-reference consistently.
  4. [Section 5.2] In the M-4 case study, the text refers to "Figure 8 in the Appendix," but Figure 8 appears in the main body; the cross-reference should be updated.
  5. [Appendix A.1] The text refers to "M-18" in connection with QUT status detection, but Table 2 has M-8 as the Quinn panic; the numbering is inconsistent.
  6. [Appendix Table 8] The output-symbol descriptions for <ConnectionActive> and <ConnectionClosed> appear swapped relative to the prose in Section A.1: the table says <ConnectionActive> indicates the QUT has closed the connection while <ConnectionClosed> indicates the connection is still active, which is the reverse of the surrounding text.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: QUICtester's differential findings are externally anchored to RFC text, developer patches, CVEs, and bug bounties.

full rationale

QUICtester's central claim is that active automata learning plus pairwise differential analysis of learned FSMs can surface non-compliant QUIC behaviors without a formal reference model. Nothing in the paper's derivation reduces this claim to its own inputs by construction. The learned models are inferred from black-box observations via LearnLib's TTT algorithm; the Differential Analyzer compares optimized models and extracts deviating input sequences; the 55 reported faults were then manually validated against RFC 9000/9001 text and confirmed by external parties through 5 CVEs, developer patches, and bug bounties. The short/long timing parameters are calibrated to avoid nondeterminism, not fitted to predict faults; time-differential testing exposed M-4, but that finding was validated through crash logs and root-cause debugging. The curated reference models are presented as manually validated artifacts for future use, not as a self-justifying oracle. The only overlapping-author citation (QUIC-Fuzz, [8]) appears in a comparison table and is not load-bearing. Acknowledged limitations, including the possibility that all implementations share a logical vulnerability and the pruning of output symbols before LTS_Diff, are scope and internal-consistency concerns rather than circular reductions: no equation or fitted parameter is re-identified as a prediction. The paper is self-contained against external benchmarks, so the appropriate circularity score is 0.

Assumptions & free parameters 2 free parameters · 7 assumptions · 0 invented entities

The central claim rests on four load-bearing premises: (1) the RFC is the correctness criterion; (2) servers are deterministic regular systems; (3) the 30-symbol dictionary is complete enough; (4) the differential oracle set is informative. The paper discloses (3) and (4) as threats to validity. The manual validation step is an engineering assumption, not a formal guarantee.

free parameters (2)
  • short timeout (per implementation) = not reported; defined as longest measured response capture time
    Section 3.1 C2/C3: the harness measures the longest time to capture expected packets before learning and uses this as the short wait; long is 10x short. These values affect which timed-out states are learned and were chosen to avoid nondeterminism, not fitted to predict a specific bug.
  • symbol dictionary size = 30 symbols
    Section 3.1 C1 and Appendix A.1: manually curated from RFC 9000/9001 after 30-40 hours of reading per author; includes 12 invalid messages. The completeness of this alphabet is load-bearing for coverage and is acknowledged as a possible source of missed states.
assumptions (7)
  • domain assumption The QUIC RFC 9000/9001 text is the authoritative correctness criterion for implementations.
    All noncompliance judgments are made relative to the specification, including the proposed amendment in Section 5.4.
  • domain assumption Each QUIC server under test behaves as a deterministic finite state machine with a regular language.
    Active automata learning with TTT and Wp-method assumes determinism and regular behavior; the harness is designed to enforce determinism by handling timing, initialization, and crashes (Section 3.1 C3).
  • ad hoc to paper The manually curated symbol dictionary covers all behaviors relevant to the handshake.
    Section 3.1 C1 and Appendix A.1; the paper acknowledges a nonzero probability of missing a symbolization, which would cause missed noncompliance.
  • ad hoc to paper At least one implementation in the pairwise comparison is conformant, or the deviation is identifiable as noncompliance by manual inspection.
    Differential analysis has no ground-truth oracle; Section 7 Threats to validity notes all oracles could share the same vulnerability. The authors compensate by manual validation.
  • standard math The LTS_Diff algorithm correctly computes language differences between learned FSMs.
    Used in Section 3.3 C6, based on Walkinshaw and Bogdanov's algorithm.
  • domain assumption Server-side focus is sufficient to evaluate handshake security; client and server share the same bug surface.
    Scope section; they note the same protocol library is used by clients and servers.
  • ad hoc to paper The interpretation that creating a connection context for a CRYPTO-free initialPing is a flaw requiring an RFC amendment.
    Section 5.4: the RFC does not explicitly state how a server should handle a first packet without a CRYPTO frame. The judgment that this is a flaw is the authors' normative proposal, not established by the current spec.

how reviews work

0 comments
Cite this review

Pith. "Pith review of An Automated Blackbox Noncompliance Checker for QUIC Server Implementations." pith.science (2026). https://pith.science/paper/SA7JB7FN

@misc{pith2026250512690,
  author       = {Pith},
  title        = {Pith review of: An Automated Blackbox Noncompliance Checker for QUIC Server Implementations},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/SA7JB7FN}},
  note         = {Machine review of arXiv:2505.12690}
}
read the original abstract

We develop QUICtester, an automated approach for uncovering non-compliant behaviors in the ratified QUIC protocol implementations (RFC 9000/9001). QUICtester leverages active automata learning to abstract the behavior of a QUIC implementation into a finite state machine (FSM) representation. Unlike prior noncompliance checking methods, to help uncover state dependencies on event timing, QUICtester introduces the idea of state learning with event timing variations, adopting both valid and invalid input configurations, and combinations of security and transport layer parameters during learning. We use pairwise differential analysis of learned behaviour models of tested QUIC implementations to identify non-compliance instances as behaviour deviations in a property-agnostic way. This exploits the existence of the many different QUIC implementations, removing the need for validated, formal models. The diverse implementations act as cross-checking test oracles to discover non-compliance. We used QUICtester to analyze analyze 186 learned models from 19 QUIC implementations under the five security settings and discovered 55 implementation errors. Significantly, the tool uncovered a QUIC specification ambiguity resulting in an easily exploitable DoS vulnerability, led to 5 CVE assignments from developers, and two bug bounties thus far.

Figures

Figures reproduced from arXiv: 2505.12690 by the authors.

Figure 1
Figure 1. A simplified overview of handshake security con￾figurations consisting of Initial packets , 0-RTT packets , Retry packets , Handshake packets and 1-RTT packets . Frames for Address validation are in blue text and for Client Authentication are red text. Messages in purple text carries the negotiated parameters to derive the pre-shared key for 0-RTT encryption in a future connection. Packet space num￾bers for each pac… view at source ↗
Figure 2
Figure 2. An overview of QUICtester. FSM Inference with active learning and Automated Analysis method for identifying deviating behaviors. symbolized QUIC protocol parameters, messages and event timing definitions. The Test Harness, responsible for maintaining all pro￾tocol state with a test target, constructs the QUIC messages based on the symbolic instruction sequence for transmission through a UDP connection to the QUIC im… view at source ↗
Figure 3
Figure 3. Automated analysis using Differential Analyzer. S1 S2 S3 Model 1 Model 2 Result initConClose initConClose initPing S1 S2 S3 initConClose initPing initConClose S1 S2 S3 initConClose initPing initConClose initConClose [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (16 more)
Figure 4
Figure 4. Figure 4: Example illustrating a Differential Analyzer result. Given two optimized models as inputs (Model 1 and Model 2), unique state transitions (the green edge denotes the unique edge in Model 1 while the red edge denotes it is unique to Model 2) are identified by the algori…
Figure 5
Figure 5. Figure 5: Simplified learned model of a Quiche server with [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: Differential analyzer reveals a deviation on Pico [PITH_FULL_IMAGE:figures/full_fig_p009_6.png]
Figure 7
Figure 7. Figure 7: Consequently, only the oldest message is removed, while [PITH_FULL_IMAGE:figures/full_fig_p010_7.png]
Figure 8
Figure 8. Figure 8: A message sequence chart showing message flow [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]
Figure 9
Figure 9. Figure 9: Memory usage recorded for 19 QUIC servers tested [PITH_FULL_IMAGE:figures/full_fig_p011_9.png]
Figure 10
Figure 10. Figure 10: Practitioners can use QUICtester with our cu￾rated reference models to automate future testing of target QUIC implementations (QUT). 11 [PITH_FULL_IMAGE:figures/full_fig_p011_10.png]
Figure 11
Figure 11. Figure 11: An example prompt to automatically symbolize [PITH_FULL_IMAGE:figures/full_fig_p014_11.png]
Figure 12
Figure 12. Figure 12: Symbols in 50 answers sampled from OpenAI GPT [PITH_FULL_IMAGE:figures/full_fig_p015_12.png]
Figure 13
Figure 13. Figure 13: Optimized learned model of a Ngtcp2 server with the RetryClientAuth configuration, generated from a [PITH_FULL_IMAGE:figures/full_fig_p017_13.png]
Figure 14
Figure 14. Figure 14: Client authentication bypass in Quiche. The in [PITH_FULL_IMAGE:figures/full_fig_p017_14.png]
Figure 15
Figure 15. Figure 15: The learned model of Quinn—notably the QUIC implementation with the valid FSM—in the most simple, Basic [PITH_FULL_IMAGE:figures/full_fig_p019_15.png]
Figure 16
Figure 16. Figure 16: The learned model of Quinn Basic after employing our [PITH_FULL_IMAGE:figures/full_fig_p019_16.png]
Figure 17
Figure 17. Figure 17: Optimized learned model of a Quiche server with the ClientAuth configuration. Blue edges show a valid path to [PITH_FULL_IMAGE:figures/full_fig_p020_17.png]
Figure 18
Figure 18. Figure 18: An optimized model from Picoquic with ClientAuth configuration learned with [PITH_FULL_IMAGE:figures/full_fig_p020_18.png]
Figure 19
Figure 19. Figure 19: An optimized model from Picoquic with ClientAuth configuration learned with [PITH_FULL_IMAGE:figures/full_fig_p020_19.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Finding SSH Strict Key Exchange Violations by State Learning

    cs.CR 2025-09 conditional novelty 7.0 of 10

    Seven of ten SSH servers misimplement strict key exchange, and two violations are exploitable: pre-auth RCE in Erlang SSH and a rogue session attack in Tectia SSH.

Reference graph

Works this paper leans on

67 extracted references · 60 canonical work pages · cited by 1 Pith paper

  1. [1]

    [n. d.]. Aioquic. https://aioquic.readthedocs.io/en/latest/. Accessed: 10 October 2022

    work page 2022

  2. [2]

    [n. d.]. BoringSSL. https://boringssl.googlesource.com/boringssl/. Accessed: 7 June 2022

    work page 2022

  3. [3]

    [n. d.]. Bug Description with input sequence to reproduce the faults. https: //anonymous.4open.science/r/QUICTester-7EBC/results/README.md. Accessed: 2 August 2024

    work page 2024

  4. [4]

    [n. d.]. rr: lightweight recording & deterministic debugging. https://rr-project. org/. Accessed: 16 January 2023

    work page 2023

  5. [5]

    [n. d.]. Usage statistics of HTTP/3 for websites. https://w3techs.com/ technologies/details/ce-http3. Accessed: 7 June 2023

    work page 2023

  6. [6]

    Bernhard K Aichernig, Edi Muškardin, and Andrea Pferscher. 2021. Learning- based fuzzing of IoT message brokers. In IEEE Conference on Software Testing, Verification and Validation (ICST). 47–58

    work page 2021

  7. [7]

    Anastasios Andronidis and Cristian Cadar. 2022. SnapFuzz: high-throughput fuzzing of network applications. In ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). 340–351

    work page 2022

  8. [8]

    Ranasinghe

    Kian Kai Ang and Damith C. Ranasinghe. 2025. QUIC-Fuzz: An Effective Greybox Fuzzer For The QUIC Protocol. In European Symposium on Research in Computer Security (ESORICS)

    work page 2025

Show all 67 references
  1. [9]

    Dana Angluin. 1987. Learning regular sets from queries and counterexamples. Information and computation 75, 2 (1987), 87–106

    1987

  2. [10]

    Jinsheng Ba, Marcel Böhme, Zahra Mirzamomen, and Abhik Roychoudhury

  3. [11]

    Nils Bars, Moritz Schloegel, Nico Schiller, Lukas Bernhard, and Thorsten Holz

  4. [12]

    Benjamin Beurdouche, Karthikeyan Bhargavan, Antoine Delignat-Lavaud, Cédric Fournet, Markulf Kohlweiss, Alfredo Pironti, Pierre-Yves Strub, and Jean Karim Zinzindohoue. 2015. A Messy State of the Union: Taming the Composite State Machines of TLS. In IEEE Symposium on Security ...

    2015 doi

  5. [13]

    Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. 2020. Language models are few-shot learners. Advances in neural information processing systems 33 (2020), 1877–1901

    2020

  6. [14]

    Chad Brubaker, Suman Jana, Baishakhi Ray, Sarfraz Khurshid, and Vitaly Shmatikov. 2014. Using Frankencerts for Automated Adversarial Testing of Certificate Validation in SSL/TLS Implementations. In IEEE Symposium on Secu- rity and Privacy (S&P) . 114–129. https://doi.org/10.11...

    2014 doi

  7. [15]

    Yufan Chen, Arjun Arunasalam, and Z Berkay Celik. 2023. Can large language models provide security & privacy advice? measuring the ability of llms to refute misconceptions. In Annual Computer Security Applications Conference (ACSAC). 366–378

    2023

  8. [16]

    Tsun S. Chow. 1978. Testing software design modeled by finite-state machines. IEEE transactions on software engineering 3 (1978), 178–187

    1978

  9. [17]

    Paolo Milani Comparetti, Gilbert Wondracek, Christopher Kruegel, and Engin Kirda. 2009. Prospex: Protocol specification extraction. In IEEE Symposium on Security and Privacy (S&P) . IEEE, 110–125

    2009

  10. [18]

    Christophe Crochet, Tom Rousseaux, Maxime Piraux, Jean-François Sambon, and Axel Legay. 2021. Verifying QUIC implementations using Ivy. In Proceedings of the 2021 Workshop on Evolution, Performance and Interoperability of QUIC . 35–41

    2021

  11. [19]

    Lesly-Ann Daniel, Erik Poll, and Joeri de Ruiter. 2018. Inferring OpenVPN state machines using protocol state fuzzing. In IEEE European Symposium On Security And Privacy Workshops (EuroS&PW). 11–19

    2018

  12. [20]

    Joeri De Ruiter and Erik Poll. 2015. Protocol state fuzzing of TLS implementations. In USENIX Security Symposium (USENIX Security) . 193–206

    2015

  13. [21]

    Yinlin Deng, Chunqiu Steven Xia, Haoran Peng, Chenyuan Yang, and Lingming Zhang. 2023. Large language models are zero-shot fuzzers: Fuzzing deep-learning libraries via large language models. In ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). 423–435

    2023

  14. [23]

    Tim Dierks and Eric Rescorla. 2008. The transport layer security (TLS) protocol version 1.2. RFC 5246

    2008

  15. [24]

    Michael Eddington. [n. d.]. Peach fuzzing platform. https://gitlab.com/gitlab- org/security-products/protocol-fuzzer-ce.. Accessed: 2 August 2024

    2024

  16. [25]

    Fátima Fernández, Mihail Zverev, Pablo Garrido, José R Juárez, Josu Bilbao, and Ramón Agüero. 2020. And QUIC meets IoT: performance assessment of MQTT over QUIC. In International Conference on Wireless and Mobile Computing, Networking and Communications (WiMob)

    2020

  17. [26]

    Tiago Ferreira, Harrison Brewton, Loris D’Antoni, and Alexandra Silva. 2021. Prognosis: closed-box analysis of network protocol implementations. In Proceed- ings of the 2021 ACM SIGCOMM 2021 Conference . 762–774

    2021

  18. [27]

    Paul Fiterău-Broştean, Ramon Janssen, and Frits Vaandrager. 2016. Combin- ing model learning and model checking to analyze TCP implementations. In International Conference on Computer Aided Verification (CA V)

    2016

  19. [28]

    Paul Fiterau-Brostean, Bengt Jonsson, Robert Merget, Joeri De Ruiter, Konstanti- nos Sagonas, and Juraj Somorovsky. 2020. Analysis of DTLS implementations using protocol state fuzzing. In USENIX Security Symposium (USENIX Security) . 2523–2540

    2020

  20. [29]

    Paul Fiterau-Brostean, Bengt Jonsson, Konstantinos Sagonas, and Fredrik Tåquist

  21. [30]

    Paul Fiterău-Broştean, Toon Lenaerts, Erik Poll, Joeri de Ruiter, Frits Vaandrager, and Patrick Verleg. 2017. Model learning and model checking of SSH implemen- tations. In ACM SIGSOFT International Symposium on Model Checking of Software (SPIN). 142–151

    2017

  22. [31]

    Olga Grinchtein, Bengt Jonsson, and Martin Leucker. 2010. Learning of event- recording automata. Theoretical Computer Science 411, 47 (2010), 4029–4054

    2010

  23. [32]

    Kaiyu Hou, Sen Lin, Yan Chen, and Vinod Yegneswaran. 2022. QFaaS: accelerating and securing serverless cloud networks with QUIC. In Symposium on Cloud Computing (SoCC). 240–256

    2022

  24. [33]

    Yating Hsu, Guoqiang Shu, and David Lee. 2008. A model-based approach to se- curity flaw detection of network protocol implementations. In IEEE International Conference on Network Protocols . IEEE, 114–123

    2008

  25. [34]

    Christian Huitema, Sara Dickinson, and Allison Mankin. 2022. DNS over Dedi- cated QUIC Connections. RFC 9250. https://doi.org/10.17487/RFC9250

    2022 doi

  26. [35]

    Syed Rafiul Hussain, Imtiaz Karim, Abdullah Al Ishtiaq, Omar Chowdhury, and Elisa Bertino. 2021. Noncompliance as deviant behavior: An automated black-box noncompliance checker for 4G LTE cellular devices. In Proceedings of the 2021 ACM SIGSAC Conference on Computer and Commun...

    2021

  27. [36]

    IoT Analytics GmbH. 2023. State of IoT 2023: Number of connected IoT devices growing 16% to 16.7 billion globally. https://iot-analytics.com/number-connected- iot-devices

    2023

  28. [37]

    Malte Isberner. 2015. Foundations of active automata learning: an algorithmic perspective. (2015)

    2015

  29. [38]

    Malte Isberner, Falk Howar, and Bernhard Steffen. 2014. The TTT algorithm: a redundancy-free approach to active automata learning. In Runtime Verification: 5th International Conference, RV 2014, Toronto, ON, Canada, September 22-25, 2014. Proceedings 5. Springer, 307–322

    2014

  30. [39]

    Malte Isberner, Falk Howar, and Bernhard Steffen. 2015. The open-source learnLib: a framework for active automata learning. In Computer Aided Verification: 27th International Conference, CA V 2015, San Francisco, CA, USA, July 18-24, 2015, Proceedings, Part I 27 . Springer, 487–495

    2015

  31. [40]

    J Iyengar and M Thomson. 2021. QUIC: A UDP-Based Multiplexed and Secure Transport. RFC 9000

    2021

  32. [41]

    jtpereyda. [n. d.]. BooFuzz: Network protocol fuzzing for humans. https://github.com/jtpereyda/boofuzz

  33. [42]

    Arash Molavi Kakhki, Samuel Jero, David Choffnes, Cristina Nita-Rotaru, and Alan Mislove. 2017. Taking a long look at QUIC: an approach for rigorous evaluation of rapidly evolving transport protocols. In Proceedings of the Internet Measurement Conference. 290–303

    2017

  34. [43]

    Sungmin Kang, Juyeon Yoon, and Shin Yoo. 2023. Large language models are few- shot testers: Exploring llm-based general bug reproduction. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE) . IEEE, 2312–2323. 13 Conference’17July 2017Washington, DC, U...

    2023

  35. [44]

    Imtiaz Karim, Abdullah Al Ishtiaq, Syed Rafiul Hussain, and Elisa Bertino. 2023. BLEDiff: Scalable and Property-Agnostic Noncompliance Checking for BLE Imple- mentations. In IEEE Symposium on Security and Privacy (S&P) . IEEE, 3209–3227

    2023

  36. [45]

    Puneet Kumar and Behnam Dezfouli. 2019. Implementation and analysis of QUIC for MQTT. Computer Networks 150 (2019), 28–45

    2019

  37. [46]

    Zhengxiong Luo, Junze Yu, Feilong Zuo, Jianzhong Liu, Yu Jiang, Ting Chen, Abhik Roychoudhury, and Jiaguang Sun. 2023. Bleem: Packet sequence oriented fuzzing for protocol implementations. In USENIX Security Symposium (USENIX Security). 4481–4498

    2023

  38. [47]

    Dominik Maier, Otto Bittner, Marc Munier, and Julian Beier. 2022. FitM: Binary- Only Coverage-Guided Fuzzing for Stateful Network Protocols. In Workshop on Binary Analysis Research (BAR)

    2022

  39. [48]

    Chris McMahon Stone, Tom Chothia, and Joeri de Ruiter. 2018. Extending automated protocol state learning for the 802.11 4-way handshake. In European Symposium on Research in Computer Security (ESORICS) . 325–345

    2018

  40. [49]

    Kenneth L McMillan and Lenore D Zuck. 2019. Formal specification and testing of QUIC. In Proceedings of the ACM Special Interest Group on Data Communication. 227–240

    2019

  41. [50]

    Ruijie Meng, Martin Mirchev, Marcel Böhme, and Abhik Roychoudhury. 2024. Large language model guided protocol fuzzing. InNetwork and Distributed System Security (NDSS)

    2024

  42. [51]

    Van-Thuan Pham, Marcel Böhme, and Abhik Roychoudhury. 2020. AFLNet: a greybox fuzzer for network protocols. InIEEE International Conference on Software Testing, Validation and Verification (ICST). 460–465

    2020

  43. [52]

    Jon Postel. 1981. Transmission control protocol. RFC 793

    1981

  44. [53]

    Harald Raffelt, Maik Merten, Bernhard Steffen, and Tiziana Margaria. 2009. Dy- namic testing via automata learning. International Journal on Software Tools for Technology Transfer (STTT) 11, 4 (2009), 307–324. https://doi.org/10.1007/s10009- 009-0120-7

    2009 doi

  45. [54]

    Abdullah Rasool, Greg Alpár, and Joeri de Ruiter. 2019. State machine inference of QUIC. ArXiv (2019)

    2019

  46. [55]

    Gaganjeet Singh Reen and Christian Rossow. 2020. DPIFuzz: a differential fuzzing framework to detect DPI elusion strategies for QUIC. InAnnual Computer Security Applications Conference (ACSAC). 332–344

    2020

  47. [56]

    Eric Rescorla. 2018. The transport layer security (TLS) protocol version 1.3. RFC 8446

    2018

  48. [57]

    Eric Rescorla and Brian Korver. 2003. Guidelines for writing RFC text on security considerations. Technical Report

    2003

  49. [58]

    Sergej Schumilo, Cornelius Aschermann, Andrea Jemmett, Ali Abbasi, and Thorsten Holz. 2022. Nyx-Net: Network Fuzzing with Incremental Snapshots. In European Conference on Computer Systems (EuroSys) . https://doi.org/10.1145/ 3492321.3519591

    2022

  50. [59]

    Juraj Somorovsky. 2016. Systematic fuzzing and testing of TLS libraries. In ACM SIGSAC Conference on Computer and Communications Security (CCS) . 1492–1504

    2016

  51. [60]

    Simeng Sun, Yang Liu, Dan Iter, Chenguang Zhu, and Mohit Iyyer. 2023. How does in-context learning help prompt tuning? arXiv preprint arXiv:2302.11521 (2023)

    2023 arXiv

  52. [61]

    Martin Tappler, Bernhard K Aichernig, and Roderick Bloem. 2017. Model-based testing IoT communication via active automata learning. In IEEE International conference on software testing, verification and validation (ICST) . 276–287

    2017

  53. [62]

    Martin Thomson and Sean Turner. 2021. Using TLS to secure QUIC. RFC 9001

    2021

  54. [63]

    Frits Vaandrager. 2017. Model Learning. Commun. ACM 60, 2 (Jan 2017), 86–95. https://doi.org/10.1145/2967606

    2017 doi

  55. [64]

    Neil Walkinshaw and Kirill Bogdanov. 2013. Automated comparison of state- based software models in terms of their language and structure.ACM Transactions on Software Engineering and Methodology (TOSEM) 22, 2 (2013), 1–37

    2013

  56. [65]

    Chunqiu Steven Xia, Matteo Paltenghi, Jia Le Tian, Michael Pradel, and Ling- ming Zhang. 2024. Fuzz4all: Universal fuzzing with large language models. In IEEE/ACM International Conference on Software Engineering (ICSE) . 1–13. APPENDIX A SYMBOLIZATION WITH LLMS Recently, langu...

    2024

  57. [2022]

    In USENIX Security Symposium (USENIX Security)

    Stateful greybox fuzzing. In USENIX Security Symposium (USENIX Security) . 3255–3272

  58. [2023]

    In Network and Distributed System Security (NDSS)

    Automata-Based Automated Detection of State Machine Bugs in Protocol Implementations.. In Network and Distributed System Security (NDSS)

  59. [2024]

    No Peer, no Cry: Network Application Fuzzing via Fault Injection. (2024)

    2024

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.