type Client struct {HTTPClient *http.ClientURL        *url.URL}

funcNew¶

func New(serverURL *url.URL) *Client

New creates a tunneld client for the provided URL.

func (*Client)ClientRegister¶

func (c *Client) ClientRegister(ctxcontext.Context, reqClientRegisterRequest) (ClientRegisterResponse,error)

func (*Client)LaunchTunnel¶

func (c *Client) LaunchTunnel(ctxcontext.Context, cfgTunnelConfig) (*Tunnel,error)

LaunchTunnel makes a request to the tunneld server to register the client'stunnel using the client's public key, then establishes a wireguard connectionto the server and returns a *Tunnel. Connections can be accepted fromtunnel.Listener.

func (*Client)Request¶

func (c *Client) Request(ctxcontext.Context, method, pathstring, body interface{}) (*http.Response,error)

Request performs an HTTP request with the body provided. The caller isresponsible for closing the response body.

type ClientRegisterRequest struct {VersionTunnelVersion         `json:"version"`PublicKeydevice.NoisePublicKey `json:"public_key"`}

type ClientRegisterResponse struct {VersionTunnelVersion `json:"version"`ReregisterWaittime.Duration `json:"reregister_wait"`// TunnelURLs contains a list of valid URLs that will be forwarded from the// server to this tunnel client once connected. The first URL is the// preferred URL, and the other URLs are provided for compatibility// purposes only.//// The order of the URLs changes based on the Version field in the request.TunnelURLs []string   `json:"tunnel_urls"`ClientIPnetip.Addr `json:"client_ip"`ServerEndpointstring                `json:"server_endpoint"`ServerIPnetip.Addr            `json:"server_ip"`ServerPublicKeydevice.NoisePublicKey `json:"server_public_key"`WireguardMTUint                   `json:"wireguard_mtu"`}

type Error struct {Response// contains filtered or unexported fields}

func (*Error)Error¶

func (e *Error) Error()string

func (*Error)Friendly¶

func (e *Error) Friendly()string

func (*Error)StatusCode¶

func (e *Error) StatusCode()int

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

funcFromNoisePrivateKey¶added inv0.1.1

func FromNoisePrivateKey(kdevice.NoisePrivateKey)Key

FromNoisePrivateKey converts a device.NoisePrivateKey to a Key.

funcFromNoisePublicKey¶added inv0.1.1

func FromNoisePublicKey(kdevice.NoisePublicKey)Key

FromNoisePublicKey converts a device.NoisePublicKey to a Key.

funcGeneratePrivateKey¶

func GeneratePrivateKey() (Key,error)

GenerateWireguardPrivateKey generates a new wireguard private key usingsecure cryptography. The caller should store the key (using key.String()) ina safe place like the user's home directory, and use it in the future ratherthan generating a new key each time.

funcParsePrivateKey¶

func ParsePrivateKey(keystring) (Key,error)

ParsePrivateKey parses a private key generated using key.String().

funcParsePublicKey¶added inv0.1.1

func ParsePublicKey(keystring) (Key,error)

ParsePublicKey parses a public key generated using key.String().

func (Key)Hash¶added inv0.1.3

func (kKey) Hash()string

Hash returns the SHA512 hash of the key.

func (Key)HexString¶

func (kKey) HexString()string

HexString returns the hex string representation of the key.

func (Key)IsPrivate¶

func (kKey) IsPrivate()bool

IsPrivate returns true if the key is a private key.

func (Key)IsZero¶

func (kKey) IsZero()bool

IsZero returns true if the Key is the zero value.

func (Key)NoisePrivateKey¶

func (kKey) NoisePrivateKey() (device.NoisePrivateKey,error)

NoisePrivateKey returns the device.NoisePrivateKey for the key. If the key isnot a private key, an error is returned.

func (Key)NoisePublicKey¶

func (kKey) NoisePublicKey()device.NoisePublicKey

NoisePublicKey returns the device.NoisePublicKey for the key. If the key is aprivate key, it is converted to a public key automatically.

func (Key)PublicKey¶

func (kKey) PublicKey() (Key,error)

PublicKey returns the public key component of the Wireguard private key. Ifthe key is not a private key, an error is returned.

func (Key)String¶

func (kKey) String()string

String returns a base64 encoded string representation of the key.

type Response struct {Messagestring `json:"message"`Detailstring `json:"detail,omitempty"`}

type Tunnel struct {URL       *url.URLOtherURLs []*url.URLListenernet.Listener// contains filtered or unexported fields}

func (*Tunnel)Close¶

func (t *Tunnel) Close()error

func (*Tunnel)Wait¶

func (t *Tunnel) Wait() <-chan struct{}

type TunnelConfig struct {Logslog.Logger// Version denotes which version of the tunnel URL specification to use.// Undefined version is treated as the latest version.VersionTunnelVersion// PrivateKey is the Wireguard private key. You can use GeneratePrivateKey// to generate a new key. It should be stored in a safe place for future// tunnel sessions, otherwise you will get a new hostname.PrivateKeyKey}

type TunnelVersionint