sam3

package module
v0.33.92 Latest Latest
Warning

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

 Go to latest Published: Nov 16, 2024 License: Unlicense Imports: 17 Imported by: 3

README

README

STATUS: This project is maintained. I will respond to issues, pull requests, and feature requests within a few days.

Go Report Card

README

go library for the I2P SAMv3.0 bridge, used to build anonymous/pseudonymous end-to-end encrypted sockets.

This library is much better than ccondom (that use BOB), much more stable and much easier to maintain.

Support/TODO

What works:

  • Utils
    • Resolving domain names to I2P destinations
    • .b32.i2p hashes
    • Generating keys/i2p destinations
  • Streaming
    • DialI2P() - Connecting to stuff in I2P
    • Listen()/Accept() - Handling incomming connections
    • Implements net.Conn and net.Listener
  • Datagrams
    • Implements net.PacketConn
  • Raw datagrams
    • Like datagrams, but without addresses

Does not work:

  • Stream Forwarding
  • Probably needs some real-world testing

Documentation

  • Latest version-documentation:
    • set your GOPATH
    • Enter godoc -http=:8081 into your terminal and hit enter.
    • Goto http://localhost:8081, click packages, and navigate to sam3

Examples

package main

import (
	"github.com/go-i2p/sam3"
	"github.com/go-i2p/sam3/i2pkeys"
	"fmt"
)

const yoursam = "127.0.0.1:7656" // sam bridge

func client(server i2pkeys.I2PAddr) {
	sam, _ := sam3.NewSAM(yoursam)
	keys, _ := sam.NewKeys()
	stream, _ := sam.NewStreamSession("clientTun", keys, sam3.Options_Small)
	fmt.Println("Client: Connecting to " + server.Base32())
	conn, _ := stream.DialI2P(server)
	conn.Write([]byte("Hello world!"))
	return
}

func main() {
	sam, _ := NewSAM(yoursam)
	keys, _ := sam.NewKeys()
	stream, _ := sam.NewStreamSession("serverTun", keys, sam3.Options_Medium)
	listener, _ := stream.Listen()
	go client(keys.Addr())
	conn, _ := listener.Accept()
	buf := make([]byte, 4096)
	n, _ := conn.Read(buf)
	fmt.Println("Server received: " + string(buf[:n]))
}

The above will write to the terminal:

Client: Connecting to zjnvfh4hs3et5vtz35ogwzrws26zvwkcad5uo5esecvg4qpk5b4a.b32.i2p
Server received: Hello world!

Error handling was omitted in the above code for readability.

Testing

  • go test -tags=nettest runs the whole suite (takes 90+ sec to perform!)
  • go test -short runs the shorter variant, does not connect to anything

Verbosity

Logging can be enabled and configured using the DEBUG_I2P environment variable. By default, logging is disabled.

There are three available log levels:

  • Debug
export DEBUG_I2P=debug
  • Warn
export DEBUG_I2P=warn
  • Error
export DEBUG_I2P=error

If DEBUG_I2P is set to an unrecognized variable, it will fall back to "debug".

License

Public domain.

Author

Documentation

Overview

Library for I2Ps SAMv3 bridge (https://geti2p.com)

Index

Examples

Constants

View Source 
const (
	Sig_NONE                 = "SIGNATURE_TYPE=EdDSA_SHA512_Ed25519"
	Sig_DSA_SHA1             = "SIGNATURE_TYPE=DSA_SHA1"
	Sig_ECDSA_SHA256_P256    = "SIGNATURE_TYPE=ECDSA_SHA256_P256"
	Sig_ECDSA_SHA384_P384    = "SIGNATURE_TYPE=ECDSA_SHA384_P384"
	Sig_ECDSA_SHA512_P521    = "SIGNATURE_TYPE=ECDSA_SHA512_P521"
	Sig_EdDSA_SHA512_Ed25519 = "SIGNATURE_TYPE=EdDSA_SHA512_Ed25519"
)

Variables

View Source 
var (
	// Suitable options if you are shuffling A LOT of traffic. If unused, this
	// will waste your resources.
	Options_Humongous = []string{"inbound.length=3", "outbound.length=3",
		"inbound.lengthVariance=1", "outbound.lengthVariance=1",
		"inbound.backupQuantity=3", "outbound.backupQuantity=3",
		"inbound.quantity=6", "outbound.quantity=6"}

	// Suitable for shuffling a lot of traffic.
	Options_Large = []string{"inbound.length=3", "outbound.length=3",
		"inbound.lengthVariance=1", "outbound.lengthVariance=1",
		"inbound.backupQuantity=1", "outbound.backupQuantity=1",
		"inbound.quantity=4", "outbound.quantity=4"}

	// Suitable for shuffling a lot of traffic quickly with minimum
	// anonymity. Uses 1 hop and multiple tunnels.
	Options_Wide = []string{"inbound.length=1", "outbound.length=1",
		"inbound.lengthVariance=1", "outbound.lengthVariance=1",
		"inbound.backupQuantity=2", "outbound.backupQuantity=2",
		"inbound.quantity=3", "outbound.quantity=3"}

	// Suitable for shuffling medium amounts of traffic.
	Options_Medium = []string{"inbound.length=3", "outbound.length=3",
		"inbound.lengthVariance=1", "outbound.lengthVariance=1",
		"inbound.backupQuantity=0", "outbound.backupQuantity=0",
		"inbound.quantity=2", "outbound.quantity=2"}

	// Sensible defaults for most people
	Options_Default = []string{"inbound.length=3", "outbound.length=3",
		"inbound.lengthVariance=0", "outbound.lengthVariance=0",
		"inbound.backupQuantity=1", "outbound.backupQuantity=1",
		"inbound.quantity=1", "outbound.quantity=1"}

	// Suitable only for small dataflows, and very short lasting connections:
	// You only have one tunnel in each direction, so if any of the nodes
	// through which any of your two tunnels pass through go offline, there will
	// be a complete halt in the dataflow, until a new tunnel is built.
	Options_Small = []string{"inbound.length=3", "outbound.length=3",
		"inbound.lengthVariance=1", "outbound.lengthVariance=1",
		"inbound.backupQuantity=0", "outbound.backupQuantity=0",
		"inbound.quantity=1", "outbound.quantity=1"}

	// Does not use any anonymization, you connect directly to others tunnel
	// endpoints, thus revealing your identity but not theirs. Use this only
	// if you don't care.
	Options_Warning_ZeroHop = []string{"inbound.length=0", "outbound.length=0",
		"inbound.lengthVariance=0", "outbound.lengthVariance=0",
		"inbound.backupQuantity=0", "outbound.backupQuantity=0",
		"inbound.quantity=2", "outbound.quantity=2"}
)

Examples and suggestions for options when creating sessions.

View Source 
var PrimarySessionSwitch string = PrimarySessionString()
View Source 
var SAM_HOST = getEnv("sam_host", "127.0.0.1")
View Source 
var SAM_PORT = getEnv("sam_port", "7656")

Functions

func ExtractDest 

func ExtractDest(input string) string

func ExtractPairInt 

func ExtractPairInt(input, value string) int

func ExtractPairString 

func ExtractPairString(input, value string) string

func GenerateOptionString 

func GenerateOptionString(opts []string) string

func GetSAM3Logger 

func GetSAM3Logger() *logrus.Logger

GetSAM3Logger returns the initialized logger

func IgnorePortError 

func IgnorePortError(err error) error

func InitializeSAM3Logger 

func InitializeSAM3Logger()

func PrimarySessionString 

func PrimarySessionString() string

func RandString 

func RandString() string

func SAMDefaultAddr 

func SAMDefaultAddr(fallforward string) string

func SetAccessList 

func SetAccessList(s []string) func(*SAMEmit) error

SetAccessList tells the system to treat the AccessList as a whitelist

func SetAccessListType 

func SetAccessListType(s string) func(*SAMEmit) error

SetAccessListType tells the system to treat the AccessList as a whitelist

func SetAllowZeroIn 

func SetAllowZeroIn(b bool) func(*SAMEmit) error

SetAllowZeroIn tells the tunnel to accept zero-hop peers

func SetAllowZeroOut 

func SetAllowZeroOut(b bool) func(*SAMEmit) error

SetAllowZeroOut tells the tunnel to accept zero-hop peers

func SetCloseIdle 

func SetCloseIdle(b bool) func(*SAMEmit) error

SetCloseIdle tells the connection to close it's tunnels during extended idle time.

func SetCloseIdleTime 

func SetCloseIdleTime(u int) func(*SAMEmit) error

SetCloseIdleTime sets the time to wait before closing tunnels to idle levels

func SetCloseIdleTimeMs 

func SetCloseIdleTimeMs(u int) func(*SAMEmit) error

SetCloseIdleTimeMs sets the time to wait before closing tunnels to idle levels in milliseconds

func SetCompress 

func SetCompress(b bool) func(*SAMEmit) error

SetCompress tells clients to use compression

func SetEncrypt 

func SetEncrypt(b bool) func(*SAMEmit) error

SetEncrypt tells the router to use an encrypted leaseset

func SetFastRecieve 

func SetFastRecieve(b bool) func(*SAMEmit) error

SetFastRecieve tells clients to use compression

func SetInBackups 

func SetInBackups(u int) func(*SAMEmit) error

SetInBackups sets the inbound tunnel backups

func SetInLength 

func SetInLength(u int) func(*SAMEmit) error

SetInLength sets the number of hops inbound

func SetInQuantity 

func SetInQuantity(u int) func(*SAMEmit) error

SetInQuantity sets the inbound tunnel quantity

func SetInVariance 

func SetInVariance(i int) func(*SAMEmit) error

SetInVariance sets the variance of a number of hops inbound

func SetLeaseSetKey 

func SetLeaseSetKey(s string) func(*SAMEmit) error

SetLeaseSetKey sets the host of the SAMEmit's SAM bridge

func SetLeaseSetPrivateKey 

func SetLeaseSetPrivateKey(s string) func(*SAMEmit) error

SetLeaseSetPrivateKey sets the host of the SAMEmit's SAM bridge

func SetLeaseSetPrivateSigningKey 

func SetLeaseSetPrivateSigningKey(s string) func(*SAMEmit) error

SetLeaseSetPrivateSigningKey sets the host of the SAMEmit's SAM bridge

func SetMessageReliability 

func SetMessageReliability(s string) func(*SAMEmit) error

SetMessageReliability sets the host of the SAMEmit's SAM bridge

func SetName 

func SetName(s string) func(*SAMEmit) error

SetName sets the host of the SAMEmit's SAM bridge

func SetOutBackups 

func SetOutBackups(u int) func(*SAMEmit) error

SetOutBackups sets the inbound tunnel backups

func SetOutLength 

func SetOutLength(u int) func(*SAMEmit) error

SetOutLength sets the number of hops outbound

func SetOutQuantity 

func SetOutQuantity(u int) func(*SAMEmit) error

SetOutQuantity sets the outbound tunnel quantity

func SetOutVariance 

func SetOutVariance(i int) func(*SAMEmit) error

SetOutVariance sets the variance of a number of hops outbound

func SetReduceIdle 

func SetReduceIdle(b bool) func(*SAMEmit) error

SetReduceIdle tells the connection to reduce it's tunnels during extended idle time.

func SetReduceIdleQuantity 

func SetReduceIdleQuantity(u int) func(*SAMEmit) error

SetReduceIdleQuantity sets minimum number of tunnels to reduce to during idle time

func SetReduceIdleTime 

func SetReduceIdleTime(u int) func(*SAMEmit) error

SetReduceIdleTime sets the time to wait before reducing tunnels to idle levels

func SetReduceIdleTimeMs 

func SetReduceIdleTimeMs(u int) func(*SAMEmit) error

SetReduceIdleTimeMs sets the time to wait before reducing tunnels to idle levels in milliseconds

func SetSAMAddress 

func SetSAMAddress(s string) func(*SAMEmit) error

SetSAMAddress sets the SAM address all-at-once

func SetSAMHost 

func SetSAMHost(s string) func(*SAMEmit) error

SetSAMHost sets the host of the SAMEmit's SAM bridge

func SetSAMPort 

func SetSAMPort(s string) func(*SAMEmit) error

SetSAMPort sets the port of the SAMEmit's SAM bridge using a string

func SetType 

func SetType(s string) func(*SAMEmit) error

SetType sets the type of the forwarder server

func SplitHostPort 

func SplitHostPort(hostport string) (string, string, error)

Types

type Config 

type Config struct {
	Addr    string
	Opts    Options
	Session string
	Keyfile string
}

Config is the config type for the sam connector api for i2p which allows applications to 'speak' with i2p

func (*Config) DatagramSession 

func (cfg *Config) DatagramSession() (session *DatagramSession, err error)

create new sam datagram session from config

func (*Config) StreamSession 

func (cfg *Config) StreamSession() (session *StreamSession, err error)

create new sam connector from config with a stream session

type DatagramSession 

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

The DatagramSession implements net.PacketConn. It works almost like ordinary UDP, except that datagrams may be at most 31kB large. These datagrams are also end-to-end encrypted, signed and includes replay-protection. And they are also built to be surveillance-resistant (yey!).

Example 
// Creates a new DatagramSession, which behaves just like a net.PacketConn.

const samBridge = "127.0.0.1:7656"

sam, err := NewSAM(samBridge)
if err != nil {
	fmt.Println(err.Error())
	return
}
keys, err := sam.NewKeys()
if err != nil {
	fmt.Println(err.Error())
	return
}
myself := keys.Addr()

// See the example Option_* variables.
dg, err := sam.NewDatagramSession("DGTUN", keys, Options_Small, 0)
if err != nil {
	fmt.Println(err.Error())
	return
}
someone, err := sam.Lookup("zzz.i2p")
if err != nil {
	fmt.Println(err.Error())
	return
}

dg.WriteTo([]byte("Hello stranger!"), someone)
dg.WriteTo([]byte("Hello myself!"), myself)

buf := make([]byte, 31*1024)
n, _, err := dg.ReadFrom(buf)
if err != nil {
	fmt.Println(err.Error())
	return
}
fmt.Println("Got message: '" + string(buf[:n]) + "'")
fmt.Println("Got message: " + string(buf[:n]))

return

Output:

Got message: Hello myself!

func (*DatagramSession) Accept 

func (s *DatagramSession) Accept() (net.Conn, error)

func (*DatagramSession) Addr 

func (s *DatagramSession) Addr() net.Addr

func (*DatagramSession) B32 

func (s *DatagramSession) B32() string

func (*DatagramSession) Close 

func (s *DatagramSession) Close() error

Closes the DatagramSession. Implements net.PacketConn

func (*DatagramSession) Dial 

func (s *DatagramSession) Dial(net string, addr string) (*DatagramSession, error)

func (*DatagramSession) DialI2PRemote 

func (s *DatagramSession) DialI2PRemote(net string, addr net.Addr) (*DatagramSession, error)

func (*DatagramSession) DialRemote 

func (s *DatagramSession) DialRemote(net, addr string) (net.PacketConn, error)

func (*DatagramSession) LocalAddr 

func (s *DatagramSession) LocalAddr() net.Addr

Implements net.PacketConn

func (*DatagramSession) LocalI2PAddr 

func (s *DatagramSession) LocalI2PAddr() i2pkeys.I2PAddr

Returns the I2P destination of the DatagramSession.

func (*DatagramSession) Lookup 

func (s *DatagramSession) Lookup(name string) (a net.Addr, err error)

func (*DatagramSession) Read 

func (s *DatagramSession) Read(b []byte) (n int, err error)

func (*DatagramSession) ReadFrom 

func (s *DatagramSession) ReadFrom(b []byte) (n int, addr net.Addr, err error)

Reads one datagram sent to the destination of the DatagramSession. Returns the number of bytes read, from what address it was sent, or an error. implements net.PacketConn

func (*DatagramSession) RemoteAddr 

func (s *DatagramSession) RemoteAddr() net.Addr

func (*DatagramSession) SetDeadline 

func (s *DatagramSession) SetDeadline(t time.Time) error

Sets read and write deadlines for the DatagramSession. Implements net.PacketConn and does the same thing. Setting write deadlines for datagrams is seldom done.

func (*DatagramSession) SetReadDeadline 

func (s *DatagramSession) SetReadDeadline(t time.Time) error

Sets read deadline for the DatagramSession. Implements net.PacketConn

func (*DatagramSession) SetWriteBuffer 

func (s *DatagramSession) SetWriteBuffer(bytes int) error

func (*DatagramSession) SetWriteDeadline 

func (s *DatagramSession) SetWriteDeadline(t time.Time) error

Sets the write deadline for the DatagramSession. Implements net.Packetconn.

func (*DatagramSession) Write 

func (s *DatagramSession) Write(b []byte) (int, error)

func (*DatagramSession) WriteTo 

func (s *DatagramSession) WriteTo(b []byte, addr net.Addr) (n int, err error)

Sends one signed datagram to the destination specified. At the time of writing, maximum size is 31 kilobyte, but this may change in the future. Implements net.PacketConn.

type I2PConfig 

type I2PConfig struct {
	SamHost string
	SamPort string
	TunName string

	SamMin string
	SamMax string

	Fromport string
	Toport   string

	Style   string
	TunType string

	DestinationKeys i2pkeys.I2PKeys

	SigType                   string
	EncryptLeaseSet           string
	LeaseSetKey               string
	LeaseSetPrivateKey        string
	LeaseSetPrivateSigningKey string
	LeaseSetKeys              i2pkeys.I2PKeys
	InAllowZeroHop            string
	OutAllowZeroHop           string
	InLength                  string
	OutLength                 string
	InQuantity                string
	OutQuantity               string
	InVariance                string
	OutVariance               string
	InBackupQuantity          string
	OutBackupQuantity         string
	FastRecieve               string
	UseCompression            string
	MessageReliability        string
	CloseIdle                 string
	CloseIdleTime             string
	ReduceIdle                string
	ReduceIdleTime            string
	ReduceIdleQuantity        string
	LeaseSetEncryption        string

	//Streaming Library options
	AccessListType string
	AccessList     []string
}

I2PConfig is a struct which manages I2P configuration options

func NewConfig 

func NewConfig(opts ...func(*I2PConfig) error) (*I2PConfig, error)

func (*I2PConfig) Accesslist 

func (f *I2PConfig) Accesslist() string

func (*I2PConfig) Accesslisttype 

func (f *I2PConfig) Accesslisttype() string

func (*I2PConfig) Close 

func (f *I2PConfig) Close() string

func (*I2PConfig) DestinationKey 

func (f *I2PConfig) DestinationKey() string

func (*I2PConfig) DoZero 

func (f *I2PConfig) DoZero() string

func (*I2PConfig) EncryptLease 

func (f *I2PConfig) EncryptLease() string

func (*I2PConfig) FromPort 

func (f *I2PConfig) FromPort() string

func (*I2PConfig) ID 

func (f *I2PConfig) ID() string

func (*I2PConfig) LeaseSetEncryptionType 

func (f *I2PConfig) LeaseSetEncryptionType() string

func (*I2PConfig) Leasesetsettings 

func (f *I2PConfig) Leasesetsettings() (string, string, string)

func (*I2PConfig) MaxSAM 

func (f *I2PConfig) MaxSAM() string

func (*I2PConfig) MinSAM 

func (f *I2PConfig) MinSAM() string

func (*I2PConfig) Print 

func (f *I2PConfig) Print() []string

func (*I2PConfig) Reduce 

func (f *I2PConfig) Reduce() string

func (*I2PConfig) Reliability 

func (f *I2PConfig) Reliability() string

func (*I2PConfig) Sam 

func (f *I2PConfig) Sam() string

func (*I2PConfig) SessionStyle 

func (f *I2PConfig) SessionStyle() string

func (*I2PConfig) SetSAMAddress 

func (f *I2PConfig) SetSAMAddress(addr string)

func (*I2PConfig) SignatureType 

func (f *I2PConfig) SignatureType() string

func (*I2PConfig) ToPort 

func (f *I2PConfig) ToPort() string

type Option 

type Option func(*SAMEmit) error

Option is a SAMEmit Option

type Options 

type Options map[string]string

options map

func (Options) AsList 

func (opts Options) AsList() (ls []string)

obtain sam options as list of strings

type PrimarySession 

type PrimarySession struct {
	Timeout  time.Duration
	Deadline time.Time

	Config SAMEmit
	// contains filtered or unexported fields
}

Represents a primary session.

func (*PrimarySession) Addr 

func (ss *PrimarySession) Addr() i2pkeys.I2PAddr

Returns the I2P destination (the address) of the stream session

func (*PrimarySession) Close 

func (ss *PrimarySession) Close() error

func (*PrimarySession) Dial 

func (sam *PrimarySession) Dial(network, addr string) (net.Conn, error)

func (*PrimarySession) DialTCP 

func (sam *PrimarySession) DialTCP(network string, laddr, raddr net.Addr) (net.Conn, error)

DialTCP implements x/dialer

func (*PrimarySession) DialTCPI2P 

func (sam *PrimarySession) DialTCPI2P(network string, laddr, raddr string) (net.Conn, error)

func (*PrimarySession) DialUDP 

func (sam *PrimarySession) DialUDP(network string, laddr, raddr net.Addr) (net.PacketConn, error)

DialUDP implements x/dialer

func (*PrimarySession) DialUDPI2P 

func (sam *PrimarySession) DialUDPI2P(network, laddr, raddr string) (*DatagramSession, error)

func (*PrimarySession) From 

func (ss *PrimarySession) From() string

func (*PrimarySession) ID 

func (ss *PrimarySession) ID() string

Returns the local tunnel name of the I2P tunnel used for the stream session

func (*PrimarySession) Keys 

func (ss *PrimarySession) Keys() i2pkeys.I2PKeys

Returns the keys associated with the stream session

func (*PrimarySession) LocalAddr 

func (ss *PrimarySession) LocalAddr() net.Addr

func (*PrimarySession) Lookup 

func (s *PrimarySession) Lookup(name string) (a net.Addr, err error)

func (*PrimarySession) NewDatagramSubSession 

func (s *PrimarySession) NewDatagramSubSession(id string, udpPort int) (*DatagramSession, error)

Creates a new datagram session. udpPort is the UDP port SAM is listening on, and if you set it to zero, it will use SAMs standard UDP port.

func (*PrimarySession) NewRawSubSession 

func (s *PrimarySession) NewRawSubSession(id string, udpPort int) (*RawSession, error)

Creates a new raw session. udpPort is the UDP port SAM is listening on, and if you set it to zero, it will use SAMs standard UDP port.

func (*PrimarySession) NewStreamSubSession 

func (sam *PrimarySession) NewStreamSubSession(id string) (*StreamSession, error)

Creates a new StreamSession with the I2CP- and streaminglib options as specified. See the I2P documentation for a full list of options.

func (*PrimarySession) NewStreamSubSessionWithPorts 

func (sam *PrimarySession) NewStreamSubSessionWithPorts(id, from, to string) (*StreamSession, error)

Creates a new StreamSession with the I2CP- and streaminglib options as specified. See the I2P documentation for a full list of options.

func (*PrimarySession) NewUniqueStreamSubSession 

func (sam *PrimarySession) NewUniqueStreamSubSession(id string) (*StreamSession, error)

Creates a new StreamSession with the I2CP- and streaminglib options as specified. See the I2P documentation for a full list of options.

func (*PrimarySession) Resolve 

func (sam *PrimarySession) Resolve(network, addr string) (net.Addr, error)

func (*PrimarySession) ResolveTCPAddr 

func (sam *PrimarySession) ResolveTCPAddr(network, dest string) (net.Addr, error)

func (*PrimarySession) ResolveUDPAddr 

func (sam *PrimarySession) ResolveUDPAddr(network, dest string) (net.Addr, error)

func (*PrimarySession) SignatureType 

func (ss *PrimarySession) SignatureType() string

func (*PrimarySession) To 

func (ss *PrimarySession) To() string

type RawSession 

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

The RawSession provides no authentication of senders, and there is no sender address attached to datagrams, so all communication is anonymous. The messages send are however still endpoint-to-endpoint encrypted. You need to figure out a way to identify and authenticate clients yourself, iff that is needed. Raw datagrams may be at most 32 kB in size. There is no overhead of authentication, which is the reason to use this..

func (*RawSession) Close 

func (s *RawSession) Close() error

Closes the RawSession.

func (*RawSession) LocalAddr 

func (s *RawSession) LocalAddr() i2pkeys.I2PAddr

Returns the local I2P destination of the RawSession.

func (*RawSession) Read 

func (s *RawSession) Read(b []byte) (n int, err error)

Reads one raw datagram sent to the destination of the DatagramSession. Returns the number of bytes read. Who sent the raw message can not be determined at this layer - you need to do it (in a secure way!).

func (*RawSession) SetDeadline 

func (s *RawSession) SetDeadline(t time.Time) error

func (*RawSession) SetReadDeadline 

func (s *RawSession) SetReadDeadline(t time.Time) error

func (*RawSession) SetWriteDeadline 

func (s *RawSession) SetWriteDeadline(t time.Time) error

func (*RawSession) WriteTo 

func (s *RawSession) WriteTo(b []byte, addr i2pkeys.I2PAddr) (n int, err error)

Sends one raw datagram to the destination specified. At the time of writing, maximum size is 32 kilobyte, but this may change in the future.

type SAM 

type SAM struct {
	Config SAMEmit
	// contains filtered or unexported fields
}

Used for controlling I2Ps SAMv3.

func NewSAM 

func NewSAM(address string) (*SAM, error)

Creates a new controller for the I2P routers SAM bridge.

func (*SAM) Close 

func (sam *SAM) Close() error

close this sam session

func (*SAM) EnsureKeyfile 

func (sam *SAM) EnsureKeyfile(fname string) (keys i2pkeys.I2PKeys, err error)

if keyfile fname does not exist

func (*SAM) Keys 

func (sam *SAM) Keys() (k *i2pkeys.I2PKeys)

func (*SAM) Lookup 

func (sam *SAM) Lookup(name string) (i2pkeys.I2PAddr, error)

Performs a lookup, probably this order: 1) routers known addresses, cached addresses, 3) by asking peers in the I2P network.

func (*SAM) NewDatagramSession 

func (s *SAM) NewDatagramSession(id string, keys i2pkeys.I2PKeys, options []string, udpPort int) (*DatagramSession, error)

Creates a new datagram session. udpPort is the UDP port SAM is listening on, and if you set it to zero, it will use SAMs standard UDP port.

func (*SAM) NewKeys 

func (sam *SAM) NewKeys(sigType ...string) (i2pkeys.I2PKeys, error)

Creates the I2P-equivalent of an IP address, that is unique and only the one who has the private keys can send messages from. The public keys are the I2P desination (the address) that anyone can send messages to.

func (*SAM) NewPrimarySession 

func (sam *SAM) NewPrimarySession(id string, keys i2pkeys.I2PKeys, options []string) (*PrimarySession, error)

Creates a new PrimarySession with the I2CP- and streaminglib options as specified. See the I2P documentation for a full list of options.

func (*SAM) NewPrimarySessionWithSignature 

func (sam *SAM) NewPrimarySessionWithSignature(id string, keys i2pkeys.I2PKeys, options []string, sigType string) (*PrimarySession, error)

Creates a new PrimarySession with the I2CP- and PRIMARYinglib options as specified. See the I2P documentation for a full list of options.

func (*SAM) NewRawSession 

func (s *SAM) NewRawSession(id string, keys i2pkeys.I2PKeys, options []string, udpPort int) (*RawSession, error)

Creates a new raw session. udpPort is the UDP port SAM is listening on, and if you set it to zero, it will use SAMs standard UDP port.

func (*SAM) NewStreamSession 

func (sam *SAM) NewStreamSession(id string, keys i2pkeys.I2PKeys, options []string) (*StreamSession, error)

Creates a new StreamSession with the I2CP- and streaminglib options as specified. See the I2P documentation for a full list of options.

func (*SAM) NewStreamSessionWithSignature 

func (sam *SAM) NewStreamSessionWithSignature(id string, keys i2pkeys.I2PKeys, options []string, sigType string) (*StreamSession, error)

Creates a new StreamSession with the I2CP- and streaminglib options as specified. See the I2P documentation for a full list of options.

func (*SAM) NewStreamSessionWithSignatureAndPorts 

func (sam *SAM) NewStreamSessionWithSignatureAndPorts(id, from, to string, keys i2pkeys.I2PKeys, options []string, sigType string) (*StreamSession, error)

Creates a new StreamSession with the I2CP- and streaminglib options as specified. See the I2P documentation for a full list of options.

func (*SAM) ReadKeys 

func (sam *SAM) ReadKeys(r io.Reader) (err error)

read public/private keys from an io.Reader

type SAMConn 

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

import ( 

. "github.com/go-i2p/i2pkeys"

)

Implements net.Conn

func (*SAMConn) Close 

func (sc *SAMConn) Close() error

Implements net.Conn

func (*SAMConn) LocalAddr 

func (sc *SAMConn) LocalAddr() net.Addr

func (*SAMConn) Read 

func (sc *SAMConn) Read(buf []byte) (int, error)

Implements net.Conn

func (*SAMConn) RemoteAddr 

func (sc *SAMConn) RemoteAddr() net.Addr

func (*SAMConn) SetDeadline 

func (sc *SAMConn) SetDeadline(t time.Time) error

Implements net.Conn

func (*SAMConn) SetReadDeadline 

func (sc *SAMConn) SetReadDeadline(t time.Time) error

Implements net.Conn

func (*SAMConn) SetWriteDeadline 

func (sc *SAMConn) SetWriteDeadline(t time.Time) error

Implements net.Conn

func (*SAMConn) Write 

func (sc *SAMConn) Write(buf []byte) (int, error)

Implements net.Conn

type SAMEmit 

type SAMEmit struct {
	I2PConfig
}

func NewEmit 

func NewEmit(opts ...func(*SAMEmit) error) (*SAMEmit, error)

func (*SAMEmit) Accept 

func (e *SAMEmit) Accept() string

func (*SAMEmit) AcceptBytes 

func (e *SAMEmit) AcceptBytes() []byte

func (*SAMEmit) Connect 

func (e *SAMEmit) Connect(dest string) string

func (*SAMEmit) ConnectBytes 

func (e *SAMEmit) ConnectBytes(dest string) []byte

func (*SAMEmit) Create 

func (e *SAMEmit) Create() string

func (*SAMEmit) CreateBytes 

func (e *SAMEmit) CreateBytes() []byte

func (*SAMEmit) GenerateDestination 

func (e *SAMEmit) GenerateDestination() string

func (*SAMEmit) GenerateDestinationBytes 

func (e *SAMEmit) GenerateDestinationBytes() []byte

func (*SAMEmit) Hello 

func (e *SAMEmit) Hello() string

func (*SAMEmit) HelloBytes 

func (e *SAMEmit) HelloBytes() []byte

func (*SAMEmit) Lookup 

func (e *SAMEmit) Lookup(name string) string

func (*SAMEmit) LookupBytes 

func (e *SAMEmit) LookupBytes(name string) []byte

func (*SAMEmit) OptStr 

func (e *SAMEmit) OptStr() string

type SAMResolver 

type SAMResolver struct {
	*SAM
}

func NewFullSAMResolver 

func NewFullSAMResolver(address string) (*SAMResolver, error)

func NewSAMResolver 

func NewSAMResolver(parent *SAM) (*SAMResolver, error)

func (*SAMResolver) Resolve 

func (sam *SAMResolver) Resolve(name string) (i2pkeys.I2PAddr, error)

Performs a lookup, probably this order: 1) routers known addresses, cached addresses, 3) by asking peers in the I2P network.

type StreamListener 

type StreamListener struct {
	// contains filtered or unexported fields
}
Example 
// One server Accept()ing on a StreamListener, and one client that Dials
// through I2P to the server. Server writes "Hello world!" through a SAMConn
// (which implements net.Conn) and the client prints the message.

const samBridge = "127.0.0.1:7656"

sam, err := NewSAM(samBridge)
if err != nil {
	fmt.Println(err.Error())
	return
}
defer sam.Close()
keys, err := sam.NewKeys()
if err != nil {
	fmt.Println(err.Error())
	return
}

quit := make(chan bool)

// Client connecting to the server
go func(server i2pkeys.I2PAddr) {
	csam, err := NewSAM(samBridge)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer csam.Close()
	keys, err := csam.NewKeys()
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	cs, err := csam.NewStreamSession("client_example", keys, Options_Small)
	if err != nil {
		fmt.Println(err.Error())
		quit <- false
		return
	}
	conn, err := cs.DialI2P(server)
	if err != nil {
		fmt.Println(err.Error())
		quit <- false
		return
	}
	buf := make([]byte, 256)
	n, err := conn.Read(buf)
	if err != nil {
		fmt.Println(err.Error())
		quit <- false
		return
	}
	fmt.Println(string(buf[:n]))
	quit <- true
}(keys.Addr()) // end of client

ss, err := sam.NewStreamSession("server_example", keys, Options_Small)
if err != nil {
	fmt.Println(err.Error())
	return
}
l, err := ss.Listen()
if err != nil {
	fmt.Println(err.Error())
	return
}
conn, err := l.Accept()
if err != nil {
	fmt.Println(err.Error())
	return
}
conn.Write([]byte("Hello world!"))

<-quit // waits for client to die, for example only

Output:

Hello world!

func (*StreamListener) Accept 

func (l *StreamListener) Accept() (net.Conn, error)

implements net.Listener

func (*StreamListener) AcceptI2P 

func (l *StreamListener) AcceptI2P() (*SAMConn, error)

accept a new inbound connection

func (*StreamListener) Addr 

func (l *StreamListener) Addr() net.Addr

get our address implements net.Listener

func (*StreamListener) Close 

func (l *StreamListener) Close() error

implements net.Listener

func (*StreamListener) From 

func (l *StreamListener) From() string

func (*StreamListener) To 

func (l *StreamListener) To() string

type StreamSession 

type StreamSession struct {
	Timeout  time.Duration
	Deadline time.Time
	// contains filtered or unexported fields
}

Represents a streaming session.

Example 
// Creates a new StreamingSession, dials to idk.i2p and gets a SAMConn
// which behaves just like a normal net.Conn.

const samBridge = "127.0.0.1:7656"

sam, err := NewSAM(samBridge)
if err != nil {
	fmt.Println(err.Error())
	return
}
defer sam.Close()
keys, err := sam.NewKeys()
if err != nil {
	fmt.Println(err.Error())
	return
}
// See the example Option_* variables.
ss, err := sam.NewStreamSession("stream_example", keys, Options_Small)
if err != nil {
	fmt.Println(err.Error())
	return
}
someone, err := sam.Lookup("idk.i2p")
if err != nil {
	fmt.Println(err.Error())
	return
}

conn, err := ss.DialI2P(someone)
if err != nil {
	fmt.Println(err.Error())
	return
}
defer conn.Close()
fmt.Println("Sending HTTP GET /")
if _, err := conn.Write([]byte("GET /\n")); err != nil {
	fmt.Println(err.Error())
	return
}
buf := make([]byte, 4096)
n, err := conn.Read(buf)
if !strings.Contains(strings.ToLower(string(buf[:n])), "http") && !strings.Contains(strings.ToLower(string(buf[:n])), "html") {
	fmt.Printf("Probably failed to StreamSession.DialI2P(idk.i2p)? It replied %d bytes, but nothing that looked like http/html", n)
	log.Printf("Probably failed to StreamSession.DialI2P(idk.i2p)? It replied %d bytes, but nothing that looked like http/html", n)
} else {
	fmt.Println("Read HTTP/HTML from idk.i2p")
	log.Println("Read HTTP/HTML from idk.i2p")
}
return

Output:

Sending HTTP GET /
Read HTTP/HTML from idk.i2p

func (*StreamSession) Addr 

func (s *StreamSession) Addr() i2pkeys.I2PAddr

Returns the I2P destination (the address) of the stream session

func (*StreamSession) Close 

func (s *StreamSession) Close() error

func (*StreamSession) Dial 

func (s *StreamSession) Dial(n, addr string) (c net.Conn, err error)

implement net.Dialer

func (*StreamSession) DialContext 

func (s *StreamSession) DialContext(ctx context.Context, n, addr string) (net.Conn, error)

context-aware dialer, eventually...

func (*StreamSession) DialContextI2P 

func (s *StreamSession) DialContextI2P(ctx context.Context, n, addr string) (*SAMConn, error)

context-aware dialer, eventually...

func (*StreamSession) DialI2P 

func (s *StreamSession) DialI2P(addr i2pkeys.I2PAddr) (*SAMConn, error)

Dials to an I2P destination and returns a SAMConn, which implements a net.Conn.

func (*StreamSession) From 

func (s *StreamSession) From() string

func (*StreamSession) ID 

func (s *StreamSession) ID() string

Returns the local tunnel name of the I2P tunnel used for the stream session

func (*StreamSession) Keys 

func (s *StreamSession) Keys() i2pkeys.I2PKeys

Returns the keys associated with the stream session

func (*StreamSession) Listen 

func (s *StreamSession) Listen() (*StreamListener, error)

create a new stream listener to accept inbound connections

func (*StreamSession) LocalAddr 

func (s *StreamSession) LocalAddr() net.Addr

func (*StreamSession) Lookup 

func (s *StreamSession) Lookup(name string) (i2pkeys.I2PAddr, error)

lookup name, convenience function

func (*StreamSession) Read 

func (s *StreamSession) Read(buf []byte) (int, error)

Read reads data from the stream.

func (*StreamSession) SetDeadline 

func (s *StreamSession) SetDeadline(t time.Time) error

func (*StreamSession) SetReadDeadline 

func (s *StreamSession) SetReadDeadline(t time.Time) error

func (*StreamSession) SetWriteDeadline 

func (s *StreamSession) SetWriteDeadline(t time.Time) error

func (*StreamSession) SignatureType 

func (s *StreamSession) SignatureType() string

func (*StreamSession) To 

func (s *StreamSession) To() string

func (*StreamSession) Write 

func (s *StreamSession) Write(data []byte) (int, error)

Write sends data over the stream.

Source Files

View all Source files

Directories

Path Synopsis

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.
JackTT - Gopher 🇻🇳