6 ms·
QUIC as a solution to protocol ossification
- qalmakka 9y agoI think we definitely need more standalone libraries for both servers and clients to really see QUIC's adoption flying. Nowadays it's either a Go library some people have written or scavenging Chromium sources for libquic - which is way less than ideal.
- pacificmint 9y agoHonestly, I'd rather they keep it limited to Chrome and Google, while they iterate and develop the protocol. That way can iterate much faster and without backward compatibility concerns. In a way, that's another example of ossification, this time without middle boxes. Once the protocol has settled and development slowed down, they can then build libraries for all the other languages and servers.
- dsign 9y agoThe protocol is quite complex, unfortunately, and also in flux, which deters a lot of companies from adopting it in their supported solutions. There is also the issue of HTTP/2 ... just because the major open source servers have implementations for it, it doesn't mean that it has been assimilated to its full capabilities in hundreds of other stacks. For many organizations, it's hard to sell internally the adoption of yet another protocol in such a short timeframe.
- baby 9y agoYou're also using a protocol that changes at every version of Chrome, making you only compatible with the last version of Chrome if you're keeping up to date, or with multiple versions if you're willing to do that to your code. Chrome is also only talking QUIC to Google websites, not sure how you would go about making it work with other websites (ask the G maybe?)
- londons_explore 9y agoChrome will talk QUIC to anyone else who talks QUIC
- hawski 9y agoHow does Chrome determine that a service supports QUIC? Does QUIC use a specific port and Chrome always pings it?
- dweekly 9y agoEmit an HTTP header and Chrome will attempt a QUIC connection. Alternate-Protocol: quic:<QUIC server port> https://www.chromium.org/quic/quic-faq https://www.chromium.org/quic/quic-faq
- baby 9y agoDo you need to serve that over HTTPS? EDIT: Alright, I figured it out, this page is out of date. Google services reply with this header which works: alt-svc: hq=":443"; ma=2592000; quic=51303431; quic=51303339; quic=51303338; quic=51303337; quic=51303335,quic=":443"; ma=2592000; v="41,39,38,37,35" No idea what these quic values are :) but here it is.
- detaro 9y agoWait until the IETF-version is finished and build on that? (it's a bit confusing it is named the same, since it is not just a version of Google's)
- collinmanderson 9y agoIf nginx had QUIC support, I'd use it. I used nginx's spdy back before nginx got http2 support.
- DeepYogurt 9y agoThe title really should be "UDP as a solution to protocol ossification". QUIC makes the point that you can develop a new transport-ish layer over UDP. Developing a new protocol on raw IP packets apparently gets blocked by firewall boxes around the world.
- ohazi 9y agoAlso encryption: > The first byte of the clear data was a flags field which, he said, was promptly ossified by a middlebox vendor, leading to packets being dropped when a new flag was set. [...] > The only defense against ossification of network protocols by middleboxes, he said at the conclusion of the talk, is encryption.
- lumisota 9y agoWell, it shows that Google can develop a new transport layer protocol over UDP.
- Moodles 9y agoWhile I think you are correct in that IP seems more stuck by middleboxes (SCTP is unreliable), I think any protocol whether it be over UDP or TCP can be subject to ossification. QUIC seems to have some useful properties to prevent this, such as the headers being encrypted. I could imagine alternative UDP protocols not doing this and causing more ossification.
- baby 9y agoThe beauty of it is that UDP is not even really a protocol, it's just a few additions (sport and dport) on top of IP. The RFC is only 3 pages long. So it's not like UDP is going to get in the way of your new protocol if you design on top of it.
- avian 9y agoMy take-away from the article is actually "encryption as a solution to protocol ossification". If some data (headers, etc.) is available as clear-text, there will be routers that act on it and possibly misbehave or block traffic when they encounter new patterns. So the article suggests that making it impossible for routers to inspect any protocol-specific information (via encryption) helps with this problem. Routers can't act on fields they can't read.
- ibotty 9y agoI failed to find anything a few times in the last years, so maybe it does not yet exist, but maybe someone here has any pointers. How can linux' iptables/netfilter match quic packages. Because quic is no ip protocol (but on top of udp) `-p quic` will not be implemented. Will one has to write a quic helper, so that one could match using `-m helper --helper quic`? I tend to think so, but I failed to find such a helper. Is there some difficulty I fail to see? Or is nobody interested (because nobody uses linux as a router)?
- _wmd 9y agoIt should in principle be possible to classify brand new Quic connections, since a tiny handful of its fields are cleartext during the initial handshake (flags and version, in both client/server directions) As for classifying existing Quic connections, it might get a little messier. There are still some cleartext fields but it might require observing multiple packets in the flow before making a guess the traffic is likely to be Quic. Meanwhile an explicit design goal of Quic is to avoid interference from middleboxes, so it would be no surprise if a perfect iptables Quic match is or remains impossible.
- londons_explore 9y agoSimply classifying on UDP port 443 would cover most usecases I'd guess?
- _wmd 9y agoWhere did you get 443 from? AFAIK even Google aren't using that. I didn't think there was any standardized port number at all
- londons_explore 9y agoGoogle uses UDP 443 for all it's quic services. Chrome will autoconnect to UDP 443 for any https request in parallel with TCP, and prefer QUIC if it works. Sure you could use another port, but it looks like UDP 443 is becoming the unofficial standard, even if not IETF endorsed...
- jonathanstrange 9y agoI have a question about an older UDP-based protocol. I was wondering for a long time whether UDT is worth it and in which scenarios. Has somebody tried it or is it kind of outdated?
- dangerface 9y agoUDT solves problems tcp has with congestion especially at 10Gbit+, this gives it a much higher throughput that tcp and pretty much anything else at 10Gbit+. I don't think it did much to fix latency issues which I think quick is more focused on. If you are interested in low latency protocols you should check out minimaLT[1] better performance than QUIC but the connections are portable across ip's so its better for mobiles, and can tunnel multiple connections together. DJB helped out with design so you know its super secure. [1] https://cr.yp.to/tcpip/minimalt-20130522.pdf https://cr.yp.to/tcpip/minimalt-20130522.pdf
- metaobject 9y agoWe did some experiments a few years ago when we were trying to quickly move several large-ish (30GB I think?) climate and weather data files around on Internet2 and we found that UDT solved our problems quite nicely.
- fsiefken 9y agoHow do QUIC features and capabilities overlap with those of HTTP/2? For example would using them both defeat the purpose of using one in the area of encryption or transfer speed?
- moviuro 9y ago> HTTP/2 was designed to address this problem using multiple "streams" built into a single connection. Multiple objects can be sent over a stream in parallel by multiplexing them into the connection. That helps, but it creates a new problem: the loss of a single packet will stall transmission of all of the streams at once, creating new latency issues. This variant on the head-of-line-blocking problem is built into TCP itself and cannot be fixed with more tweaks at the HTTP level. [0] https://lwn.net/Articles/745590/ https://lwn.net/Articles/745590/
- fsiefken 9y agothanks for the succinct explanation, I also found these two bits: https://ac.els-cdn.com/S1877050915016853/1-s2.0-S1877050915016853-main.pdf https://ac.els-cdn.com/S1877050915016853/1-s2.0-S18770509150... https://www.callstats.io/2017/02/03/web-protocols-http2-quic/ https://www.callstats.io/2017/02/03/web-protocols-http2-quic...
- baby 9y agoYou SHOULD use both of them at the same time. HTTP/2 intertwines your data by using different streams, except all of that is on top of TCP and one stream blocking (because a packet was dropped for example) will block the other streams. This is called head-of-line blocking and you basically can't do much to fix this in TCP unless you create multiple TCP connections for your different resources. But this has a bunch of other issues, you will need to figure out congestion control for each separate TCP connection even if they're connecting to the same service :/ QUIC also has multiple streams, but it doesn't have this head of line problem and other streams will continue to work fine if one stream blocks. So QUIC was made for HTTP/2, where your HTTP/2 streams are basically replaced by QUIC streams which are not affected by loss of packets at all. If you want to see how loss of packets affect an HTTP/2 connection over TCP, it's pretty bad. In general if you're on a lossy connection you should just use HTTP/1. Check this awesome talk: https://www.youtube.com/watch?v=0yzJAKknE_k https://www.youtube.com/watch?v=0yzJAKknE_k
- xg15 9y ago> The first byte of the clear data was a flags field which, he said, was promptly ossified by a middlebox vendor, leading to packets being dropped when a new flag was set. That was a classic example of why changing network protocols is hard and what needs to be done to improve the situation. Middleboxes are the control points for the Internet as we know it now. The only defense against ossification of network protocols by middleboxes, he said at the conclusion of the talk, is encryption. So apparently we're now at a point where any middlebox trying to make any use of a protocol higher than IP counts as "ossification"? No matter if the middlebox is well-behaved or not. And the only solution naturally is to make any stack parts higher than IP completely unusable by middleboxes by encrypting them. I guess this is make sense if you already fully control both clients and servers and get annoyed by middleboxes restricting your freedom to change the protocol on a whim. However, this seems like a major change in the vision of the internet to me. So has the internet community at large now agreed that we want to get rid of middleboxes completely? What about middleboxes I want to employ myself, e.g. to watch my own traffic?
- vertex-four 9y agoThe problem here isn’t really middleboxes - it’s that people who build middleboxes tend to break protocols. The flags field is specifically designed so that you can add stuff to it - if the middleboxes were to be built properly, they would fall back to “don’t touch anything” rather than “break the connection” when they don’t understand what’s going on. Middlebox vendors brought this upon themselves.
- baby 9y ago> Middlebox vendors brought this upon themselves. Not really, I'm sure they don't care much, most of internet users will blame their browsers instead.
- ohazi 9y agoIt's not a problem if you can keep them updated, but that's not usually what happens. Network equipment often keeps running in the closet without updates for 10+ years. That's the part that isn't working well.
- anonytrary 9y agoHeads up to the lazy folks: the article is much shorter than the scroll bar suggests.
- nfoz 9y agoI wonder what is the real difference between QUIC vs SCTP-over-UDP?
- JulienSchmidt 9y agoLower connection establishment latency: SCTP over UDP using DTLS requires 4 roundtrips (that's worse than standard TCP) while QUIC (which includes DTLS like encryption) only requires 1 roundtrip for the first connection and 0 RT for subsequent connections, when it cached some information.
- nfoz 9y agoThanks, I found this: https://docs.google.com/document/d/1RNHkx_VvKWyWg6Lr8SZ-saqsQx7rFV-ev2jRFUoVD34/mobilebasic#h.nvk2biis6bpk https://docs.google.com/document/d/1RNHkx_VvKWyWg6Lr8SZ-saqs... "One of the major and believably achievable goals of QUIC, is to predominantly have zero RTT connection (re)establishment, as was mentioned in goal 3a above. It is highly doubtful that SCTP over DTLS can come close to achieving that goal." ---- I actually think the "zero round-trip-time" claim is a bit too strong. It's only 0RTT if you've communicated before, so in a way it's not a new connection. There's a privacy implication here -- you should wipe that state between communications to be more anonymous -- and also you only get "predominantely 0RTT" with an increasingly centralized web.
- baby 9y agoI'm guessing QUIC integrates better with HTTP/2?
- IshKebab 9y agoOr enet (ignoring encryption).
- Moodles 9y agoDavid Benjamin has proposed the GREASE proposal for TLS. Basically, random values of future flags are thrown around so that servers (not middleboxes) have no choice but to process them. I think it is a good idea, but there are still occasionally niggles such as certain machines processing different meanings for specific flags, causing them to not be able to speak TLS 1.3.
- pacificmint 9y agoCloudflare had an interesting blog post[1] a month ago about TLS 1.3. It talks extensively about ossification and the GREASE proposal. [1] https://blog.cloudflare.com/why-tls-1-3-isnt-in-browsers-yet/ https://blog.cloudflare.com/why-tls-1-3-isnt-in-browsers-yet... Previous HN discussion of the post: https://news.ycombinator.com/item?id=16010930 https://news.ycombinator.com/item?id=16010930
- indescions_2018 9y agoCloudFlare's Filippo Valsorda also dives into the nitty gritty of their TLS 1.3 implementation here: TLS 1.3 - CloudFlare London Tech Talk https://vimeo.com/177333631 https://vimeo.com/177333631 And his experimental golang crypto/tls pkg: https://github.com/cloudflare/tls-tris https://github.com/cloudflare/tls-tris
- deleted 9y ago[deleted]
- the8472 9y agogrease works for string-valued flags. It's a bit more difficult to grease bitfields.
- minibob 9y agohttps://downloadidm99.blogspot.com/ https://downloadidm99.blogspot.com/ Download IDM Full Version Thanks!
- omginternets 9y agoFor those of you using Go, it's been an absolute pleasure to use https://github.com/lucas-clemente/quic-go https://github.com/lucas-clemente/quic-go. FWIW.
- fsiefken 9y agoCoincidentally came across this while looking up a board game: "The hidden costs of QUIC and TOU" https://www.snellman.net/blog/archive/2016-12-01-quic-tou/ https://www.snellman.net/blog/archive/2016-12-01-quic-tou/
- jsnell 9y agoWhile I still stand behind what was written in that post re: the non-endpoints needing the ability to troubleshoot networks, it might not be totally up to date. A caricature of the stakeholders in QUIC standardization would split them in three groups: - The privacy cabal thinks that every single bit of unencrypted data is unacceptable, since with enough statistical evidence over enough data paths it could be used to deduce some bit of totally irrelevant information about a user. - The operator cabal believes that any bit of encrypted metadata (but not payload data) is unacceptable, since there could be some valid operational reason to access it. - The ossification cabal believes that any bit of unencrypted data is unacceptable, since somebody in the operator cabal would end up misusing it, and accidentally fix the protocol in place. Now, obviously actual humans are more nuanced than that. Still, at the time that was written, it appeared that there was absolutely no chance of getting any manageability metadata at all. These are not positions conducive to compromise. (And the lack of that kind of data leads to horrible things like using the TCP traffic going to client X to infer measurements on the QUIC traffic going to the same client). But at the moment it feels like it might be possible (but nowhere near guaranteed) for the standardization to export some minimal amount of transport layer data. See for example the spin-bit proposal [0], where just 1-2 bits of incredibly non-sensitive data would already go a long way. Give me a single spin-bit and say 3 low-order bits of the packet number, and I'd be happy. [0] https://tools.ietf.org/html/draft-trammell-quic-spin-01 https://tools.ietf.org/html/draft-trammell-quic-spin-01
- Luker88 9y agoHonestly, I am kind of disappointed at QUIC. It could have been much more... * there is no support for non-reliable streams * I am not keen on the variability and non-alignment of the whole header (which can go from 0 to 60+ bytes). * it points too much towards just reducing the RTT for the initial connection (0RTT is a bad idea, especially if your application now needs to handle the special case of the connection being 0RTT or not). * There is no support for datagrams, just datastreams. * Perfect forward secrecy is not granted on the initial handshake (you need to explicitly do a second key exchange for that) * Forward error correction is actually cool but just using XOR is too limited. * The proof of ownership of the connection is one incredible hack And these are just the things I remember from looking at it a couple of years ago. Still, it's a nice improvement over older protocols. To those that are going to comment something like "Well, then do your own": that's exactly what I'm doing although it's going slowly as I don't have Google's budget.
- bryanlarsen 9y agoHave you tried engaging with IETF-QUIC?
- Luker88 9y agoI'm a nobody, the protocol is already well defined and what I need would call for something close to a rewrite, which is why I am actually doing my own. Hopefully in a one or two months I will have a stable enough implementation so people might be interested enough to contribute, then I can think about writing a proper rfc.
- niftich 9y agoIf you can nonetheless voice a design issue, consider putting it on the record in their own forum [1], even if your concerns won't result in substantive changes in the end. [1] https://github.com/quicwg/base-drafts/blob/master/CONTRIBUTING.md https://github.com/quicwg/base-drafts/blob/master/CONTRIBUTI...
- woah 9y ago
- bullen 9y agoInstead of making order guaranteed on UDP, allow removal (delay) of guarantee from TCP: https://www.ietf.org/id/draft-add-ackfreq-to-tcp-00.txt https://www.ietf.org/id/draft-add-ackfreq-to-tcp-00.txt
- gwbas1c 9y agoOne of the things that I don't like about TCP is that it really goes out of its way to emulate a stream of data over a wire. This then leads to things like Nagle's algorithm that deliberately slow it down. This is problematic when doing things like HTTP, or any of the infinite RPC schemes that come into popularity every few years. (REST, Thrift, Protocol Buffers, ect.) As a programmer, we're trying to send a request of known length and get a response where the server knows the length. As TCP makes this looks like a wire stream, it means that the protocol implementer needs to disable Nagle and implement logic that figures out where the requests begin and end; even though most likely these boundaries are the packet boundaries. Think of it this way: An HTTP GET request may fit into one or two IP packets; but the nature of TCP streams means that the server's HTTP API needs to find the \n\n to know when the request headers end. Instead, the stream API itself should just be able to say, "here's a packet of 300 bytes!" Furthermore, if the client didn't disable Nagle, its TCP library will deliberately delay sending the header for 200 ms. The reality of the TCP API is that it's great for long streams of data. It just isn't optimized for half of its use case.
- baby 9y agoif you care about these things, I imagine that using the PUSH flag of TCP gets rid of Nagle's?
- easytiger 9y agoIn RHEL 7, using TCP_NODELAY and FAST_ACK still results in IP level conflation. Even when you turn off hardware coalescence. Only way i've been able to get one push = one tcp packet is via solarflare. Even then you have to disable a SF specific batching amount that still kicks in when nagle is disabled
- baby 9y agoI thought SSH managed to do one packet per key pressed via the push option :o
- deleted 9y ago[deleted]
- deleted 9y ago[deleted]
- easytiger 9y agoMakes me wonder whatefver happened to PGM Reliable Transport Protocol Specification - https://tools.ietf.org/html/rfc3208 https://tools.ietf.org/html/rfc3208 Not an entirely dissimilar concept. LBM/29West being its successor.
- deleted 9y ago[deleted]
- wittedhaddock 9y agoFor cases where the payload is small (<100kb), Caffeine (http://www.caffei.net/ http://www.caffei.net/) is a good solution (TCP based)
- Someone 9y ago”One key feature of QUIC is that the transport headers — buried inside the UDP packets — are encrypted” I’m not sure I completely understand this, but does that mean you get net neutrality for free if you use this?
- wmf 9y agoNot for any useful definition of net neutrality; IP addresses are still visible for ISPs to discriminate on.
- otherlife35 9y agoOne Ring to rule them all, One Ring to find them, One Ring to bring them all and in the darkness bind them.