client

package
v0.0.0-...-9e52cca Latest Latest
Warning

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

 Go to latest Published: Mar 13, 2023 License: GPL-3.0, GPL-3.0 Imports: 35 Imported by: 1

README

Meson-client

Client

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

Source Files

View all Source files

Directories

Path Synopsis
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
 Package pkiclient implements a caching wrapper
epochtime

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.