session

Documentation

Overview

Package session implements session storage.

Index

• Variables
• type Data
  • func TDesktopSession(account tdesktop.Account) (*Data, error)
  • func TelethonSession(hx string) (*Data, error)
• type FileStorage
  • func (f *FileStorage) LoadSession(_ context.Context) ([]byte, error)
  • func (f *FileStorage) StoreSession(_ context.Context, data []byte) error
• type Loader
  • func (l *Loader) Load(ctx context.Context) (*Data, error)
  • func (l *Loader) Save(ctx context.Context, data *Data) error
• type Storage
• type StorageMemory
  • func (s *StorageMemory) Bytes(to []byte) ([]byte, error)
  • func (s *StorageMemory) Clone() *StorageMemory
  • func (s *StorageMemory) Dump(w io.Writer) error
  • func (s *StorageMemory) LoadSession(context.Context) ([]byte, error)
  • func (s *StorageMemory) StoreSession(ctx context.Context, data []byte) error
  • func (s *StorageMemory) WriteFile(name string, perm os.FileMode) error

Examples

• TDesktopSession
• TDesktopSession (Convert)
• TelethonSession
• TelethonSession (Convert)

Variables

var ErrNotFound = errors.New("session storage: not found")

ErrNotFound means that session is not found in storage.

Types

type Data

type Data struct {
	Config    tg.Config
	DC        int
	Addr      string
	AuthKey   []byte
	AuthKeyID []byte
	Salt      int64
}

Data of session.

func TDesktopSession

func TDesktopSession(account tdesktop.Account) (*Data, error)

TDesktopSession converts TDesktop's Account to Data.

Example

package main

import (
	"fmt"
	"os"
	"path/filepath"

	"github.com/gotd/td/session"
	"github.com/gotd/td/session/tdesktop"
)

func main() {
	home, err := os.UserHomeDir()
	if err != nil {
		panic(err)
	}

	root := filepath.Join(home, "Downloads", "Telegram", "tdata")
	accounts, err := tdesktop.Read(root, nil)
	if err != nil {
		panic(err)
	}

	data, err := session.TDesktopSession(accounts[0])
	if err != nil {
		panic(err)
	}

	fmt.Println(data.DC, data.Addr)
}

Example (Convert)

package main

import (
	"context"
	"os"
	"path/filepath"

	"github.com/gotd/td/session"
	"github.com/gotd/td/session/tdesktop"
	"github.com/gotd/td/telegram"
)

func main() {
	ctx := context.Background()

	home, err := os.UserHomeDir()
	if err != nil {
		panic(err)
	}

	root := filepath.Join(home, "Downloads", "Telegram", "tdata")
	accounts, err := tdesktop.Read(root, nil)
	if err != nil {
		panic(err)
	}

	data, err := session.TDesktopSession(accounts[0])
	if err != nil {
		panic(err)
	}

	var (
		storage = new(session.StorageMemory)
		loader  = session.Loader{Storage: storage}
	)

	// Save decoded Telegram Desktop session as gotd session.
	if err := loader.Save(ctx, data); err != nil {
		panic(err)
	}

	// Create client.
	client := telegram.NewClient(telegram.TestAppID, telegram.TestAppHash, telegram.Options{
		SessionStorage: storage,
	})
	if err := client.Run(ctx, func(ctx context.Context) error {
		// Use Telegram Desktop session.
		return nil
	}); err != nil {
		panic(err)
	}
}

func TelethonSession

func TelethonSession(hx string) (*Data, error)

TelethonSession decodes Telethon's StringSession string to the Data. Notice that Telethon does not save tg.Config and server salt.

See https://docs.telethon.dev/en/latest/modules/sessions.html#telethon.sessions.string.StringSession.

See https://github.com/LonamiWebs/Telethon/blob/master/telethon/sessions/string.py#L29-L46.

Example

package main

import (
	"fmt"

	"github.com/gotd/td/session"
)

func main() {
	// Get a session from Telethon.
	str := `1AsCoAAEBu2FhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYW
FhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhY
WFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFh
YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE=`

	data, err := session.TelethonSession(str)
	if err != nil {
		panic(err)
	}

	fmt.Println(data.DC, data.Addr)
}

Output:

2 192.168.0.1:443

Example (Convert)

package main

import (
	"context"

	"github.com/gotd/td/session"
	"github.com/gotd/td/telegram"
)

func main() {
	ctx := context.Background()
	// Get a session from Telethon.
	str := `1AsCoAAEBu2FhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYW
FhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhY
WFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFh
YWFhYWFhYWFhYWFhYWFhYWFhYWFhYWE=`

	data, err := session.TelethonSession(str)
	if err != nil {
		panic(err)
	}

	var (
		storage = new(session.StorageMemory)
		loader  = session.Loader{Storage: storage}
	)

	// Save decoded Telethon session as gotd session.
	if err := loader.Save(ctx, data); err != nil {
		panic(err)
	}

	// Create client.
	client := telegram.NewClient(telegram.TestAppID, telegram.TestAppHash, telegram.Options{
		SessionStorage: storage,
	})
	if err := client.Run(ctx, func(ctx context.Context) error {
		// Use Telethon session.
		return nil
	}); err != nil {
		panic(err)
	}
}

type FileStorage

type FileStorage struct {
	Path string
	// contains filtered or unexported fields
}

FileStorage implements SessionStorage for file system as file stored in Path.

func (*FileStorage) LoadSession

func (f *FileStorage) LoadSession(_ context.Context) ([]byte, error)

LoadSession loads session from file.

func (*FileStorage) StoreSession

func (f *FileStorage) StoreSession(_ context.Context, data []byte) error

StoreSession stores session to file.

type Loader

type Loader struct {
	Storage Storage
}

Loader wraps Storage implementing Data (un-)marshaling.

func (*Loader) Load

func (l *Loader) Load(ctx context.Context) (*Data, error)

Load loads Data from Storage.

func (*Loader) Save

func (l *Loader) Save(ctx context.Context, data *Data) error

Save saves Data to Storage.

type Storage

type Storage interface {
	LoadSession(ctx context.Context) ([]byte, error)
	StoreSession(ctx context.Context, data []byte) error
}

Storage is secure persistent storage for client session.

NB: Implementation security is important, attacker can abuse it not only for connecting as authenticated user or bot, but even decrypting previous messages in some situations.

type StorageMemory

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

StorageMemory implements in-memory session storage. Goroutine-safe.

func (*StorageMemory) Bytes

func (s *StorageMemory) Bytes(to []byte) ([]byte, error)

Bytes appends raw session data to the given slice. Returns ErrNotFound if storage is nil or if underlying session is empty.

func (*StorageMemory) Clone

func (s *StorageMemory) Clone() *StorageMemory

Clone creates a clone of existing StorageMemory,

func (*StorageMemory) Dump

func (s *StorageMemory) Dump(w io.Writer) error

Dump dumps raw session data to the given writer. Returns ErrNotFound if storage is nil or if underlying session is empty.

func (*StorageMemory) LoadSession

func (s *StorageMemory) LoadSession(context.Context) ([]byte, error)

LoadSession loads session from memory.

func (*StorageMemory) StoreSession

func (s *StorageMemory) StoreSession(ctx context.Context, data []byte) error

StoreSession stores session to memory.

func (*StorageMemory) WriteFile

func (s *StorageMemory) WriteFile(name string, perm os.FileMode) error

WriteFile dumps raw session data to the named file, creating it if necessary. Returns ErrNotFound if storage is nil or if underlying session is empty.