client

package module
v0.0.0-...-3619da3 Latest Latest
Warning

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

Go to latest
Published: Jan 24, 2022 License: GPL-3.0 Imports: 34 Imported by: 0

README

Meson-client

Go

A simple client for use with the Meson mixnet software

Tests

Since this library requires to connect to an existing katzenpost mixnet one needs to run the tests inside of a docker container and connect to the mixnet docker network. You can run a mixnet by following the instructions at https://github.com/hashcloak/Meson

docker run --rm \
  -v `pwd`:/client \
  --network nonvoting_testnet_nonvoting_test_net \
  -v /tmp/gopath-pkg:/go/pkg \
  -w /client \
  golang:buster \
  /bin/bash -c "GORACE=history_size=7 go test -race"

The above can be de-constructed as follows:

  • -v `pwd`:/client: Mount the current directory inside the docker container at /client
  • --network nonvoting_testnet_nonvoting_test_net: Connect to the existing docker network mixnet
  • -v /tmp/gopath-pkg:/go/pkg: Cache the go modules that belong to this container in /tmp/gopath-pkg
  • -w /client: Working directory for the docker image
  • golang:buster: The docker image to be used
  • /bin/bash -c "GORACE=history_size=7 go test -race": The command to run inside the container

Documentation

Overview

Package client provides a thin-wrapper of the Katzenpost client library for cryptocurrency transactions.

Index

Constants

This section is empty.

Variables

View Source
var ErrMessageNotSent = errors.New("failure sending message")
View Source
var ErrQueueEmpty = errors.New("queue is empty")

ErrQueueEmpty is the error issued when the queue is empty.

View Source
var ErrQueueFull = errors.New("queue is full")

ErrQueueFull is the error issued when the queue is full.

View Source
var ErrReplyTimeout = errors.New("failure waiting for reply, timeout reached")

Functions

func AutoRegisterRandomClient

func AutoRegisterRandomClient(cfg *config.Config) *ecdh.PrivateKey

func RegisterClient

func RegisterClient(cfg *config.Config, linkKey *ecdh.PublicKey) error

func ValidateReply

func ValidateReply(reply []byte) ([]byte, error)

Types

type Client

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

func New

func New(cfg *config.Config, service string) (*Client, error)

New instantiates a new Meson client with the provided configuration file and service that represents the chain it's being used for. It returns a Client struct pointer and any errors encountered.

func NewFromConfig

func NewFromConfig(cfg *config.Config, service string) (*Client, error)

New instantiates a new Meson client with the provided configuration

func (*Client) GetBackendLog

func (c *Client) GetBackendLog() *log.Backend

func (*Client) GetLogger

func (c *Client) GetLogger(name string) *logging.Logger

GetLogger returns a new logger with the given name.

func (*Client) InitLogging

func (c *Client) InitLogging() error

InitLogging provides logging for the meson client It returns any errors it encounters.

func (*Client) NewSession

func (c *Client) NewSession(linkKey *ecdh.PrivateKey) (*Session, error)

New establishes a session with provider using key. This method will block until session is connected to the Provider.

func (*Client) Shutdown

func (c *Client) Shutdown()

Shutdown cleanly shuts down a given Client instance.

func (*Client) Start

func (c *Client) Start() error

Start begins a Meson client. The client retrieves PKI consensus documents in order to get a view of the network and connect to a provider. It returns an error if they were any issues starting the client.

func (*Client) Wait

func (c *Client) Wait()

Wait waits till the Client is terminated for any reason.

type ConnectionStatusEvent

type ConnectionStatusEvent struct {
	// IsConnected is true iff the account is connected to the provider.
	IsConnected bool

	// Err is the error encountered when connecting or by the connection if any.
	Err error
}

ConnectionStatusEvent is the event sent when an account's connection status changes.

func (*ConnectionStatusEvent) String

func (e *ConnectionStatusEvent) String() string

String returns a string representation of the ConnectionStatusEvent.

type EgressQueue

type EgressQueue interface {

	// Peek returns the next queue item without modifying the queue.
	Peek() (Item, error)

	// Pop pops the next item off the queue.
	Pop() (Item, error)

	// Push pushes the item onto the queue.
	Push(Item) error
}

EgressQueue is the egress queue interface.

type Event

type Event interface {
	// String returns a string representation of the Event.
	String() string
}

Event is the generic event sent over the event listener channel.

type Item

type Item interface {
	Priority() uint64
}

type Message

type Message struct {
	// ID is the message identifier
	ID *[cConstants.MessageIDLength]byte

	// Recipient is the message recipient
	Recipient string

	// Provider is the recipient Provider
	Provider string

	// Payload is the message payload
	Payload []byte

	// SentAt contains the time the message was sent.
	SentAt time.Time

	// ReplyETA is the expected round trip time to receive a response.
	ReplyETA time.Duration

	// IsBlocking indicates whether or not the client is blocking on the
	// sending of the query and the receiving of it's reply.
	IsBlocking bool

	// SURBID is the SURB identifier.
	SURBID *[sConstants.SURBIDLength]byte

	// Key is the SURB decryption keys
	Key []byte

	// Reply is the SURB reply
	Reply []byte

	// WithSURB specified if a SURB should be bundled with the forward payload.
	WithSURB bool

	// Specifies if this message is a decoy.
	IsDecoy bool

	// Priority controls the dwell time in the current AQM.
	QueuePriority uint64
}

Message is a message reference which is used to match future received SURB replies.

func (*Message) Priority

func (m *Message) Priority() uint64

type MessageIDGarbageCollected

type MessageIDGarbageCollected struct {
	// MessageID is the local unique identifier for the message.
	MessageID *[cConstants.MessageIDLength]byte
}

MessageIDGarbageCollected is the event used to signal when a given message ID has been garbage collected.

func (*MessageIDGarbageCollected) String

func (e *MessageIDGarbageCollected) String() string

String returns a string representation of a MessageIDGarbageCollected.

type MessageReplyEvent

type MessageReplyEvent struct {
	// MessageID is the unique identifier for the request associated with the
	// reply.
	MessageID *[cConstants.MessageIDLength]byte

	// Payload is the reply payload if any.
	Payload []byte

	// Err is the error encountered when servicing the request if any.
	Err error
}

MessageReplyEvent is the event sent when a new message is received.

func (*MessageReplyEvent) String

func (e *MessageReplyEvent) String() string

String returns a string representation of the MessageReplyEvent.

type MessageSentEvent

type MessageSentEvent struct {
	// MessageID is the local unique identifier for the message, generated
	// when the message was enqueued.
	MessageID *[cConstants.MessageIDLength]byte

	// SentAt contains the time the message was sent.
	SentAt time.Time

	// ReplyETA is the expected round trip time to receive a response.
	ReplyETA time.Duration

	// Err is the error encountered when sending the message if any.
	Err error
}

MessageSentEvent is the event sent when a message has been fully transmitted.

func (*MessageSentEvent) String

func (e *MessageSentEvent) String() string

String returns a string representation of a MessageSentEvent.

type NewDocumentEvent

type NewDocumentEvent struct {
	Document *pki.Document
}

NewDocumentEvent is the new document event, signaling that we have received a new document from the PKI.

func (*NewDocumentEvent) String

func (e *NewDocumentEvent) String() string

String returns a string representation of a NewDocumentEvent.

type Queue

type Queue struct {
	sync.Mutex
	// contains filtered or unexported fields
}

Queue is our in-memory queue implementation used as our egress FIFO queue for messages sent by the client.

func (*Queue) Peek

func (q *Queue) Peek() (Item, error)

Peek returns the next message ref from the queue without modifying the queue.

func (*Queue) Pop

func (q *Queue) Pop() (Item, error)

Pop pops the next message ref off the queue and returns nil upon success, otherwise an error is returned.

func (*Queue) Push

func (q *Queue) Push(e Item) error

Push pushes the given message ref onto the queue and returns nil on success, otherwise an error is returned.

type Session

type Session struct {
	worker.Worker

	EventSink chan Event
	// contains filtered or unexported fields
}

Session is the struct type that keeps state for a given session.

func NewSession

func NewSession(
	ctx context.Context,
	fatalErrCh chan error,
	logBackend *log.Backend,
	cfg *config.Config,
	linkKey *ecdh.PrivateKey) (*Session, error)

New establishes a session with provider using key. This method will block until session is connected to the Provider.

func (*Session) BlockingSendUnreliableMessage

func (s *Session) BlockingSendUnreliableMessage(recipient, provider string, message []byte) ([]byte, error)

func (*Session) CurrentDocument

func (s *Session) CurrentDocument() *cpki.Document

func (*Session) GetPandaConfig

func (s *Session) GetPandaConfig() *config.Panda

func (*Session) GetReunionConfig

func (s *Session) GetReunionConfig() *config.Reunion

func (*Session) GetService

func (s *Session) GetService(serviceName string) (*utils.ServiceDescriptor, error)

GetService returns a randomly selected service matching the specified service name

func (*Session) SendUnreliableMessage

func (s *Session) SendUnreliableMessage(recipient, provider string, message []byte) (*[cConstants.MessageIDLength]byte, error)

SendUnreliableMessage asynchronously sends message without any automatic retransmissions.

func (*Session) Shutdown

func (s *Session) Shutdown()

type TimerQueue

type TimerQueue struct {
	sync.Mutex
	sync.Cond
	worker.Worker
	// contains filtered or unexported fields
}

TimerQueue is a queue that delays messages before forwarding to another queue

func NewTimerQueue

func NewTimerQueue(nextQueue nqueue) *TimerQueue

NewTimerQueue intantiates a new TimerQueue and starts the worker routine

func (*TimerQueue) Push

func (a *TimerQueue) Push(i Item)

Push adds a message to the TimerQueue

func (*TimerQueue) Remove

func (a *TimerQueue) Remove(i Item) error

Remove removes a Message from the TimerQueue

Directories

Path Synopsis
cmd
Package config implements the configuration for the Katzenpost client.
Package config implements the configuration for the Katzenpost client.
internal
proxy
Package proxy implements the support for an upstream (outgoing) proxy.
Package proxy implements the support for an upstream (outgoing) proxy.
Package minclient provides a minimal Katzenpost client.
Package minclient provides a minimal Katzenpost client.
Package pkiclient implements a caching wrapper katzenmint pkiclient interface
Package pkiclient implements a caching wrapper katzenmint pkiclient interface

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL