quic-go - A QUIC implementation in pure go

•    Go

quic-go is an implementation of the QUIC protocol in Go. quic-go is compatible with the current version(s) of Google Chrome and QUIC as deployed on Google's servers. We're actively tracking the development of the Chrome code to ensure compatibility as the protocol evolves. In that process, we're dropping support for old QUIC versions. As Google's QUIC versions are expected to converge towards the IETF QUIC draft, quic-go will eventually implement that draft.

gost - GO Simple Tunnel - a simple tunnel written in golang

•    Go

GO Simple Tunnel - a simple tunnel written in golang

quinn - Futures-based QUIC implementation in Rust

•    Rust

Quinn is a pure-rust, future-based implementation of the QUIC transport protocol undergoing standardization by the IETF. This library is at draft 32. This launches an HTTP 0.9 server on the loopback address serving the current working directory, with the client fetching ./Cargo.toml. By default, the server generates a self-signed certificate and stores it to disk, where the client will automatically find and trust it.

aioquic - QUIC and HTTP/3 implementation in Python

•    Python

aioquic is a library for the QUIC network protocol in Python. It features a minimal TLS 1.3 implementation, a QUIC stack and an HTTP/3 stack. QUIC standardisation is not finalised yet, but aioquic closely tracks the specification drafts and is regularly tested for interoperability against other QUIC implementations.

MsQuic - Cross-platform, C implementation of the IETF QUIC protocol, exposed to C, C++, C# and Rust

•    C

MsQuic is a Microsoft implementation of the IETF QUIC protocol. QUIC, a UDP-based, stream-multiplexing, encrypted transport protocol. It is cross-platform, written in C and designed to be a general purpose QUIC library. MsQuic also has C++ API wrapper classes and exposes interop layers for both Rust and C#.

yomo - 🦖 Serverless Streaming Framework for Low-latency Edge Computing applications, running atop QUIC protocol, as Metaverse infrastructure, engaging 5G technology

•    Go

YoMo is an open-source Streaming Serverless Framework for building Low-latency Edge Computing applications. Built atop QUIC Transport Protocol and Functional Reactive Programming interface. makes real-time data processing reliable, secure, and easy. Congratulations! You have done your first YoMo Stream Function.

gsnova - Private proxy solution & network troubleshooting tool.

•    Go

GSnova: Private Proxy Solution. go1.9 is requied.

PyExfil - A Python Package for Data Exfiltration

•    Python

All requirements can be met with a pip install --user -r requirments.txt. After that the server is easy to execute. Notice that in some cases you might want to use py2exe before delivering the package to the code you want to operate. So recently we have decided to impliment some physical data exfiltration techniques assuming some networks might be airgapped from any internet connectivity. So this is the first one. It will encode a file in several QR codes, display them on the screen one by one and it comes with a decoder to recompile that into the file itself.

sower - Sower is a cross platform intelligent transparent proxy solution

•    Go

The sower is a cross-platform intelligent transparent proxy tool base on DNS solution. The first time you visit a new website, sower will detect if the domain in block list and add it in suggect list. So that, you do not need to care about the rules, sower will handle it in a intelligent way.

this-is-quic - A document describing the QUIC protocol

Get the Web, PDF, or e-book versions on gitbook.com. The contents get updated automatically on every commit to this git repository.

quicrs - A QUIC library for Rust

•    Rust

A Rust library for using the QUIC protocol. This library tracks the IETF QUIC protocol and not the Google implementation.

quic-py - QUIC protocol implementation in python

•    Python

QUIC protocol implementation in python

quic-conn - a single-stream encrypted connection between two peers using QUIC

•    Go

At the moment, this project is intended to figure out the right API exposed by the quic package in quic-go. When fully implemented, a QUIC connection can be used as a replacement for an encrypted TCP connection. It provides a single ordered byte-stream abstraction, with the main benefit of being able to perform connection migration.

go-libp2p-quic-transport - An implementation of a libp2p transport using QUIC

•    Go

This is an implementation of the libp2p transport and the libp2p stream muxer using QUIC.

quic-proxy - A http/https proxy using QUIC as transport layer

•    Go

A http/https proxy using QUIC as transport layer. Implementation detail: A http proxy based on QUIC in 100 lines.

quictun - The simplest tunnel service based on QUIC.

•    Go

The simplest tunnel service based on QUIC. Download precompiled Releases.

quic-tracker - A test suite for QUIC

•    Go

The test suite comprises a minimal Go implementation of QUIC which is currently draft-17/18 and TLS-1.3 compatible, as well as several test scenarii built upon this implementation. The test suite outputs its result as JSON files, which contains the result, the decrypted packets exchanged, as well as a pcap file and exporter secrets. You should have Go 1.9, tcpdump, libpcap libraries and headers as well as openssl headers installed before starting.

quictun - Hidden Tunneling using the QUIC Protocol

•    Go

quictun is a simple hidden tunnel based on the QUIC protocol. This repository contains a proof-of-concept implementation of quictun. Its purpose is to demonstrate that quictun clients and servers can be implemented with minimal effort on top of an existing QUIC and HTTP/2 over QUIC implementation. The implementation uses the quic-go QUIC implementation as a basis.

quinn - Futures-based QUIC implementation in Rust

•    Rust

Quinn is an implementation of the QUIC network protocol currently undergoing standardization by the IETF. It is currently suitable for experimental use. The implementation is split up into the state machine crate quinn-proto which performs no I/O internally and can be tested deterministically, and a high-level tokio-compatible API in quinn. See quinn/examples/ for usage. Quinn is the subject of a RustFest Paris (May 2018) presentation; you can also get the slides (and the animation about head-of-line blocking). Video of the talk is available on YouTube. Since this presentation, Quinn has been merged with quicr, another Rust implementation.

master-thesis - A test suite for QUIC

•    Go

This work is part of my master thesis for my master's degree in Computer Science at Université catholique de Louvain. It is supervised by Pr. Olivier Bonaventure and Quentin De Coninck. It is a test suite that exchanges packets with IETF-QUIC implementations to verify whether an implementation conforms with the IETF specification of QUIC. The test suite is consisting of several test scenarii. Each of them aims at testing a particular feature of the QUIC protocol. The test suite runs daily, and its results are available on https://quic-tracker.info.ucl.ac.be. This is the main focus of my effort.