handshake

package
v0.8.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 27, 2018 License: MIT Imports: 20 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ErrCloseSessionForRetry = errors.New("closing session in order to recreate after a retry")

ErrCloseSessionForRetry is returned by HandleCryptoStream when the server wishes to perform a stateless retry

View Source 
var ErrNSTPExperiment = qerr.Error(qerr.InvalidCryptoMessageParameter, "NSTP experiment. Unsupported")

ErrNSTPExperiment is returned when the client sends the NSTP tag in the CHLO. This is an experiment implemented by Chrome in QUIC 38, which we don't support at this point.

Functions

This section is empty.

Types

type ConnectionState added in v0.7.0 

type ConnectionState struct {
	HandshakeComplete bool                // handshake is complete
	ServerName        string              // server name requested by client, if any (server side only)
	PeerCertificates  []*x509.Certificate // certificate chain presented by remote peer
}

ConnectionState records basic details about the QUIC connection. Warning: This API should not be considered stable and might change soon. 

type Cookie struct {
	RemoteAddr string
	// The time that the STK was issued (resolution 1 second)
	SentTime time.Time
}

A Cookie is derived from the client address and can be used to verify the ownership of this address.

type CookieGenerator 

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

A CookieGenerator generates Cookies

func NewCookieGenerator 

func NewCookieGenerator() (*CookieGenerator, error)

NewCookieGenerator initializes a new CookieGenerator

func (*CookieGenerator) DecodeToken 

func (g *CookieGenerator) DecodeToken(encrypted []byte) (*Cookie, error)

DecodeToken decodes a Cookie

func (*CookieGenerator) NewToken 

func (g *CookieGenerator) NewToken(raddr net.Addr) ([]byte, error)

NewToken generates a new Cookie for a given source address

type CookieHandler 

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

A CookieHandler generates and validates cookies. The cookie is sent in the TLS Retry. By including the cookie in its ClientHello, a client can proof ownership of its source address.

func NewCookieHandler 

func NewCookieHandler(callback func(net.Addr, *Cookie) bool, logger utils.Logger) (*CookieHandler, error)

NewCookieHandler creates a new CookieHandler.

func (*CookieHandler) Generate 

func (h *CookieHandler) Generate(conn *mint.Conn) ([]byte, error)

Generate a new cookie for a mint connection.

func (*CookieHandler) Validate 

func (h *CookieHandler) Validate(conn *mint.Conn, token []byte) bool

Validate a cookie.

type CryptoSetup 

type CryptoSetup interface {
	Open(dst, src []byte, packetNumber protocol.PacketNumber, associatedData []byte) ([]byte, protocol.EncryptionLevel, error)
	// contains filtered or unexported methods
}

CryptoSetup is the crypto setup used by gQUIC

func NewCryptoSetup 

func NewCryptoSetup(
	cryptoStream io.ReadWriter,
	connID protocol.ConnectionID,
	remoteAddr net.Addr,
	version protocol.VersionNumber,
	divNonce []byte,
	scfg *ServerConfig,
	params *TransportParameters,
	supportedVersions []protocol.VersionNumber,
	acceptSTK func(net.Addr, *Cookie) bool,
	paramsChan chan<- TransportParameters,
	handshakeEvent chan<- struct{},
	logger utils.Logger,
) (CryptoSetup, error)

NewCryptoSetup creates a new CryptoSetup instance for a server

func NewCryptoSetupClient 

func NewCryptoSetupClient(
	cryptoStream io.ReadWriter,
	hostname string,
	connID protocol.ConnectionID,
	version protocol.VersionNumber,
	tlsConfig *tls.Config,
	params *TransportParameters,
	paramsChan chan<- TransportParameters,
	handshakeEvent chan<- struct{},
	initialVersion protocol.VersionNumber,
	negotiatedVersions []protocol.VersionNumber,
	logger utils.Logger,
) (CryptoSetup, error)

NewCryptoSetupClient creates a new CryptoSetup instance for a client

type CryptoSetupTLS added in v0.8.0 

type CryptoSetupTLS interface {
	OpenHandshake(dst, src []byte, packetNumber protocol.PacketNumber, associatedData []byte) ([]byte, error)
	Open1RTT(dst, src []byte, packetNumber protocol.PacketNumber, associatedData []byte) ([]byte, error)
	// contains filtered or unexported methods
}

CryptoSetupTLS is the crypto setup used by IETF QUIC

func NewCryptoSetupTLSClient 

func NewCryptoSetupTLSClient(
	cryptoStream io.ReadWriter,
	connID protocol.ConnectionID,
	hostname string,
	handshakeEvent chan<- struct{},
	tls MintTLS,
	version protocol.VersionNumber,
) (CryptoSetupTLS, error)

NewCryptoSetupTLSClient creates a new TLS CryptoSetup instance for a client

func NewCryptoSetupTLSServer 

func NewCryptoSetupTLSServer(
	tls MintTLS,
	cryptoStream *CryptoStreamConn,
	nullAEAD crypto.AEAD,
	handshakeEvent chan<- struct{},
	version protocol.VersionNumber,
) CryptoSetupTLS

NewCryptoSetupTLSServer creates a new TLS CryptoSetup instance for a server

type CryptoStreamConn 

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

The CryptoStreamConn is used as the net.Conn passed to mint. It has two operating modes: 1. It can read and write to bytes.Buffers. 2. It can use a quic.Stream for reading and writing. The buffer-mode is only used by the server, in order to statelessly handle retries.

func NewCryptoStreamConn 

func NewCryptoStreamConn(remoteAddr net.Addr) *CryptoStreamConn

NewCryptoStreamConn creates a new CryptoStreamConn

func (*CryptoStreamConn) AddDataForReading 

func (c *CryptoStreamConn) AddDataForReading(data []byte)

AddDataForReading adds data to the read buffer. This data will ONLY be read when the stream has not been set.

func (*CryptoStreamConn) Close 

func (c *CryptoStreamConn) Close() error

Close is not implemented

func (*CryptoStreamConn) Flush 

func (c *CryptoStreamConn) Flush() (int, error)

Flush copies the contents of the write buffer to the stream

func (*CryptoStreamConn) GetDataForWriting 

func (c *CryptoStreamConn) GetDataForWriting() []byte

GetDataForWriting returns all data currently in the write buffer, and resets this buffer.

func (*CryptoStreamConn) LocalAddr 

func (c *CryptoStreamConn) LocalAddr() net.Addr

LocalAddr is not implemented

func (*CryptoStreamConn) Read 

func (c *CryptoStreamConn) Read(b []byte) (int, error)

func (*CryptoStreamConn) RemoteAddr 

func (c *CryptoStreamConn) RemoteAddr() net.Addr

RemoteAddr returns the remote address

func (*CryptoStreamConn) SetDeadline 

func (c *CryptoStreamConn) SetDeadline(time.Time) error

SetDeadline is not implemented

func (*CryptoStreamConn) SetReadDeadline 

func (c *CryptoStreamConn) SetReadDeadline(time.Time) error

SetReadDeadline is not implemented

func (*CryptoStreamConn) SetStream 

func (c *CryptoStreamConn) SetStream(stream io.ReadWriter)

SetStream sets the stream. After setting the stream, the read and write buffer won't be used any more.

func (*CryptoStreamConn) SetWriteDeadline 

func (c *CryptoStreamConn) SetWriteDeadline(time.Time) error

SetWriteDeadline is not implemented

func (*CryptoStreamConn) Write 

func (c *CryptoStreamConn) Write(p []byte) (int, error)

type HandshakeMessage 

type HandshakeMessage struct {
	Tag  Tag
	Data map[Tag][]byte
}

A HandshakeMessage is a handshake message

func ParseHandshakeMessage 

func ParseHandshakeMessage(r io.Reader) (HandshakeMessage, error)

ParseHandshakeMessage reads a crypto message

func (HandshakeMessage) String 

func (h HandshakeMessage) String() string

func (HandshakeMessage) Write 

func (h HandshakeMessage) Write(b *bytes.Buffer)

Write writes a crypto message

type KeyDerivationFunction 

type KeyDerivationFunction func(crypto.TLSExporter, protocol.Perspective) (crypto.AEAD, error)

KeyDerivationFunction is used for key derivation

type KeyExchangeFunction 

type KeyExchangeFunction func() (crypto.KeyExchange, error)

KeyExchangeFunction is used to make a new KEX

type MintTLS 

type MintTLS interface {
	crypto.TLSExporter

	// additional methods
	Handshake() mint.Alert
	State() mint.State
	ConnectionState() mint.ConnectionState

	SetCryptoStream(io.ReadWriter)
}

MintTLS combines some methods needed to interact with mint.

type QuicCryptoKeyDerivationFunction 

type QuicCryptoKeyDerivationFunction func(forwardSecure bool, sharedSecret, nonces []byte, connID protocol.ConnectionID, chlo []byte, scfg []byte, cert []byte, divNonce []byte, pers protocol.Perspective) (crypto.AEAD, error)

QuicCryptoKeyDerivationFunction is used for key derivation

type Sealer 

type Sealer interface {
	Seal(dst, src []byte, packetNumber protocol.PacketNumber, associatedData []byte) []byte
	Overhead() int
}

Sealer seals a packet

type ServerConfig 

type ServerConfig struct {
	ID []byte
	// contains filtered or unexported fields
}

ServerConfig is a server config

func NewServerConfig 

func NewServerConfig(kex crypto.KeyExchange, certChain crypto.CertChain) (*ServerConfig, error)

NewServerConfig creates a new server config

func (*ServerConfig) Get 

func (s *ServerConfig) Get() []byte

Get the server config binary representation

func (*ServerConfig) GetCertsCompressed 

func (s *ServerConfig) GetCertsCompressed(sni string, commonSetHashes, compressedHashes []byte) ([]byte, error)

GetCertsCompressed returns the certificate data

func (*ServerConfig) Sign 

func (s *ServerConfig) Sign(sni string, chlo []byte) ([]byte, error)

Sign the server config and CHLO with the server's keyData

type TLSExtensionHandler 

type TLSExtensionHandler interface {
	Send(mint.HandshakeType, *mint.ExtensionList) error
	Receive(mint.HandshakeType, *mint.ExtensionList) error
	GetPeerParams() <-chan TransportParameters
}

A TLSExtensionHandler sends and received the QUIC TLS extension. It provides the parameters sent by the peer on a channel.

func NewExtensionHandlerClient 

func NewExtensionHandlerClient(
	params *TransportParameters,
	initialVersion protocol.VersionNumber,
	supportedVersions []protocol.VersionNumber,
	version protocol.VersionNumber,
	logger utils.Logger,
) TLSExtensionHandler

NewExtensionHandlerClient creates a new extension handler for the client.

func NewExtensionHandlerServer 

func NewExtensionHandlerServer(
	params *TransportParameters,
	supportedVersions []protocol.VersionNumber,
	version protocol.VersionNumber,
	logger utils.Logger,
) TLSExtensionHandler

NewExtensionHandlerServer creates a new extension handler for the server

type Tag 

type Tag uint32

A Tag in the QUIC crypto 

const (
	// TagCHLO is a client hello
	TagCHLO Tag = 'C' + 'H'<<8 + 'L'<<16 + 'O'<<24
	// TagREJ is a server hello rejection
	TagREJ Tag = 'R' + 'E'<<8 + 'J'<<16
	// TagSCFG is a server config
	TagSCFG Tag = 'S' + 'C'<<8 + 'F'<<16 + 'G'<<24

	// TagPAD is padding
	TagPAD Tag = 'P' + 'A'<<8 + 'D'<<16
	// TagSNI is the server name indication
	TagSNI Tag = 'S' + 'N'<<8 + 'I'<<16
	// TagVER is the QUIC version
	TagVER Tag = 'V' + 'E'<<8 + 'R'<<16
	// TagCCS are the hashes of the common certificate sets
	TagCCS Tag = 'C' + 'C'<<8 + 'S'<<16
	// TagCCRT are the hashes of the cached certificates
	TagCCRT Tag = 'C' + 'C'<<8 + 'R'<<16 + 'T'<<24
	// TagMSPC is max streams per connection
	TagMSPC Tag = 'M' + 'S'<<8 + 'P'<<16 + 'C'<<24
	// TagMIDS is max incoming dyanamic streams
	TagMIDS Tag = 'M' + 'I'<<8 + 'D'<<16 + 'S'<<24
	// TagUAID is the user agent ID
	TagUAID Tag = 'U' + 'A'<<8 + 'I'<<16 + 'D'<<24
	// TagSVID is the server ID (unofficial tag by us :)
	TagSVID Tag = 'S' + 'V'<<8 + 'I'<<16 + 'D'<<24
	// TagTCID is truncation of the connection ID
	TagTCID Tag = 'T' + 'C'<<8 + 'I'<<16 + 'D'<<24
	// TagPDMD is the proof demand
	TagPDMD Tag = 'P' + 'D'<<8 + 'M'<<16 + 'D'<<24
	// TagSRBF is the socket receive buffer
	TagSRBF Tag = 'S' + 'R'<<8 + 'B'<<16 + 'F'<<24
	// TagICSL is the idle connection state lifetime
	TagICSL Tag = 'I' + 'C'<<8 + 'S'<<16 + 'L'<<24
	// TagNONP is the client proof nonce
	TagNONP Tag = 'N' + 'O'<<8 + 'N'<<16 + 'P'<<24
	// TagSCLS is the silently close timeout
	TagSCLS Tag = 'S' + 'C'<<8 + 'L'<<16 + 'S'<<24
	// TagCSCT is the signed cert timestamp (RFC6962) of leaf cert
	TagCSCT Tag = 'C' + 'S'<<8 + 'C'<<16 + 'T'<<24
	// TagCOPT are the connection options
	TagCOPT Tag = 'C' + 'O'<<8 + 'P'<<16 + 'T'<<24
	// TagCFCW is the initial session/connection flow control receive window
	TagCFCW Tag = 'C' + 'F'<<8 + 'C'<<16 + 'W'<<24
	// TagSFCW is the initial stream flow control receive window.
	TagSFCW Tag = 'S' + 'F'<<8 + 'C'<<16 + 'W'<<24

	// TagNSTP is the no STOP_WAITING experiment
	// currently unsupported by quic-go
	TagNSTP Tag = 'N' + 'S'<<8 + 'T'<<16 + 'P'<<24

	// TagSTK is the source-address token
	TagSTK Tag = 'S' + 'T'<<8 + 'K'<<16
	// TagSNO is the server nonce
	TagSNO Tag = 'S' + 'N'<<8 + 'O'<<16
	// TagPROF is the server proof
	TagPROF Tag = 'P' + 'R'<<8 + 'O'<<16 + 'F'<<24

	// TagNONC is the client nonce
	TagNONC Tag = 'N' + 'O'<<8 + 'N'<<16 + 'C'<<24
	// TagXLCT is the expected leaf certificate
	TagXLCT Tag = 'X' + 'L'<<8 + 'C'<<16 + 'T'<<24

	// TagSCID is the server config ID
	TagSCID Tag = 'S' + 'C'<<8 + 'I'<<16 + 'D'<<24
	// TagKEXS is the list of key exchange algos
	TagKEXS Tag = 'K' + 'E'<<8 + 'X'<<16 + 'S'<<24
	// TagAEAD is the list of AEAD algos
	TagAEAD Tag = 'A' + 'E'<<8 + 'A'<<16 + 'D'<<24
	// TagPUBS is the public value for the KEX
	TagPUBS Tag = 'P' + 'U'<<8 + 'B'<<16 + 'S'<<24
	// TagOBIT is the client orbit
	TagOBIT Tag = 'O' + 'B'<<8 + 'I'<<16 + 'T'<<24
	// TagEXPY is the server config expiry
	TagEXPY Tag = 'E' + 'X'<<8 + 'P'<<16 + 'Y'<<24
	// TagCERT is the CERT data
	TagCERT Tag = 0xff545243

	// TagSHLO is the server hello
	TagSHLO Tag = 'S' + 'H'<<8 + 'L'<<16 + 'O'<<24

	// TagPRST is the public reset tag
	TagPRST Tag = 'P' + 'R'<<8 + 'S'<<16 + 'T'<<24
	// TagRSEQ is the public reset rejected packet number
	TagRSEQ Tag = 'R' + 'S'<<8 + 'E'<<16 + 'Q'<<24
	// TagRNON is the public reset nonce
	TagRNON Tag = 'R' + 'N'<<8 + 'O'<<16 + 'N'<<24
)

type TransportParameters 

type TransportParameters struct {
	StreamFlowControlWindow     protocol.ByteCount
	ConnectionFlowControlWindow protocol.ByteCount

	MaxPacketSize protocol.ByteCount

	MaxUniStreams  uint16 // only used for IETF QUIC
	MaxBidiStreams uint16 // only used for IETF QUIC
	MaxStreams     uint32 // only used for gQUIC

	OmitConnectionID bool // only used for gQUIC
	IdleTimeout      time.Duration
}

TransportParameters are parameters sent to the peer during the handshake

func (*TransportParameters) String added in v0.8.0 

func (p *TransportParameters) String() string

String returns a string representation, intended for logging. It should only used for IETF QUIC.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.