Send hybrid msg3 without a repair delay, so the packets cached behind it do not reach the responder before it completes

handshake_manager_hybrid.go

@@ -342,7 +342,12 @@ func (hm *HandshakeManager) sendHybridMsg3(c *hybridConfirm) {
 		return
 	}
 	hm.messageMetrics.Tx(header.Handshake, hybridSubtype, int64(len(pkts)+len(later)))
-	if err := hm.sendFragmented(pkts, later, c.send); err != nil {
+	// No repair delay: the packets cached during the handshake go out right
+	// behind msg3, and the responder drops whatever arrives before msg3
+	// completes. With the repair trailing, losing either data fragment would
+	// cost them. msg3 is four packets, too short for the tail drop the delay
+	// guards against.
+	if err := hm.sendFragmentedAfter(pkts, later, c.send, 0); err != nil {
 		c.hostinfo.logger(hm.l).Debug("Failed to send handshake message", "error", err)
 	}
 }

handshake_manager_pq.go

@@ -434,6 +434,11 @@ func (hm *HandshakeManager) continuePQ(via ViaSender, hh *HandshakeHostInfo, h *
 // repair delay. It returns the first error from the immediate sends; errors from
 // delayed sends are only logged.
 func (hm *HandshakeManager) sendFragmented(now, later [][]byte, send func([]byte) error) error {
+	return hm.sendFragmentedAfter(now, later, send, hm.pqConfig().repairDelay)
+}
+
+// sendFragmentedAfter is sendFragmented with the given repair delay.
+func (hm *HandshakeManager) sendFragmentedAfter(now, later [][]byte, send func([]byte) error, delay time.Duration) error {
 	var first error
 	for _, p := range now {
 		if err := send(p); err != nil && first == nil {
@@ -447,7 +452,6 @@ func (hm *HandshakeManager) sendFragmented(now, later [][]byte, send func([]byte
 			}
 		}
 	}
-	delay := hm.pqConfig().repairDelay
 	switch {
 	case len(later) == 0:
 	case delay <= 0: