niaucchi5

README

niaucchi5 --- an obfuscated, encrypted multiplexed unreliable channel

Overview of architecture

Niaucchi5 provides an interface similar to that of QUIC, except that streams are unreliable. There's optional support for reliable streams based on a simple TCP-like protocol.

This maps neatly to Geph: proxy mode uses reliable streams, while VPN mode uses a single unreliable stream.

Niaucchi5 is a richly layered protocol:

|-----------------------|
|        streams        |
|-----------------------|
|  encryption protocol  |
|-----------------------|
| wire | wire | wire ...|
|-----------------------|
| obfs | obfs | obfs ...|
|-----------------------|

We take a bottom-down approach, specifying the lower layers before the upper layers.

Documentation

Index

• Variables
• func ToPacketConn(pw PacketWire) net.PacketConn
• type PacketWire
• type URTCP
  • func NewURTCP(wire net.Conn) *URTCP
  • func (tr *URTCP) RecvSegment(seg []byte) (n int, err error)
  • func (tr *URTCP) SendSegment(seg []byte, block bool) (err error)

Variables

var StandardAddr net.Addr

StandardAddr is the standard net.Addr to communicate with the "other end" in PacketWire-generated PacketConns.

Functions

func ToPacketConn

func ToPacketConn(pw PacketWire) net.PacketConn

ToPacketConn converts a PacketWire to a PacketConn with a standard remote address.

Types

type PacketWire

type PacketWire interface {
	SendSegment(seg []byte, allowBlocking bool) (err error)
	RecvSegment(seg []byte) (n int, err error)
}

PacketWire is the base "unreliable connection" primitive used in niaucchi5.

type URTCP

type URTCP struct {
	// contains filtered or unexported fields
}

URTCP implements "unreliable TCP". This is an unreliable PacketWire implementation over reliable net.Conn's like TCP, yet avoids excessive bufferbloat, "TCP over TCP" problems, etc.

func NewURTCP

func NewURTCP(wire net.Conn) *URTCP

NewURTCP creates a new URTCP instance.

func (*URTCP) RecvSegment

func (tr *URTCP) RecvSegment(seg []byte) (n int, err error)

RecvSegment receives a single segment.

func (*URTCP) SendSegment

func (tr *URTCP) SendSegment(seg []byte, block bool) (err error)

SendSegment sends a single segment.