noisecat

Documentation

Index

• Constants
• Variables
• func GenerateKeypair(dh, cipher, hash byte) ([]byte, error)
• type Config
  • func (config *Config) ParseConfig() (*noise.Config, error)
• type NoiseInterface
• type Noisecat
  • func (n *Noisecat) StartClient()
  • func (n *Noisecat) StartServer()
• type Params
  • func (c *Params) Router()
• type Progress
• type Verbose
  • func (l Verbose) Fatalf(format string, v ...interface{})
  • func (l Verbose) Verb(format string, v ...interface{})

Constants

const (
	NOISE_DH_CURVE25519 = 1
	NOISE_DH_CURVE448   = 2

	NOISE_CIPHER_CHACHAPOLY = 1
	NOISE_CIPHER_AESGCM     = 2

	NOISE_HASH_BLAKE2s = 1
	NOISE_HASH_BLAKE2b = 2
	NOISE_HASH_SHA256  = 3
	NOISE_HASH_SHA512  = 4

	NOISE_PATTERN_NN = 4
	NOISE_PATTERN_NK = 5
	NOISE_PATTERN_NX = 6
	NOISE_PATTERN_XN = 7
	NOISE_PATTERN_XK = 8
	NOISE_PATTERN_XX = 9
	NOISE_PATTERN_KN = 10
	NOISE_PATTERN_KK = 11
	NOISE_PATTERN_KX = 12
	NOISE_PATTERN_IN = 13
	NOISE_PATTERN_IK = 14
	NOISE_PATTERN_IX = 15
)

Variables

var CipherByteObj = map[byte]noise.CipherFunc{
	NOISE_CIPHER_CHACHAPOLY: noise.CipherChaChaPoly,
	NOISE_CIPHER_AESGCM:     noise.CipherAESGCM,
}

var CipherStrByte = map[string]byte{
	"ChaChaPoly": NOISE_CIPHER_CHACHAPOLY,
	"AESGCM":     NOISE_CIPHER_AESGCM,
}

Cipher Funcs

var DHByteObj = map[byte]noise.DHFunc{
	NOISE_DH_CURVE25519: noise.DH25519,
}

var DHStrByte = map[string]byte{
	"25519": NOISE_DH_CURVE25519,
}

DH Funcs

var HashByteObj = map[byte]noise.HashFunc{
	NOISE_HASH_BLAKE2s: noise.HashBLAKE2s,
	NOISE_HASH_BLAKE2b: noise.HashBLAKE2b,
	NOISE_HASH_SHA256:  noise.HashSHA256,
	NOISE_HASH_SHA512:  noise.HashSHA512,
}

var HashStrByte = map[string]byte{
	"BLAKE2s": NOISE_HASH_BLAKE2s,
	"BLAKE2b": NOISE_HASH_BLAKE2b,
	"SHA256":  NOISE_HASH_SHA256,
	"SHA512":  NOISE_HASH_SHA512,
}

Hash Funcs

var PatternByteObj = map[byte]noise.HandshakePattern{
	NOISE_PATTERN_NN: noise.HandshakeNN,
	NOISE_PATTERN_NK: noise.HandshakeNK,
	NOISE_PATTERN_NX: noise.HandshakeNX,
	NOISE_PATTERN_XN: noise.HandshakeXN,
	NOISE_PATTERN_XK: noise.HandshakeXK,
	NOISE_PATTERN_XX: noise.HandshakeXX,
	NOISE_PATTERN_KN: noise.HandshakeKN,
	NOISE_PATTERN_KK: noise.HandshakeKK,
	NOISE_PATTERN_KX: noise.HandshakeKX,
	NOISE_PATTERN_IN: noise.HandshakeIN,
	NOISE_PATTERN_IK: noise.HandshakeIK,
	NOISE_PATTERN_IX: noise.HandshakeIX,
}

var PatternStrByte = map[string]byte{
	"NN": NOISE_PATTERN_NN,
	"NL": NOISE_PATTERN_NK,
	"NX": NOISE_PATTERN_NX,
	"XN": NOISE_PATTERN_XN,
	"XK": NOISE_PATTERN_XK,
	"XX": NOISE_PATTERN_XX,
	"KN": NOISE_PATTERN_KN,
	"KK": NOISE_PATTERN_KK,
	"KX": NOISE_PATTERN_KX,
	"IN": NOISE_PATTERN_IN,
	"IK": NOISE_PATTERN_IK,
	"IX": NOISE_PATTERN_IX,
}

Handshake Patterns

Functions

func GenerateKeypair

func GenerateKeypair(dh, cipher, hash byte) ([]byte, error)

GenerateKeypair generates and outputs private and public keys based on the provided functions

Types

type Config

type Config struct {
	SrcPort string
	SrcHost string
	DstPort string
	DstHost string

	ExecuteCmd string
	Proxy      string
	Listen     bool
	Verbose    bool
	Daemon     bool
	Keygen     bool

	Protocol   string
	Pattern    byte
	DHFunc     byte
	CipherFunc byte
	HashFunc   byte

	PSK     string
	RStatic string
	LStatic string
}

Config parameters

func (*Config) ParseConfig

func (config *Config) ParseConfig() (*noise.Config, error)

ParseConfig parses a configuration struct for setup and correctness

type NoiseInterface

type NoiseInterface interface {
	GetLocalStaticPublic() []byte
}

NoiseInterface intrfaces with noise configurations

type Noisecat

type Noisecat struct {
	Config      *Config
	NoiseConfig *noise.Config
	Log         Verbose
}

Noisecat defines the main network configuration

func (*Noisecat) StartClient

func (n *Noisecat) StartClient()

StartClient starts a noisecat client

func (*Noisecat) StartServer

func (n *Noisecat) StartServer()

StartServer starts a noisecat server

type Params

type Params struct {
	Conn       net.Conn
	Proxy      string
	ExecuteCmd string
	Log        Verbose
}

Params type defines the parameters required by the runners

func (*Params) Router

func (c *Params) Router()

Router routes a connection based on provided parameters

type Progress

type Progress struct {
	Bytes int64
	Dir   string
}

Progress struct

type Verbose

type Verbose bool

Verbose is a logging facility

func (Verbose) Fatalf

func (l Verbose) Fatalf(format string, v ...interface{})

Fatalf prints a messager if Log is true and exits with an error code

func (Verbose) Verb

func (l Verbose) Verb(format string, v ...interface{})

Verb prints a line if Log is true