Bug 1158011 (QUIC)

QUIC (Quick UDP Internet Connections) support

NEW
Unassigned

Status

()

enhancement
P3
normal
4 years ago
a month ago

People

(Reporter: mt, Unassigned)

Tracking

({feature, parity-chrome})

Trunk
Points:
---

Firefox Tracking Flags

(Not tracked)

Details

(Whiteboard: [necko-backlog], URL)

(Reporter)

Description

4 years ago
User Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.10; rv:37.0) Gecko/20100101 Firefox/37.0
Build ID: 20150415140819

Steps to reproduce:

The official website of QUIC: https://www.chromium.org/quic
The source code of QUIC: https://chromium.googlesource.com/chromium/src/net/+/master/quic/

Updated

4 years ago
Severity: normal → enhancement
OS: Unspecified → All
Hardware: Unspecified → All
Summary: QUIC(Quick UDP Internet Connections) supporting → QUIC (Quick UDP Internet Connections) supporting
Version: unspecified → 37 Branch

Updated

4 years ago
Component: Networking: HTTP → Networking
Summary: QUIC (Quick UDP Internet Connections) supporting → QUIC (Quick UDP Internet Connections) support
Version: 37 Branch → 1.0 Branch

Comment 1

4 years ago
Informational RFC Draft:
https://tools.ietf.org/html/draft-tsvwg-quic-protocol
Status: UNCONFIRMED → NEW
Ever confirmed: true
Whiteboard: [parity-Chrome]
Version: 1.0 Branch → Trunk

Updated

4 years ago
Alias: QUIC
Patrick, what's the opinion of the networking team on that?
Flags: needinfo?(mcmanus)

Comment 3

4 years ago
To anyone that read any QUIC docs a long while ago: they've made drastic improvements to completeness and readability. For a long while the documentation did not look like something that was practical to try to implement from.
(In reply to [:fabrice] Fabrice Desré from comment #2)
> Patrick, what's the opinion of the networking team on that?

userspace based transport is an incredibly important area of interest. Personally, its probably my top interest right now and its strategically important for Mozilla as part of Internet evolution.

It allows us to deploy what are effectively L4 upgrades in an era when OS stack updates to TCP are becoming a an ossified bottleneck to things like transport security, effective network utilization, and fault tolerance.

quic deserves credit for pushing forward the state of the art, and has shown good results with the specific case of streaming media on a well distributed CDN. We eagerly look forward to working with goog and engaging with other interested parties to develop an open standard in this space that is suitable for a broad range of use cases and operators.

Informational drops of evolving packet formats are welcome contributions on the road to this goal, but they don't reach the bar on their own.
Flags: needinfo?(mcmanus)
(Reporter)

Comment 5

3 years ago
May the following library help?
https://github.com/devsisters/libquic
YouTube serves video to Chrome over QUIC. A contact at YouTube says, "QUIC has worked out pretty well for Chrome. Improved things across the board for Chrome and Android."
Keywords: feature
Whiteboard: [parity-Chrome] → [parity-Chrome][necko-backlog]
Comment hidden (spam)
No longer blocks: Quantum

Comment 8

2 years ago
If this is implemented, we should ensure that it's accessible to WebExtensions webRequest APIs.

https://blog.brave.com/quic-in-the-wild-for-google-ad-advantage/

"AdBlock Plus, uBlock Origin, and other extensions cannot block QUIC requests. Recommended best practice is to disable QUIC from the chrome://flags/ URL."
re comment 8 - the protocol should not be a problem for any sensible content API. Just make sure they are defined in terms of content and scheme and not protocol. There is nothing about quic that would make it harder to implement for than than say http/2 (which also does not have its own scheme - they both use https://). If the webextension gets defined in terms of TCP or something then that would be a problem - but I cannot see a reason to do that.
Regarding that specific blog post in comment 8, there was a huge twitter thread about it:

https://twitter.com/bcrypt/status/856886044066590721

It seems maybe the confusion is due to QUIC pre-connects being allowed even if the actual requests are blocked by webRequest:

https://bugs.chromium.org/p/chromium/issues/detail?id=715140#c11

Also, chrome has some special whitelisting of google domains that bypass webRequest that muddies the waters:

https://bugs.chromium.org/p/chromium/issues/detail?id=715184
specifically protocol-independent pre-connects are not impacted by webRequest (which seems right to me fwiw). Its not a QUIC issue - same would apply to other transports.

And the whitelist thing certainly sounds undesirable, but again that's a chrome implementation issue independent of transport (i.e. turning off quic doesn't make the whitelisted requests visible to the ad blockets.)

it seems possible that the nascent state of quic tooling made it harder for the bloggers to correctly diagnose the bytes they were seeing. Time and standards will fix that problem.
Bulk change to priority: https://bugzilla.mozilla.org/show_bug.cgi?id=1399258
Priority: -- → P1
Bulk change to priority: https://bugzilla.mozilla.org/show_bug.cgi?id=1399258
Priority: P1 → P3
Mass bug change to replace various 'parity' whiteboard flags with the new canonical keywords. (See bug 1443764 comment 13.)
Keywords: parity-chrome
Whiteboard: [parity-Chrome][necko-backlog] → [necko-backlog]
Dirkjan Ochtman (already CCed on this bug) mentioned on Twitter today that he published the first version of his Rust crate (quinn) that implements QUIC: https://crates.io/crates/quinn

We probably couldn't ship it as-is because it uses ring / rustls, but it's possible it could be modified to swap those implementations to use NSS by way of wrapper crates in Firefox.
I actually emailed Dragana (the current Networking module owner) about this recently, it appears she would prefer to stick to the mozquic implementation that Patrick and she have been working on, on the premise that it will be hard to integrate the Rust code into the Gecko environment (she mentioned NSPR).

We'd be happy to bring up some traits to abstract over TLS implementations -- although in the end, I think that Gecko adopting rustls would be a much more interesting long-term strategy than doing NSS bindings. Isn't this exactly the kind of thing Rust is better at?
> I think that Gecko adopting rustls would be a much more interesting long-term strategy than doing NSS bindings

Changing TLS provider from NSS to something else is a much bigger question than "just" quic (and I wouldn't be surprised if there's already a bug filed about that with a very long comment section), but it also seems totally unlikely (and wrong) that a quic implementation for Firefox would use a different TLS 1.3 provider than the rest of necko/gecko.
Daniel: I agree that these are largely orthogonal issues, which is why I mentioned that we'd be happy to abstract over TLS implementations in our QUIC implementation if that will help unblock this strategy.

(BTW, searching Bugzilla for rustls results in Zarro Boogs for now.)
Regardless of where we start for QUIC support, our basic policy here is that Firefox should use a consistent TLS 1.3 implementation, which, at least for now, means NSS.
You need to log in before you can comment on or make changes to this bug.