noise

type Cipher interface {
	// Encrypt encrypts the provided plaintext with a nonce and then appends the
	// ciphertext to out along with an authentication tag over the ciphertext
	// and optional authenticated data.
	Encrypt(out []byte, n uint64, ad, plaintext []byte) []byte

	// Decrypt authenticates the ciphertext and optional authenticated data and
	// then decrypts the provided ciphertext using the provided nonce and
	// appends it to out.
	Decrypt(out []byte, n uint64, ad, ciphertext []byte) ([]byte, error)
}

type CipherFunc interface {
	// Cipher initializes the algorithm with the provided key and returns a Cipher.
	Cipher(k [32]byte) Cipher

	// CipherName is the name of the cipher.
	CipherName() string
}

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

type CipherSuite interface {
	DHFunc
	CipherFunc
	HashFunc
	HFSFunc
	Name() []byte
}

type Config struct {
	// CipherSuite is the set of cryptographic primitives that will be used.
	CipherSuite CipherSuite

	// Random is the source for cryptographically appropriate random bytes. If
	// zero, it is automatically configured.
	Random io.Reader

	// Pattern is the pattern for the handshake.
	Pattern HandshakePattern

	// Initiator must be true if the first message in the handshake will be sent
	// by this peer.
	Initiator bool

	// Prologue is an optional message that has already be communicated and must
	// be identical on both sides for the handshake to succeed.
	Prologue []byte

	// PresharedKey is the optional preshared key for the handshake.
	PresharedKey []byte

	// PresharedKeyPlacement specifies the placement position of the PSK token
	// when PresharedKey is specified
	PresharedKeyPlacement int

	// StaticKeypair is this peer's static keypair, required if part of the
	// handshake.
	StaticKeypair DHKey

	// EphemeralKeypair is this peer's ephemeral keypair that was provided as
	// a pre-message in the handshake.
	EphemeralKeypair DHKey

	// PeerStatic is the static public key of the remote peer that was provided
	// as a pre-message in the handshake.
	PeerStatic []byte

	// PeerEphemeral is the ephemeral public key of the remote peer that was
	// provided as a pre-message in the handshake.
	PeerEphemeral []byte

	// MaxMsgLen is the maximum number of bytes that can be sent in a single
	// Noise message.
	MaxMsgLen int
}

type DHFunc interface {
	// GenerateKeypair generates a new keypair using random as a source of
	// entropy.
	GenerateKeypair(random io.Reader) (DHKey, error)

	// DH performs a Diffie-Hellman calculation between the provided private and
	// public keys and returns the result.
	DH(privkey, pubkey []byte) ([]byte, error)

	// DHLen is the number of bytes returned by DH.
	DHLen() int

	// DHName is the name of the DH function.
	DHName() string
}

type DHKey struct {
	Private []byte
	Public  []byte
}

type HFSDecapsulationKey interface {
	DecapsulateTo(sharedSecret, ciphertext []byte)
}

type HFSFunc interface {
	// GenerateKEMKeypair generates a new KEM key pair.
	GenerateKEMKeypair(rng io.Reader) HFSKeyPair

	// GenerateKEMCiphertext generates both a ciphertext
	// and a KEM output given the remote party's public key.
	GenerateKEMCiphertext(pubkey []byte, rng io.Reader) (ciphertext, sharedSecret []byte)

	// KEM performs calculation between the private key in the key pair
	// and the ciphertext and returns a sharedSecret.
	KEM(keyPair HFSKeyPair, ciphertext []byte) (sharedSecret []byte)

	// PublicKeySize returns the size of the serialized public key.
	PublicKeySize() int

	// CiphertextSize returns the size of the KEM ciphertext.
	CiphertextSize() int

	// SharedKeySize returns the size of the KEM shared secret.
	SharedKeySize() int

	// HFSName is the name of the HFS function.
	HFSName() string
}

type HFSKeyPair interface {
	Public() []byte
	Private() HFSDecapsulationKey
}

type HandshakePattern struct {
	Name                 string
	InitiatorPreMessages []MessagePattern
	ResponderPreMessages []MessagePattern
	Messages             [][]MessagePattern
}

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

type HashFunc interface {
	// Hash returns a hash state.
	Hash() hash.Hash

	// HashName is the name of the hash function.
	HashName() string
}

type MessagePattern int