pattern

Documentation

Overview

Package pattern implements the Noise Protocol Framework handshake pattern abstract interface and standard patterns.

Index

• Variables
• func IsValid(pa Pattern) error
• func Register(pa Pattern) error
• type Message
• type Pattern
  • func FromString(s string) Pattern
  • func MakePSK(template Pattern, modifier string) (Pattern, error)
• type Token
  • func (t Token) String() string

Variables

var (
	// NN is the NN interactive (fundemental) pattern.
	NN Pattern = &builtIn{
		name: "NN",
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee},
		},
	}

	// NK is the NK interactive (fundemental) pattern.
	NK Pattern = &builtIn{
		name: "NK",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_e, Token_es},
			{Token_e, Token_ee},
		},
	}

	// NX is the NX interactive (fundemental) pattern.
	NX Pattern = &builtIn{
		name: "NX",
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_s, Token_es},
		},
	}

	// XN is the XN interactive (fundemental) pattern.
	XN Pattern = &builtIn{
		name: "XN",
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee},
			{Token_s, Token_se},
		},
	}

	// XK is the XK interactive (fundemental) pattern.
	XK Pattern = &builtIn{
		name: "XK",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_e, Token_es},
			{Token_e, Token_ee},
			{Token_s, Token_se},
		},
	}

	// XX is the XX interactive (fundemental) pattern.
	XX Pattern = &builtIn{
		name: "XX",
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_s, Token_es},
			{Token_s, Token_se},
		},
	}

	// KN is the KN interactive (fundemental) pattern.
	KN Pattern = &builtIn{
		name: "KN",
		preMessages: []Message{
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_se},
		},
	}

	// KK is the KK interactive (fundemental) pattern.
	KK Pattern = &builtIn{
		name: "KK",
		preMessages: []Message{
			{Token_s},
			{Token_s},
		},
		messages: []Message{
			{Token_e, Token_es, Token_ss},
			{Token_e, Token_ee, Token_se},
		},
	}

	// KX is the KX interactive (fundemental) pattern.
	KX Pattern = &builtIn{
		name: "KX",
		preMessages: []Message{
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_se, Token_s, Token_es},
		},
	}

	// IN is the IN interactive (fundemental) pattern.
	IN Pattern = &builtIn{
		name: "IN",
		messages: []Message{
			{Token_e, Token_s},
			{Token_e, Token_ee, Token_se},
		},
	}

	// IK is the IK interactive (fundemental) pattern.
	IK Pattern = &builtIn{
		name: "IK",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_e, Token_es, Token_s, Token_ss},
			{Token_e, Token_ee, Token_se},
		},
	}

	// IX is the IX interactive (fundemental) pattern.
	IX Pattern = &builtIn{
		name: "IX",
		messages: []Message{
			{Token_e, Token_s},
			{Token_e, Token_ee, Token_se, Token_s, Token_es},
		},
	}

	// NNpsk0 is the NNpsk0 interactive (fundemental) pattern.
	NNpsk0 = mustMakePSK(NN, "psk0")

	// NNpsk2 is the NNpsk2 interactive (fundemental) pattern.
	NNpsk2 = mustMakePSK(NN, "psk2")

	// NKpsk0 is the NKpsk0 interactive (fundemental) pattern.
	NKpsk0 = mustMakePSK(NK, "psk0")

	// NKpsk2 is the NKpsk2 interactive (fundemental) pattern.
	NKpsk2 = mustMakePSK(NK, "psk2")

	// NXpsk2 is the NXpsk2 interactive (fundemental) pattern.
	NXpsk2 = mustMakePSK(NX, "psk2")

	// XNpsk3 is the XNpsk3 interactive (fundemental) pattern.
	XNpsk3 = mustMakePSK(XN, "psk3")

	// XKpsk3 is the XKpsk3 interactive (fundemental) pattern.
	XKpsk3 = mustMakePSK(XK, "psk3")

	// XXpsk3 is the XXpsk3 interactive (fundemental) pattern.
	XXpsk3 = mustMakePSK(XX, "psk3")

	// KNpsk0 is the KNpsk0 interactive (fundemental) pattern.
	KNpsk0 = mustMakePSK(KN, "psk0")

	// KNpsk2 is the KNpsk2 interactive (fundemental) pattern.
	KNpsk2 = mustMakePSK(KN, "psk2")

	// KKpsk0 is the KKpsk0 interactive (fundemental) pattern.
	KKpsk0 = mustMakePSK(KK, "psk0")

	// KKpsk2 is the KKpsk2 interactive (fundemental) pattern.
	KKpsk2 = mustMakePSK(KK, "psk2")

	// KXpsk2 is the KXpsk2 interactive (fundemental) pattern.
	KXpsk2 = mustMakePSK(KX, "psk2")

	// INpsk1 is the INpsk1 interactive (fundemental) pattern.
	INpsk1 = mustMakePSK(IN, "psk1")

	// INpsk2 is the INpsk2 interactive (fundemental) pattern.
	INpsk2 = mustMakePSK(IN, "psk2")

	// IKpsk1 is the IKpsk1 interactive (fundemental) pattern.
	IKpsk1 = mustMakePSK(IK, "psk1")

	// IKpsk2 is the IKpsk2 interactive (fundemental) pattern.
	IKpsk2 = mustMakePSK(IK, "psk2")

	// IXpsk2 is the IXpsk2 interactive (fundemental) pattern.
	IXpsk2 = mustMakePSK(IX, "psk2")
)

var (
	// N is the N one-way handshake pattern.
	N Pattern = &builtIn{
		name: "N",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_e, Token_es},
		},
		isOneWay: true,
	}

	// K is the K one-way handshake pattern.
	K Pattern = &builtIn{
		name: "K",
		preMessages: []Message{
			{Token_s},
			{Token_s},
		},
		messages: []Message{
			{Token_e, Token_es, Token_ss},
		},
		isOneWay: true,
	}

	// X is the X one-way handshake pattern.
	X Pattern = &builtIn{
		name: "X",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_e, Token_es, Token_s, Token_ss},
		},
		isOneWay: true,
	}

	// Npsk0 is the Npsk0 one-way handshake pattern.
	Npsk0 = mustMakePSK(N, "psk0")

	// Kpsk0 is the Kpsk0 one-way handshake pattern.
	Kpsk0 = mustMakePSK(K, "psk0")

	// Xpsk1 is the Xpsk1 one-way handshake pattern.
	Xpsk1 = mustMakePSK(X, "psk1")
)

Functions

func IsValid

func IsValid(pa Pattern) error

IsValid checks a pattern for validity according to the handshake pattern validity rules, and implementation limitations.

Warning: This is not particularly fast, and should only be called when validating custom patterns, or testing. KEM pattern validation is not fully supported yet.

func Register

func Register(pa Pattern) error

Register registers a new pattern for use with `FromString()`.

Types

type Message

type Message []Token

Message is a sequence of pattern tokens.

type Pattern

type Pattern interface {
	fmt.Stringer

	// PreMessages returns the pre-message message patterns.
	PreMessages() []Message

	// Mesages returns the message patterns.
	Messages() []Message

	// NumPSKs returns the number of `psk` modifiers in the pattern.
	NumPSKs() int

	// IsOneWay returns true iff the pattern is one-way.
	IsOneWay() bool

	// IsKEM returns true iff the pattern uses a KEM for key exchanges.
	IsKEM() bool
}

Pattern is a handshake pattern.

var (
	// NK1 is the NK1 deferred pattern.
	NK1 Pattern = &builtIn{
		name: "NK1",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_es},
		},
	}

	// NX1 is the NX1 deferred pattern.
	NX1 Pattern = &builtIn{
		name: "NX1",
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_s},
			{Token_es},
		},
	}

	// X1N is the X1N deferred pattern.
	X1N Pattern = &builtIn{
		name: "X1N",
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee},
			{Token_s},
			{Token_se},
		},
	}

	// X1K is the X1K deferred pattern.
	X1K Pattern = &builtIn{
		name: "X1K",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_e, Token_es},
			{Token_e, Token_ee},
			{Token_s},
			{Token_se},
		},
	}

	// XK1 is the XK1 deferred pattern.
	XK1 Pattern = &builtIn{
		name: "XK1",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_es},
			{Token_s, Token_se},
		},
	}

	// X1K1 is the X1K1 deferred pattern.
	X1K1 Pattern = &builtIn{
		name: "X1K1",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_es},
			{Token_s},
			{Token_se},
		},
	}

	// X1X is the X1X deferred pattern.
	X1X Pattern = &builtIn{
		name: "X1X",
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_s, Token_es},
			{Token_s},
			{Token_se},
		},
	}

	// XX1 is the XX1 deferred pattern.
	XX1 Pattern = &builtIn{
		name: "XX1",
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_s},
			{Token_es, Token_s, Token_se},
		},
	}

	// X1X1 is the X1X1 deferred pattern.
	X1X1 Pattern = &builtIn{
		name: "X1X1",
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_s},
			{Token_es, Token_s},
			{Token_se},
		},
	}

	// K1N is the K1N deferred pattern.
	K1N Pattern = &builtIn{
		name: "K1N",
		preMessages: []Message{
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee},
			{Token_se},
		},
	}

	// K1K is the K1K deferred pattern.
	K1K Pattern = &builtIn{
		name: "K1K",
		preMessages: []Message{
			{Token_s},
			{Token_s},
		},
		messages: []Message{
			{Token_e, Token_es},
			{Token_e, Token_ee},
			{Token_se},
		},
	}

	// KK1 is the KK1 deferred pattern.
	KK1 Pattern = &builtIn{
		name: "KK1",
		preMessages: []Message{
			{Token_s},
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_se, Token_es},
		},
	}

	// K1K1 is the K1K1 deferred pattern.
	K1K1 Pattern = &builtIn{
		name: "K1K1",
		preMessages: []Message{
			{Token_s},
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_es},
			{Token_se},
		},
	}

	// K1X is the K1X deferred pattern.
	K1X Pattern = &builtIn{
		name: "K1X",
		preMessages: []Message{
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_s, Token_es},
			{Token_se},
		},
	}

	// KX1 is the KX1 deferred pattern.
	KX1 Pattern = &builtIn{
		name: "KX1",
		preMessages: []Message{
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_se, Token_s},
			{Token_es},
		},
	}

	// K1X1 is the K1X1 deferred pattern.
	K1X1 Pattern = &builtIn{
		name: "K1X1",
		preMessages: []Message{
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_e, Token_ee, Token_s},
			{Token_se, Token_es},
		},
	}

	// I1N is the I1N deferred pattern.
	I1N Pattern = &builtIn{
		name: "I1N",
		messages: []Message{
			{Token_e, Token_s},
			{Token_e, Token_ee},
			{Token_se},
		},
	}

	// I1K is the I1K deferred pattern.
	I1K Pattern = &builtIn{
		name: "I1K",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_e, Token_es, Token_s},
			{Token_e, Token_ee},
			{Token_se},
		},
	}

	// IK1 is the IK1 deferred pattern.
	IK1 Pattern = &builtIn{
		name: "IK1",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_e, Token_s},
			{Token_e, Token_ee, Token_se, Token_es},
		},
	}

	// I1K1 is the I1K1 deferred pattern.
	I1K1 Pattern = &builtIn{
		name: "I1K1",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_e, Token_s},
			{Token_e, Token_ee, Token_es},
			{Token_se},
		},
	}

	// I1X is the I1X deferred pattern.
	I1X Pattern = &builtIn{
		name: "I1X",
		messages: []Message{
			{Token_e, Token_s},
			{Token_e, Token_ee, Token_s, Token_es},
			{Token_se},
		},
	}

	// IX1 is the IX1 deferred pattern.
	IX1 Pattern = &builtIn{
		name: "IX1",
		messages: []Message{
			{Token_e, Token_s},
			{Token_e, Token_ee, Token_se, Token_s},
			{Token_es},
		},
	}

	// I1X1 is the I1X1 deferred pattern.
	I1X1 Pattern = &builtIn{
		name: "I1X1",
		messages: []Message{
			{Token_e, Token_s},
			{Token_e, Token_ee, Token_s},
			{Token_se, Token_es},
		},
	}
)

var (
	// PqNN is the pqNN interactive (fundemental) pattern.
	PqNN Pattern = &builtIn{
		name: "pqNN",
		messages: []Message{
			{Token_e},
			{Token_ekem},
		},
		isKEM: true,
	}

	// PqNK is the pqNK interactive (fundemental) pattern.
	PqNK Pattern = &builtIn{
		name: "pqNK",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_skem, Token_e},
			{Token_ekem},
		},
		isKEM: true,
	}

	// PqNX is the pqNX interactive (fundemental) pattern.
	PqNX Pattern = &builtIn{
		name: "pqNX",
		messages: []Message{
			{Token_e},
			{Token_ekem, Token_s},
			{Token_skem},
		},
		isKEM: true,
	}

	// PqXN is the pqXN interactive (fundemental) pattern.
	PqXN Pattern = &builtIn{
		name: "pqXN",
		messages: []Message{
			{Token_e},
			{Token_ekem},
			{Token_s},
			{Token_skem},
		},
		isKEM: true,
	}

	// PqXK is the pqXK interactive (fundemental) pattern.
	PqXK Pattern = &builtIn{
		name: "pqXK",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_skem, Token_e},
			{Token_ekem},
			{Token_s},
			{Token_skem},
		},
		isKEM: true,
	}

	// PqXX is the pqXX interactive (fundemental) pattern.
	PqXX Pattern = &builtIn{
		name: "pqXX",
		messages: []Message{
			{Token_e},
			{Token_ekem, Token_s},
			{Token_skem, Token_s},
			{Token_skem},
		},
		isKEM: true,
	}

	// PqKN is the pqKN interactive (fundemental) pattern.
	PqKN Pattern = &builtIn{
		name: "pqKN",
		preMessages: []Message{
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_ekem, Token_skem},
		},
		isKEM: true,
	}

	// PqKK is the pqKK interactive (fundemental) pattern.
	PqKK Pattern = &builtIn{
		name: "pqKK",
		preMessages: []Message{
			{Token_s},
			{Token_s},
		},
		messages: []Message{
			{Token_skem, Token_e},
			{Token_ekem, Token_skem},
		},
		isKEM: true,
	}

	// PqKX is the pqKX interactive (fundemental) pattern.
	PqKX Pattern = &builtIn{
		name: "pqKX",
		preMessages: []Message{
			{Token_s},
		},
		messages: []Message{
			{Token_e},
			{Token_ekem, Token_skem, Token_s},
			{Token_skem},
		},
		isKEM: true,
	}

	// PqIN is the pqIN interactive (fundemental) pattern.
	PqIN Pattern = &builtIn{
		name: "pqIN",
		messages: []Message{
			{Token_e, Token_s},
			{Token_ekem, Token_skem},
		},
		isKEM: true,
	}

	// PqIK is the pqIK interactive (fundemental) pattern.
	PqIK Pattern = &builtIn{
		name: "pqIK",
		preMessages: []Message{
			nil,
			{Token_s},
		},
		messages: []Message{
			{Token_skem, Token_e, Token_s},
			{Token_ekem, Token_skem},
		},
		isKEM: true,
	}

	// PqIX is the PqIX interactive (fundemental) pattern.
	PqIX Pattern = &builtIn{
		name: "pqIX",
		messages: []Message{
			{Token_e, Token_s},
			{Token_ekem, Token_skem, Token_s},
			{Token_skem},
		},
		isKEM: true,
	}
)

var PqN Pattern = &builtIn{
	name: "pqN",
	preMessages: []Message{
		nil,
		{Token_s},
	},
	messages: []Message{
		{Token_skem},
	},
	isKEM: true,
}

PqN is the pqN one-way pattern.

func FromString

func FromString(s string) Pattern

FromString returns a Pattern by pattern name, or nil.

func MakePSK

func MakePSK(template Pattern, modifier string) (Pattern, error)

MakePSK applies `psk` modifiers to an existing pattern, returning the new pattern.

type Token

type Token uint8

Token is a Noise handshake pattern token.

const (
	Token_invalid Token = iota
	Token_e
	Token_s

	// DH
	Token_ee
	Token_es
	Token_se
	Token_ss

	// KEM
	Token_ekem
	Token_skem

	Token_psk
)

func (Token) String

func (t Token) String() string

String returns the string representation of a Token.