├── .deepsource.toml ├── .github ├── FUNDING.yml └── workflows │ └── tlparser.yml ├── .gitmodules ├── CODE_OF_CONDUCT.md ├── LICENSE ├── README.md ├── errors.go ├── examples ├── auth │ └── userauth.go ├── bot │ └── echobot.go ├── broadcast │ └── broadcast.go ├── buttons │ └── replymarkup.go ├── cache │ └── main.go ├── conversation │ └── conversation.go ├── fileid │ └── fileid.go ├── getchats │ └── getchats.go ├── gifts │ └── main.go ├── inline │ └── inlinebot.go ├── multiple │ └── main.go ├── progress │ └── upload.go ├── proxy │ └── proxy.go ├── react │ └── react.go ├── sessions │ ├── pyrogram │ │ └── main.go │ ├── string │ │ └── main.go │ ├── tdata │ │ └── main.go │ └── telethon │ │ └── main.go ├── simple │ └── simpleauth.go └── stars │ └── stars.go ├── go.mod ├── go.sum ├── handshake.go ├── internal ├── aes_ige │ ├── aes.go │ ├── aes_common.go │ ├── errors.go │ ├── ige_cipher.go │ └── password.go ├── cmd │ └── tlgen │ │ ├── gen │ │ ├── common.go │ │ ├── gen.go │ │ ├── schema.go │ │ ├── tl_gen_enums.go │ │ ├── tl_gen_init.go │ │ ├── tl_gen_interfaces.go │ │ ├── tl_gen_methods.go │ │ ├── tl_gen_structs.go │ │ └── utils.go │ │ ├── go.mod │ │ ├── go.sum │ │ ├── main.go │ │ └── tlparser │ │ ├── cursor.go │ │ ├── excluded.go │ │ ├── extra.go │ │ ├── parser.go │ │ └── schema.go ├── encoding │ └── tl │ │ ├── common_types.go │ │ ├── const.go │ │ ├── cursor_r.go │ │ ├── cursor_w.go │ │ ├── decoder.go │ │ ├── encoder.go │ │ ├── errors.go │ │ ├── object.go │ │ ├── register.go │ │ ├── tag.go │ │ └── utils.go ├── keys │ └── keys.go ├── math │ └── math.go ├── mode │ ├── arbiged.go │ ├── errors.go │ ├── full.go │ ├── intermediate.go │ └── mode.go ├── mtproto │ ├── messages │ │ └── messages.go │ └── objects │ │ ├── const.go │ │ ├── init.go │ │ ├── methods.go │ │ └── types.go ├── session │ ├── file.go │ ├── interface.go │ └── string.go ├── transport │ ├── connection.go │ ├── interfaces.go │ ├── proxy.go │ ├── transport.go │ ├── utils.go │ └── writer.go └── utils │ ├── logging.go │ ├── media.go │ ├── set.go │ ├── sync.go │ └── utils.go ├── mtproto.go ├── network.go ├── schemes ├── api.tl ├── e2e.tl └── mtproto.tl └── telegram ├── auth.go ├── bots.go ├── buttons.go ├── cache.go ├── callbackquery.go ├── channels.go ├── client.go ├── const.go ├── conversation.go ├── enums_gen.go ├── formatting.go ├── helpers.go ├── init_gen.go ├── inlinequery.go ├── interfaces_gen.go ├── media.go ├── messages.go ├── methods_gen.go ├── methods_special.go ├── newmessage.go ├── participant.go ├── tgcalls.go ├── types_gen.go ├── updates.go ├── users.go └── utils.go /.deepsource.toml: -------------------------------------------------------------------------------- 1 | version = 1 2 | 3 | [[analyzers]] 4 | name = "go" 5 | enabled = true 6 | 7 | [analyzers.meta] 8 | import_root = "github.com/AmarnathCJD/gogram" -------------------------------------------------------------------------------- /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: amarnathcjd 2 | buy_me_a_coffee: amarnathcjd 3 | -------------------------------------------------------------------------------- /.github/workflows/tlparser.yml: -------------------------------------------------------------------------------- 1 | name: Go TL Parser 2 | 3 | on: 4 | push: 5 | branches: [ "master" ] 6 | pull_request: 7 | branches: [ "master" ] 8 | workflow_dispatch: 9 | schedule: 10 | - cron: '0 */3 * * *' 11 | 12 | jobs: 13 | 14 | build: 15 | runs-on: ubuntu-latest 16 | steps: 17 | - uses: actions/checkout@v4 18 | 19 | - name: Set up Go 20 | uses: actions/setup-go@v5 21 | with: 22 | go-version: '1.23' 23 | 24 | - name: Build & Run TL Parser 25 | run: cd ./internal/cmd/tlgen && go run . --doc 26 | 27 | - name: Lint 28 | run: gofmt -l -s -w . 29 | 30 | - uses: stefanzweifel/git-auto-commit-action@v5 31 | with: 32 | commit_message: "tlgen: update TL schema files" 33 | commit_options: "--no-verify" 34 | repository: . 35 | commit_user_name: AmarnathCJD 36 | commit_user_email: 72609355+AmarnathCJD@users.noreply.github.com 37 | commit_author: AmarnathCJD <72609355+AmarnathCJD+@users.noreply.github.com> 38 | 39 | 40 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "examples/tgcalls"] 2 | path = examples/tgcalls 3 | url = https://github.com/amarnathcjd/tgcalls.git 4 | -------------------------------------------------------------------------------- /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | # Contributor Covenant Code of Conduct 2 | 3 | ## Our Pledge 4 | 5 | We as members, contributors, and leaders pledge to make participation in our 6 | community a harassment-free experience for everyone, regardless of age, body 7 | size, visible or invisible disability, ethnicity, sex characteristics, gender 8 | identity and expression, level of experience, education, socio-economic status, 9 | nationality, personal appearance, race, religion, or sexual identity 10 | and orientation. 11 | 12 | We pledge to act and interact in ways that contribute to an open, welcoming, 13 | diverse, inclusive, and healthy community. 14 | 15 | ## Our Standards 16 | 17 | Examples of behavior that contributes to a positive environment for our 18 | community include: 19 | 20 | * Demonstrating empathy and kindness toward other people 21 | * Being respectful of differing opinions, viewpoints, and experiences 22 | * Giving and gracefully accepting constructive feedback 23 | * Accepting responsibility and apologizing to those affected by our mistakes, 24 | and learning from the experience 25 | * Focusing on what is best not just for us as individuals, but for the 26 | overall community 27 | 28 | Examples of unacceptable behavior include: 29 | 30 | * The use of sexualized language or imagery, and sexual attention or 31 | advances of any kind 32 | * Trolling, insulting or derogatory comments, and personal or political attacks 33 | * Public or private harassment 34 | * Publishing others' private information, such as a physical or email 35 | address, without their explicit permission 36 | * Other conduct which could reasonably be considered inappropriate in a 37 | professional setting 38 | 39 | ## Enforcement Responsibilities 40 | 41 | Community leaders are responsible for clarifying and enforcing our standards of 42 | acceptable behavior and will take appropriate and fair corrective action in 43 | response to any behavior that they deem inappropriate, threatening, offensive, 44 | or harmful. 45 | 46 | Community leaders have the right and responsibility to remove, edit, or reject 47 | comments, commits, code, wiki edits, issues, and other contributions that are 48 | not aligned to this Code of Conduct, and will communicate reasons for moderation 49 | decisions when appropriate. 50 | 51 | ## Scope 52 | 53 | This Code of Conduct applies within all community spaces, and also applies when 54 | an individual is officially representing the community in public spaces. 55 | Examples of representing our community include using an official e-mail address, 56 | posting via an official social media account, or acting as an appointed 57 | representative at an online or offline event. 58 | 59 | ## Enforcement 60 | 61 | Instances of abusive, harassing, or otherwise unacceptable behavior may be 62 | reported to the community leaders responsible for enforcement at 63 | roseloverx@proton.me. 64 | All complaints will be reviewed and investigated promptly and fairly. 65 | 66 | All community leaders are obligated to respect the privacy and security of the 67 | reporter of any incident. 68 | 69 | ## Enforcement Guidelines 70 | 71 | Community leaders will follow these Community Impact Guidelines in determining 72 | the consequences for any action they deem in violation of this Code of Conduct: 73 | 74 | ### 1. Correction 75 | 76 | **Community Impact**: Use of inappropriate language or other behavior deemed 77 | unprofessional or unwelcome in the community. 78 | 79 | **Consequence**: A private, written warning from community leaders, providing 80 | clarity around the nature of the violation and an explanation of why the 81 | behavior was inappropriate. A public apology may be requested. 82 | 83 | ### 2. Warning 84 | 85 | **Community Impact**: A violation through a single incident or series 86 | of actions. 87 | 88 | **Consequence**: A warning with consequences for continued behavior. No 89 | interaction with the people involved, including unsolicited interaction with 90 | those enforcing the Code of Conduct, for a specified period of time. This 91 | includes avoiding interactions in community spaces as well as external channels 92 | like social media. Violating these terms may lead to a temporary or 93 | permanent ban. 94 | 95 | ### 3. Temporary Ban 96 | 97 | **Community Impact**: A serious violation of community standards, including 98 | sustained inappropriate behavior. 99 | 100 | **Consequence**: A temporary ban from any sort of interaction or public 101 | communication with the community for a specified period of time. No public or 102 | private interaction with the people involved, including unsolicited interaction 103 | with those enforcing the Code of Conduct, is allowed during this period. 104 | Violating these terms may lead to a permanent ban. 105 | 106 | ### 4. Permanent Ban 107 | 108 | **Community Impact**: Demonstrating a pattern of violation of community 109 | standards, including sustained inappropriate behavior, harassment of an 110 | individual, or aggression toward or disparagement of classes of individuals. 111 | 112 | **Consequence**: A permanent ban from any sort of public interaction within 113 | the community. 114 | 115 | ## Attribution 116 | 117 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], 118 | version 2.0, available at 119 | https://www.contributor-covenant.org/version/2/0/code_of_conduct.html. 120 | 121 | Community Impact Guidelines were inspired by [Mozilla's code of conduct 122 | enforcement ladder](https://github.com/mozilla/diversity). 123 | 124 | [homepage]: https://www.contributor-covenant.org 125 | 126 | For answers to common questions about this code of conduct, see the FAQ at 127 | https://www.contributor-covenant.org/faq. Translations are available at 128 | https://www.contributor-covenant.org/translations. 129 | -------------------------------------------------------------------------------- /examples/auth/userauth.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/amarnathcjd/gogram/telegram" 7 | ) 8 | 9 | const ( 10 | appID = 6 11 | appHash = "YOUR_APP_HASH" 12 | phoneNum = "YOUR_PHONE_NUMBER" 13 | ) 14 | 15 | func main() { 16 | // Create a new client 17 | client, _ := telegram.NewClient(telegram.ClientConfig{ 18 | AppID: appID, 19 | AppHash: appHash, 20 | LogLevel: telegram.LogInfo, 21 | // StringSession: "", // Uncomment this line to use string session 22 | // SessionFile: "session.session", To use session File. 23 | }) 24 | 25 | // Connect to the server 26 | if err := client.Connect(); err != nil { 27 | panic(err) 28 | } 29 | 30 | // Authenticate the client using the bot token 31 | // This will send a code to the phone number if it is not already authenticated 32 | if _, err := client.Login(phoneNum); err != nil { 33 | panic(err) 34 | } 35 | 36 | // Do something with the client 37 | // ... 38 | me, err := client.GetMe() 39 | if err != nil { 40 | panic(err) 41 | } 42 | client.SendMessage("me", fmt.Sprintf("Hello, %s!", me.FirstName)) 43 | fmt.Println("Logged in as", me.Username) 44 | } 45 | -------------------------------------------------------------------------------- /examples/bot/echobot.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "github.com/amarnathcjd/gogram/telegram" 5 | ) 6 | 7 | const ( 8 | appID = 6 9 | appHash = "YOUR_APP_HASH" 10 | botToken = "YOUR_BOT_TOKEN" 11 | ) 12 | 13 | func main() { 14 | // create a new client object 15 | client, _ := telegram.NewClient(telegram.ClientConfig{ 16 | AppID: appID, 17 | AppHash: appHash, 18 | LogLevel: telegram.LogInfo, 19 | }) 20 | 21 | client.LoginBot(botToken) 22 | 23 | client.On(telegram.OnMessage, func(message *telegram.NewMessage) error { 24 | message.Respond(message) 25 | return nil 26 | }, telegram.FilterPrivate) 27 | 28 | client.On("message:/start", func(message *telegram.NewMessage) error { 29 | message.Reply("Hello, I am a bot!") 30 | return nil 31 | }) 32 | 33 | // lock the main routine 34 | client.Idle() 35 | } 36 | -------------------------------------------------------------------------------- /examples/broadcast/broadcast.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "github.com/amarnathcjd/gogram/telegram" 5 | ) 6 | 7 | // Broadcasting to bot users / chats using updates.GetDifference 8 | // client.Broadcast returns peers in update history via channels 9 | // these peers can be used for broadcasting messages 10 | // no external database is required to store user / chat ids 11 | 12 | const ( 13 | appID = 6 14 | appHash = "YOUR_APP_HASH" 15 | botToken = "YOUR_BOT_TOKEN" 16 | ) 17 | 18 | func main() { 19 | // create a new client object 20 | client, _ := telegram.NewClient(telegram.ClientConfig{ 21 | AppID: appID, 22 | AppHash: appHash, 23 | LogLevel: telegram.LogInfo, 24 | }) 25 | 26 | client.LoginBot(botToken) 27 | 28 | users, chats, err := client.Broadcast() 29 | if err != nil { 30 | panic(err) 31 | } 32 | 33 | for user := range users { 34 | client.SendMessage(user, "Hello, This is a broadcast message") 35 | } 36 | 37 | for chat := range chats { 38 | client.SendMessage(chat, "Hello, This is a broadcast message") 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /examples/buttons/replymarkup.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "github.com/amarnathcjd/gogram/telegram" 5 | ) 6 | 7 | const ( 8 | appID = 6 9 | appHash = "YOUR_APP_HASH" 10 | botToken = "YOUR_BOT_TOKEN" 11 | ) 12 | 13 | func main() { 14 | // create a new client object 15 | client, _ := telegram.NewClient(telegram.ClientConfig{ 16 | AppID: appID, 17 | AppHash: appHash, 18 | LogLevel: telegram.LogInfo, 19 | }) 20 | 21 | client.LoginBot(botToken) 22 | 23 | client.SendMessage("username", "Hello, This is ReplyMarkup Example", &telegram.SendOptions{ 24 | ReplyMarkup: telegram.NewKeyboard().AddRow( // adds a row of buttons 25 | telegram.Button.Data("Help", "help"), 26 | telegram.Button.URL("Google", "https://www.google.com"), 27 | ).Build(), //.AddRow( // adds another row of buttons) 28 | }) 29 | 30 | client.On("message:/start", func(message *telegram.NewMessage) error { 31 | message.Reply("Hello:>", telegram.SendOptions{ 32 | ReplyMarkup: telegram.NewKeyboard().NewGrid(2, 3, // 2 rows, 3 columns format 33 | telegram.Button.URL("Google", "https://www.google.com"), 34 | telegram.Button.Data("Help", "help"), 35 | telegram.Button.Data("Main Menu", "main"), 36 | telegram.Button.Data("Source", "source"), 37 | telegram.Button.SwitchInline("goinline", true, "query"), 38 | telegram.Button.Data("Back", "back")).Build(), 39 | }) 40 | return nil 41 | }) 42 | 43 | telegram.NewKeyboard().NewColumn(2, telegram.Button.URL("Google", "https://www.google.com"), 44 | telegram.Button.URL("Yahoo", "https://www.yahoo.com"), 45 | telegram.Button.URL("Bing", "https://www.bing.com"), 46 | telegram.Button.URL("DuckDuckGo", "https://www.duckduckgo.com"), 47 | ).Build() // 2 columns format, buttons equally divided into 2 columns 48 | 49 | telegram.NewKeyboard().NewRow(3, 50 | telegram.Button.URL("Google", "https://www.google.com"), 51 | telegram.Button.URL("Yahoo", "https://www.yahoo.com"), 52 | telegram.Button.URL("Bing", "https://www.bing.com"), 53 | telegram.Button.URL("DuckDuckGo", "https://www.duckduckgo.com"), 54 | ).Build() // 3 rows format, buttons equally divided into 3 rows 55 | 56 | client.On("callback:help", func(callback *telegram.CallbackQuery) error { 57 | callback.Answer("Help is on the way!") 58 | return nil 59 | }) 60 | 61 | client.Idle() 62 | } 63 | -------------------------------------------------------------------------------- /examples/cache/main.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "github.com/amarnathcjd/gogram/telegram" 5 | ) 6 | 7 | const ( 8 | appID = 6 9 | appHash = "YOUR_APP_HASH" 10 | botToken = "YOUR_BOT_TOKEN" 11 | ) 12 | 13 | func main() { 14 | // create a new client object 15 | client, _ := telegram.NewClient(telegram.ClientConfig{ 16 | AppID: appID, 17 | AppHash: appHash, 18 | LogLevel: telegram.LogInfo, 19 | Cache: telegram.NewCache("cache_file.db", &telegram.CacheConfig{ 20 | MaxSize: 1000, // TODO 21 | LogLevel: telegram.LogInfo, 22 | LogNoColor: true, // disable color in logs 23 | Memory: true, // disable writing to disk 24 | Disabled: false, // to totally disable cache 25 | }), // if left empty, it will use the default cache 'cache.db', with default config 26 | }) 27 | 28 | client.LoginBot(botToken) 29 | 30 | client.On(telegram.OnMessage, func(message *telegram.NewMessage) error { 31 | message.Respond(message) 32 | return nil 33 | }, telegram.FilterPrivate) 34 | 35 | client.On("message:/start", func(message *telegram.NewMessage) error { 36 | message.Reply("Hello, I am a bot!") 37 | return nil 38 | }) 39 | 40 | // lock the main routine 41 | client.Idle() 42 | } 43 | -------------------------------------------------------------------------------- /examples/conversation/conversation.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/amarnathcjd/gogram/telegram" 7 | ) 8 | 9 | const ( 10 | appID = 6 11 | appHash = "YOUR_APP_HASH" 12 | botToken = "YOUR_BOT_TOKEN" 13 | ) 14 | 15 | func main() { 16 | // create a new client object 17 | client, _ := telegram.NewClient(telegram.ClientConfig{ 18 | AppID: appID, 19 | AppHash: appHash, 20 | LogLevel: telegram.LogInfo, 21 | }) 22 | 23 | client.LoginBot(botToken) 24 | 25 | client.On("message", convEventHandler) 26 | 27 | // new conversation 28 | conv, _ := client.NewConversation("username or id", false, 30) // 30 is the timeout in seconds, false means it's not a private conversation 29 | defer conv.Close() 30 | 31 | _, err := conv.Respond("Hello, Please reply to this message") 32 | if err != nil { 33 | panic(err) 34 | } 35 | resp, err := conv.GetResponse() // wait for the response 36 | // resp, err := conv.GetReply() // wait for the reply 37 | // conv.MarkRead() // mark the conversation as read 38 | // conv.WaitEvent() // wait for any custom update 39 | if err != nil { 40 | panic(err) 41 | } 42 | 43 | fmt.Println("response:", resp.Text()) 44 | } 45 | 46 | func convEventHandler(m *telegram.NewMessage) error { 47 | response, err := m.Ask("What's your name?") 48 | if err != nil { 49 | return err 50 | } 51 | 52 | response.Reply("Nice to meet you, " + response.Text()) 53 | return nil 54 | } 55 | -------------------------------------------------------------------------------- /examples/fileid/fileid.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "github.com/amarnathcjd/gogram/telegram" 5 | ) 6 | 7 | // https://gist.github.com/AmarnathCJD/824907f8ec9e7aa9cec8278937fc437b 8 | // use this code to convert bot-api file id to gogram file id 9 | 10 | // https://gist.github.com/AmarnathCJD/27626c8fc1b5d5234576d1eecb5d651f 11 | // use this code to convert pyrogram file id to gogram file id 12 | 13 | const ( 14 | appID = 6 15 | appHash = "YOUR_APP_HASH" 16 | phoneNum = "YOUR_PHONE_NUMBER" 17 | ) 18 | 19 | func main() { 20 | // Create a new client 21 | client, _ := telegram.NewClient(telegram.ClientConfig{ 22 | AppID: appID, 23 | AppHash: appHash, 24 | LogLevel: telegram.LogInfo, 25 | }) 26 | 27 | client.Conn() // Connect to the telegram server 28 | 29 | // Authentication 30 | client.LoginBot("") 31 | 32 | client.On(telegram.OnMessage, func(msg *telegram.NewMessage) error { 33 | if msg.Media() != nil { 34 | fileID := msg.File.FileID // or telegram.PackBotFileID(msg.Media()) 35 | 36 | msg.Respond("File ID: " + fileID) 37 | 38 | fileRetained, err := telegram.ResolveBotFileID(fileID) 39 | if err != nil { 40 | return err 41 | } 42 | 43 | msg.RespondMedia(fileRetained) 44 | } 45 | 46 | return nil 47 | }) 48 | } 49 | -------------------------------------------------------------------------------- /examples/getchats/getchats.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/amarnathcjd/gogram/telegram" 7 | ) 8 | 9 | const ( 10 | appID = 6 11 | appHash = "YOUR_APP_HASH" 12 | phoneNum = "YOUR_PHONE_NUMBER" 13 | ) 14 | 15 | func main() { 16 | // Create a new client 17 | client, _ := telegram.NewClient(telegram.ClientConfig{ 18 | AppID: appID, 19 | AppHash: appHash, 20 | LogLevel: telegram.LogInfo, 21 | // StringSession: "", // Uncomment this line to use string session 22 | }) 23 | 24 | // Connect to the server 25 | if err := client.Connect(); err != nil { 26 | panic(err) 27 | } 28 | 29 | // Authenticate the client using the bot token 30 | // This will send a code to the phone number if it is not already authenticated 31 | if _, err := client.Login(phoneNum); err != nil { 32 | panic(err) 33 | } 34 | 35 | // if you are using bot account, use client.Broadcast() 36 | 37 | dialogs, err := client.GetDialogs() 38 | if err != nil { 39 | panic(err) 40 | } 41 | for _, dialog := range dialogs { 42 | switch d := dialog.(type) { 43 | case *telegram.DialogObj: 44 | fmt.Println(d.TopMessage) 45 | } 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /examples/gifts/main.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/amarnathcjd/gogram/telegram" 7 | ) 8 | 9 | const ( 10 | appID = 6 11 | appHash = "YOUR_APP_HASH" 12 | phoneNum = "YOUR_PHONE_NUMBER" 13 | ) 14 | 15 | func main() { 16 | client, _ := telegram.NewClient(telegram.ClientConfig{ 17 | AppID: appID, 18 | AppHash: appHash, 19 | }) 20 | client.Conn() 21 | client.AuthPrompt() 22 | 23 | // get all your unique gifts and send the first one to a user 24 | gifts, _ := client.GetMyGifts(true) 25 | for _, gift := range gifts { 26 | gft := (*gift).(*telegram.StarGiftUnique) 27 | 28 | // transfer the gift to the user 29 | client.SendGift("roseloverx", gft.ID, "Here is a gift for you!") 30 | 31 | break 32 | } 33 | 34 | // buying new gifts and sending them to users 35 | availGifts, _ := client.PaymentsGetStarGifts(0) 36 | for _, gift := range availGifts.(*telegram.PaymentsStarGiftsObj).Gifts { 37 | gft := gift.(*telegram.StarGiftObj) 38 | 39 | // buy and send the gift 40 | client.SendNewGift("roseloverx", gft.ID, "Here is a gift for you!") 41 | 42 | break 43 | } 44 | 45 | // add a handler on receiving gifts 46 | client.AddActionHandler(func(m *telegram.NewMessage) error { 47 | if action, ok := m.Action.(*telegram.MessageActionStarGift); ok { 48 | fmt.Println("Gift received", action.Gift) 49 | } else if action, ok := m.Action.(*telegram.MessageActionStarGiftUnique); ok { 50 | fmt.Println("Unique gift received", action.Gift) 51 | } 52 | 53 | return nil 54 | }) 55 | } 56 | -------------------------------------------------------------------------------- /examples/inline/inlinebot.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "github.com/amarnathcjd/gogram/telegram" 5 | ) 6 | 7 | const ( 8 | appID = 6 9 | appHash = "YOUR_APP_HASH" 10 | botToken = "YOUR_BOT_TOKEN" 11 | ) 12 | 13 | func main() { 14 | // Create a new client 15 | client, _ := telegram.NewClient(telegram.ClientConfig{ 16 | AppID: appID, 17 | AppHash: appHash, 18 | LogLevel: telegram.LogInfo, 19 | }) 20 | 21 | // Connect to the server 22 | if err := client.Connect(); err != nil { 23 | panic(err) 24 | } 25 | 26 | // Authenticate the client using the bot token 27 | if err := client.LoginBot(botToken); err != nil { 28 | panic(err) 29 | } 30 | 31 | // Add a inline query handler 32 | client.AddInlineHandler(telegram.OnInlineQuery, HelloWorld) 33 | 34 | // Start polling 35 | client.Idle() 36 | } 37 | 38 | func HelloWorld(i *telegram.InlineQuery) error { 39 | builder := i.Builder() 40 | builder.Article("Hello World", "Hello World", "This is a test article") 41 | _, err := i.Answer(builder.Results()) 42 | return err 43 | } 44 | -------------------------------------------------------------------------------- /examples/multiple/main.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | // ExampleMultiple demonstrates how to use multiple clients in a single application. 4 | 5 | import ( 6 | "fmt" 7 | 8 | tg "github.com/amarnathcjd/gogram/telegram" 9 | ) 10 | 11 | func main() { 12 | // Create a new client with the default options 13 | client1, _ := tg.NewClient(tg.ClientConfig{ 14 | Cache: tg.NewCache("client1_cache"), 15 | Session: "client1_session", 16 | }) 17 | 18 | // Create a new client with the default options 19 | client2, _ := tg.NewClient(tg.ClientConfig{ 20 | Cache: tg.NewCache("client2_cache"), 21 | Session: "client2_session", 22 | }) 23 | 24 | client1.LoginBot("123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11") 25 | client2.LoginBot("123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11") 26 | 27 | fmt.Println(client1.GetMe()) 28 | fmt.Println(client2.GetMe()) 29 | 30 | // This way, their cache and session files are stored separately. 31 | // Now you can use both clients in your application. 32 | } 33 | -------------------------------------------------------------------------------- /examples/progress/upload.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | // Youtube DL Bot Example; 4 | // https://gist.github.com/AmarnathCJD/bfceefe9efd1a079ab151da54ef3bba2 5 | 6 | import ( 7 | "fmt" 8 | "strings" 9 | 10 | "github.com/amarnathcjd/gogram/telegram" 11 | ) 12 | 13 | const ( 14 | appID = 6 15 | apiKey = "" 16 | botToken = "" 17 | ) 18 | 19 | func main() { 20 | // create a new client object 21 | client, _ := telegram.NewClient(telegram.ClientConfig{ 22 | AppID: appID, 23 | AppHash: apiKey, 24 | }) 25 | 26 | client.LoginBot(botToken) 27 | 28 | chat, _ := client.ResolvePeer("chatId") 29 | m, _ := client.SendMessage(chat, "Starting File Upload...") 30 | 31 | client.SendMedia(chat, "", &telegram.MediaOptions{ 32 | ProgressManager: telegram.NewProgressManager(5).SetMessage(m), 33 | }) 34 | 35 | // to use custom progress manager 36 | // pm := telegram.NewProgressManager(5) 37 | // pm.EditFunc(MediaDownloadProgress("", m, pm)) 38 | // client.SendMedia(chat, "", &telegram.MediaOptions{ 39 | // ProgressManager: pm, 40 | // }) 41 | 42 | // same goes for download 43 | // &DownloadOptions{ProgressManager: NewProgressManager(5).SetMessage(m)} 44 | // &SendOptions{ProgressManager: NewProgressManager(5).SetMessage(m)} 45 | // &MediaOptions{ProgressManager: NewProgressManager(5).SetMessage(m)} 46 | } 47 | 48 | func MediaDownloadProgress(fname string, editMsg *telegram.NewMessage, pm *telegram.ProgressManager) func(atotalBytes, currentBytes int64) { 49 | return func(totalBytes int64, currentBytes int64) { 50 | text := "" 51 | text += "📄 Name: %s\n" 52 | text += "💾 File Size: %.2f MiB\n" 53 | text += "⌛️ ETA: %s\n" 54 | text += "⏱ Speed: %s\n" 55 | text += "⚙️ Progress: %s %.2f%%" 56 | 57 | size := float64(totalBytes) / 1024 / 1024 58 | eta := pm.GetETA(currentBytes) 59 | speed := pm.GetSpeed(currentBytes) 60 | percent := pm.GetProgress(currentBytes) 61 | 62 | progressbar := strings.Repeat("■", int(percent/10)) + strings.Repeat("□", 10-int(percent/10)) 63 | 64 | message := fmt.Sprintf(text, fname, size, eta, speed, progressbar, percent) 65 | editMsg.Edit(message) 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /examples/proxy/proxy.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "net/url" 6 | 7 | "github.com/amarnathcjd/gogram/telegram" 8 | ) 9 | 10 | // supported proxy types 11 | // socks5, sock4, http, https 12 | 13 | const ( 14 | appID = 6 15 | appHash = "YOUR_APP_HASH" 16 | phoneNum = "+YOUR_PHONE_NUMBER" 17 | ) 18 | 19 | func main() { 20 | socks5Proxy := &url.URL{ 21 | Scheme: "socks5", 22 | Host: "127.0.0.1:1080", 23 | // User: url.UserPassword("username", "password"), 24 | } 25 | 26 | // create a new client object 27 | client, _ := telegram.NewClient(telegram.ClientConfig{ 28 | AppID: appID, 29 | AppHash: appHash, 30 | LogLevel: telegram.LogInfo, 31 | Proxy: socks5Proxy, 32 | }) 33 | 34 | // authenticate the client using the bot token 35 | // this will send a code to the phone number if it is not already authenticated 36 | if _, err := client.Login(phoneNum); err != nil { 37 | panic(err) 38 | } 39 | 40 | // Do something with the client 41 | // ... 42 | me, err := client.GetMe() 43 | if err != nil { 44 | panic(err) 45 | } 46 | client.SendMessage("me", fmt.Sprintf("Hello, %s!", me.FirstName)) 47 | fmt.Println("Logged in as", me.Username) 48 | } 49 | -------------------------------------------------------------------------------- /examples/react/react.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/amarnathcjd/gogram/telegram" 7 | ) 8 | 9 | const ( 10 | apiKey = 6 11 | apiHash = "" 12 | botToken = "" 13 | ) 14 | 15 | func main() { 16 | // create a new client object 17 | client, _ := telegram.NewClient(telegram.ClientConfig{ 18 | AppID: apiKey, 19 | AppHash: apiHash, 20 | }) 21 | 22 | if err := client.LoginBot(botToken); err != nil { 23 | panic(err) 24 | } 25 | 26 | client.AddRawHandler(&telegram.UpdateBotMessageReaction{}, func(m telegram.Update, c *telegram.Client) error { 27 | fmt.Println(m.(*telegram.UpdateBotMessageReaction).NewReactions) 28 | return nil 29 | }) 30 | 31 | client.AddMessageHandler(telegram.OnNewMessage, func(msg *telegram.NewMessage) error { 32 | client.MessagesSendReaction(&telegram.MessagesSendReactionParams{ 33 | Big: true, 34 | AddToRecent: false, 35 | Peer: msg.Peer, 36 | MsgID: msg.ID, 37 | Reaction: []telegram.Reaction{ 38 | &telegram.ReactionEmoji{ 39 | Emoticon: "👍", 40 | }, 41 | }, 42 | }) 43 | 44 | // or 45 | 46 | // msg.React("👍") 47 | 48 | return nil 49 | }) 50 | 51 | client.Idle() 52 | } 53 | -------------------------------------------------------------------------------- /examples/sessions/pyrogram/main.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "encoding/base64" 5 | "fmt" 6 | 7 | "github.com/amarnathcjd/gogram/telegram" 8 | ) 9 | 10 | // This function decodes the Pyrogram Session String to gogram's Session Format 11 | func decodePyrogramSessionString(encodedString string) (*telegram.Session, error) { 12 | // SESSION_STRING_FORMAT: Big-endian, uint8, uint32, bool, 256-byte array, uint64, bool 13 | const ( 14 | dcIDSize = 1 // uint8 15 | apiIDSize = 4 // uint32 16 | testModeSize = 1 // bool (uint8) 17 | authKeySize = 256 18 | userIDSize = 8 // uint64 19 | isBotSize = 1 // bool (uint8) 20 | ) 21 | 22 | // Add padding to the base64 string if necessary 23 | for len(encodedString)%4 != 0 { 24 | encodedString += "=" 25 | } 26 | 27 | packedData, err := base64.URLEncoding.DecodeString(encodedString) 28 | if err != nil { 29 | return nil, fmt.Errorf("failed to decode base64 string: %w", err) 30 | } 31 | 32 | expectedSize := dcIDSize + apiIDSize + testModeSize + authKeySize + userIDSize + isBotSize 33 | if len(packedData) != expectedSize { 34 | return nil, fmt.Errorf("unexpected data length: got %d, want %d", len(packedData), expectedSize) 35 | } 36 | 37 | return &telegram.Session{ 38 | Hostname: telegram.ResolveDataCenterIP(int(uint8(packedData[0])), packedData[5] != 0, false), 39 | AppID: int32(uint32(packedData[1])<<24 | uint32(packedData[2])<<16 | uint32(packedData[3])<<8 | uint32(packedData[4])), 40 | Key: packedData[6 : 6+authKeySize], 41 | }, nil 42 | } 43 | 44 | func main() { 45 | sessionString := "" 46 | 47 | sess, err := decodePyrogramSessionString(sessionString) 48 | if err != nil { 49 | panic(err) 50 | } 51 | 52 | client, err := telegram.NewClient(telegram.ClientConfig{ 53 | //AppID: 6, // 54 | StringSession: sess.Encode(), 55 | MemorySession: true, 56 | }) 57 | 58 | if err != nil { 59 | panic(err) 60 | } 61 | 62 | me, err := client.GetMe() 63 | if err != nil { 64 | panic(err) 65 | } 66 | 67 | fmt.Println(client.JSON(me, true)) 68 | } 69 | -------------------------------------------------------------------------------- /examples/sessions/string/main.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/amarnathcjd/gogram/telegram" 7 | ) 8 | 9 | func main() { 10 | client, err := telegram.NewClient(telegram.ClientConfig{ 11 | AppID: 6, // 12 | AppHash: "YOUR_APP_HASH", // 13 | // StringSession: "", 14 | MemorySession: true, 15 | }) 16 | 17 | if err != nil { 18 | panic(err) 19 | } 20 | 21 | client.Conn() // 22 | client.AuthPrompt() // 23 | 24 | // Print the StringSession 25 | // This can be used to login without the need of reauthenticating again 26 | // 27 | // Doings so will allow Full Access to your Telegram Account 28 | fmt.Println("StringSession:", client.ExportSession()) 29 | 30 | me, err := client.GetMe() 31 | if err != nil { 32 | panic(err) 33 | } 34 | 35 | fmt.Println(client.JSON(me, true)) 36 | } 37 | -------------------------------------------------------------------------------- /examples/sessions/telethon/main.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "encoding/base64" 5 | "encoding/binary" 6 | "fmt" 7 | "net" 8 | 9 | "github.com/amarnathcjd/gogram/telegram" 10 | ) 11 | 12 | // This function decodes the Telethon Session String to gogram's Session Format 13 | // Make sure the Schema Layer of Telethon Session matches with telegram.ApiVersion value 14 | func decodeTelethonSessionString(sessionString string) (*telegram.Session, error) { 15 | data, err := base64.URLEncoding.DecodeString(sessionString[1:]) 16 | if err != nil { 17 | return nil, fmt.Errorf("failed to decode base64: %v", err) 18 | } 19 | 20 | ipLen := 4 21 | if len(data) == 352 { 22 | ipLen = 16 23 | } 24 | 25 | expectedLen := 1 + ipLen + 2 + 256 26 | if len(data) != expectedLen { 27 | return nil, fmt.Errorf("invalid session string length") 28 | } 29 | 30 | // ">B{}sH256s" 31 | offset := 1 32 | 33 | // IP Address (4 or 16 bytes based on IPv4 or IPv6) 34 | ipData := data[offset : offset+ipLen] 35 | ip := net.IP(ipData) 36 | ipAddress := ip.String() 37 | offset += ipLen 38 | 39 | // Port (2 bytes, Big Endian) 40 | port := binary.BigEndian.Uint16(data[offset : offset+2]) 41 | offset += 2 42 | 43 | // Auth Key (256 bytes) 44 | var authKey [256]byte 45 | copy(authKey[:], data[offset:offset+256]) 46 | 47 | return &telegram.Session{ 48 | Hostname: ipAddress + ":" + fmt.Sprint(port), 49 | Key: authKey[:], 50 | }, nil 51 | } 52 | 53 | func main() { 54 | sessionString := "" 55 | 56 | sess, err := decodeTelethonSessionString(sessionString) 57 | if err != nil { 58 | panic(err) 59 | } 60 | 61 | client, err := telegram.NewClient(telegram.ClientConfig{ 62 | AppID: 6, // 63 | StringSession: sess.Encode(), 64 | MemorySession: true, 65 | }) 66 | 67 | if err != nil { 68 | panic(err) 69 | } 70 | 71 | me, err := client.GetMe() 72 | if err != nil { 73 | panic(err) 74 | } 75 | 76 | fmt.Println(client.JSON(me, true)) 77 | } 78 | -------------------------------------------------------------------------------- /examples/simple/simpleauth.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | tg "github.com/amarnathcjd/gogram/telegram" 5 | ) 6 | 7 | func main() { 8 | client, _ := tg.NewClient(tg.ClientConfig{ 9 | AppID: 6, 10 | AppHash: "", 11 | }) 12 | client.Start() // this calls client.Connect() 13 | // Then asks for userInput for phone num or botToken 14 | // Further authing with that, fully automatic the auth code flow. 15 | // fmt.Println(client.ExportSession()) -> "Bwjiaw27sbss..." 16 | // client Do anything 17 | // client.Idle() 18 | } 19 | -------------------------------------------------------------------------------- /examples/stars/stars.go: -------------------------------------------------------------------------------- 1 | package examples 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/amarnathcjd/gogram/telegram" 7 | ) 8 | 9 | var paidUsers = make(map[int64]int32) 10 | 11 | func main() { 12 | bot, _ := telegram.NewClient(telegram.ClientConfig{ 13 | AppID: 123456, 14 | AppHash: "YOUR_APP_HASH", 15 | }) 16 | 17 | bot.Conn() 18 | bot.LoginBot("YOUR_BOT_TOKEN") 19 | 20 | bot.AddRawHandler(&telegram.UpdateBotPrecheckoutQuery{}, preCheckoutQueryUpd) 21 | bot.On("edit", func(m *telegram.NewMessage) error { 22 | paidUsers[m.SenderID()] = m.Invoice().ReceiptMsgID 23 | return bot.E(m.Respond("Payment Successful!")) 24 | }, telegram.FilterFunc(func(upd *telegram.NewMessage) bool { 25 | return upd.Invoice() != nil && upd.Invoice().ReceiptMsgID != 0 26 | })) 27 | 28 | bot.On("message:pay", payCmd) 29 | bot.On("message:status", statusCmd) 30 | bot.On("message:refund", refundCmd) // new type of message handlers, eg<> 31 | } 32 | 33 | func payCmd(m *telegram.NewMessage) error { 34 | invoice := telegram.InputMediaInvoice{ 35 | Title: "Test Product", 36 | Description: "Test Description", 37 | Payload: []byte(""), 38 | Invoice: &telegram.Invoice{ 39 | Test: true, 40 | Currency: "USD", 41 | Prices: []*telegram.LabeledPrice{ 42 | { 43 | Amount: 1, 44 | Label: "1 USD", 45 | }, 46 | }, 47 | }, 48 | ProviderData: &telegram.DataJson{}, 49 | } 50 | 51 | m.ReplyMedia(&invoice) 52 | return nil 53 | } 54 | 55 | func preCheckoutQueryUpd(upd telegram.Update, c *telegram.Client) error { 56 | _upd := upd.(*telegram.UpdateBotPrecheckoutQuery) 57 | c.MessagesSetBotPrecheckoutResults(true, _upd.QueryID, "Success") 58 | return nil 59 | } 60 | 61 | func statusCmd(m *telegram.NewMessage) error { 62 | if _, ok := paidUsers[m.SenderID()]; ok { 63 | return m.E(m.Respond("You have paid!")) 64 | } 65 | return m.E(m.Respond("You have not paid!")) 66 | } 67 | 68 | func refundCmd(m *telegram.NewMessage) error { 69 | if recpt_id, ok := paidUsers[m.SenderID()]; ok { 70 | delete(paidUsers, m.SenderID()) 71 | u, _ := m.Client.GetSendableUser(m.SenderID()) 72 | m.Client.PaymentsRefundStarsCharge(u, fmt.Sprintf("%d", recpt_id)) 73 | return m.E(m.Respond("Refund Successful!")) 74 | } 75 | return m.E(m.Respond("You have not paid!")) 76 | } 77 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | module github.com/amarnathcjd/gogram 2 | 3 | go 1.23 4 | 5 | require ( 6 | github.com/pkg/errors v0.9.1 7 | golang.org/x/net v0.35.0 8 | ) 9 | -------------------------------------------------------------------------------- /go.sum: -------------------------------------------------------------------------------- 1 | github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= 2 | github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= 3 | golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8= 4 | golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk= 5 | -------------------------------------------------------------------------------- /handshake.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package gogram 4 | 5 | import ( 6 | "bytes" 7 | "encoding/binary" 8 | "encoding/hex" 9 | "fmt" 10 | "math/big" 11 | "time" 12 | 13 | ige "github.com/amarnathcjd/gogram/internal/aes_ige" 14 | "github.com/amarnathcjd/gogram/internal/encoding/tl" 15 | "github.com/amarnathcjd/gogram/internal/keys" 16 | "github.com/amarnathcjd/gogram/internal/math" 17 | "github.com/amarnathcjd/gogram/internal/mtproto/objects" 18 | "github.com/amarnathcjd/gogram/internal/utils" 19 | "github.com/pkg/errors" 20 | ) 21 | 22 | // https://core.telegram.org/mtproto/auth_key 23 | func (m *MTProto) makeAuthKey() error { 24 | m.serviceModeActivated = true 25 | 26 | maxRetries := 5 27 | nonceCreate: 28 | nonceFirst := tl.RandomInt128() 29 | var ( 30 | res *objects.ResPQ 31 | err error 32 | ) 33 | 34 | if m.cdn { 35 | res, err = m.reqPQMulti(nonceFirst) 36 | } else { 37 | res, err = m.reqPQ(nonceFirst) 38 | } 39 | 40 | if err != nil { 41 | return fmt.Errorf("reqPQ: %w", err) 42 | } 43 | 44 | if nonceFirst.Cmp(res.Nonce.Int) != 0 { 45 | if maxRetries > 0 { 46 | maxRetries-- 47 | time.Sleep(200 * time.Millisecond) 48 | goto nonceCreate 49 | } 50 | return fmt.Errorf("reqPQ: nonce mismatch (%v, %v)", nonceFirst, res.Nonce) 51 | } 52 | 53 | found := false 54 | for _, b := range res.Fingerprints { 55 | if m.cdn { 56 | for _, key := range m.cdnKeys { 57 | if uint64(b) == binary.LittleEndian.Uint64(keys.RSAFingerprint(key)) { 58 | found = true 59 | m.publicKey = key 60 | break 61 | } 62 | } 63 | } 64 | if uint64(b) == binary.LittleEndian.Uint64(keys.RSAFingerprint(m.publicKey)) { 65 | found = true 66 | break 67 | } 68 | } 69 | if !found { 70 | return fmt.Errorf("reqPQ: no matching fingerprint") 71 | } 72 | 73 | // (encoding) p_q_inner_data 74 | pq := big.NewInt(0).SetBytes(res.Pq) 75 | p, q := math.Fac(pq) 76 | nonceSecond := tl.RandomInt256() 77 | nonceServer := res.ServerNonce 78 | 79 | message, err := tl.Marshal(&objects.PQInnerData{ 80 | Pq: res.Pq, 81 | P: p.Bytes(), 82 | Q: q.Bytes(), 83 | Nonce: nonceFirst, 84 | ServerNonce: nonceServer, 85 | NewNonce: nonceSecond, 86 | }) 87 | if err != nil { 88 | m.Logger.Warn("makeAuthKey: failed to marshal pq inner data") 89 | return err 90 | } 91 | 92 | hashAndMsg := make([]byte, 255) 93 | copy(hashAndMsg, append(utils.Sha1(string(message)), message...)) 94 | 95 | encryptedMessage := math.DoRSAencrypt(hashAndMsg, m.publicKey) 96 | 97 | keyFingerprint := int64(binary.LittleEndian.Uint64(keys.RSAFingerprint(m.publicKey))) 98 | dhResponse, err := m.reqDHParams(nonceFirst, nonceServer, p.Bytes(), q.Bytes(), keyFingerprint, encryptedMessage) 99 | if err != nil { 100 | return fmt.Errorf("reqDHParams: %w", err) 101 | } 102 | dhParams, ok := dhResponse.(*objects.ServerDHParamsOk) 103 | if !ok { 104 | return fmt.Errorf("reqDHParams: invalid response") 105 | } 106 | 107 | if nonceFirst.Cmp(dhParams.Nonce.Int) != 0 { 108 | return fmt.Errorf("reqDHParams: nonce mismatch") 109 | } 110 | if nonceServer.Cmp(dhParams.ServerNonce.Int) != 0 { 111 | return fmt.Errorf("reqDHParams: server nonce mismatch") 112 | } 113 | 114 | // check of hash, random bytes trail removing occurs in this func already 115 | decodedMessage, err := ige.DecryptMessageWithTempKeys(dhParams.EncryptedAnswer, nonceSecond.Int, nonceServer.Int) 116 | if err != nil { 117 | m.Logger.Debug(err.Error() + " - retrying") 118 | return m.makeAuthKey() 119 | } 120 | 121 | data, err := tl.DecodeUnknownObject(decodedMessage) 122 | if err != nil { 123 | return fmt.Errorf("decode: %w", err) 124 | } 125 | 126 | dhi, ok := data.(*objects.ServerDHInnerData) 127 | if !ok { 128 | return fmt.Errorf("decode: invalid response") 129 | } 130 | if nonceFirst.Cmp(dhi.Nonce.Int) != 0 { 131 | return fmt.Errorf("decode: nonce mismatch") 132 | } 133 | if nonceServer.Cmp(dhi.ServerNonce.Int) != 0 { 134 | return fmt.Errorf("decode: server nonce mismatch") 135 | } 136 | 137 | // this apparently is just part of diffie hellman, so just leave it as it is, hope that it will just work 138 | _, gB, gAB := math.MakeGAB(dhi.G, big.NewInt(0).SetBytes(dhi.GA), big.NewInt(0).SetBytes(dhi.DhPrime)) 139 | 140 | authKey := gAB.Bytes() 141 | if authKey[0] == 0 { 142 | authKey = authKey[1:] 143 | } 144 | 145 | m.SetAuthKey(authKey) 146 | 147 | t4 := make([]byte, 32+1+8) 148 | copy(t4[0:], nonceSecond.Bytes()) 149 | t4[32] = 1 150 | copy(t4[33:], utils.Sha1Byte(m.GetAuthKey())[0:8]) 151 | nonceHash1 := utils.Sha1Byte(t4)[4:20] 152 | salt := make([]byte, tl.LongLen) 153 | copy(salt, nonceSecond.Bytes()[:8]) 154 | math.Xor(salt, nonceServer.Bytes()[:8]) 155 | m.serverSalt = int64(binary.LittleEndian.Uint64(salt)) 156 | 157 | // (encoding) client_DH_inner_data 158 | clientDHData, err := tl.Marshal(&objects.ClientDHInnerData{ 159 | Nonce: nonceFirst, 160 | ServerNonce: nonceServer, 161 | Retry: 0, 162 | GB: gB.Bytes(), 163 | }) 164 | if err != nil { 165 | m.Logger.Warn("makeAuthKey: failed to marshal client dh inner data") 166 | return err 167 | } 168 | 169 | encryptedMessage, err = ige.EncryptMessageWithTempKeys(clientDHData, nonceSecond.Int, nonceServer.Int) 170 | if err != nil { 171 | return errors.New("dh: " + err.Error()) 172 | } 173 | 174 | dhGenStatus, err := m.setClientDHParams(nonceFirst, nonceServer, encryptedMessage) 175 | if err != nil { 176 | return errors.New("dh: " + err.Error()) 177 | } 178 | 179 | dhg, ok := dhGenStatus.(*objects.DHGenOk) 180 | if !ok { 181 | return fmt.Errorf("invalid response") 182 | } 183 | if nonceFirst.Cmp(dhg.Nonce.Int) != 0 { 184 | return fmt.Errorf("handshake: Wrong nonce: %v, %v", nonceFirst, dhg.Nonce) 185 | } 186 | if nonceServer.Cmp(dhg.ServerNonce.Int) != 0 { 187 | return fmt.Errorf("handshake: Wrong server_nonce: %v, %v", nonceServer, dhg.ServerNonce) 188 | } 189 | if !bytes.Equal(nonceHash1, dhg.NewNonceHash1.Bytes()) { 190 | return fmt.Errorf( 191 | "handshake: Wrong new_nonce_hash1: %v, %v", 192 | hex.EncodeToString(nonceHash1), 193 | hex.EncodeToString(dhg.NewNonceHash1.Bytes()), 194 | ) 195 | } 196 | 197 | m.serviceModeActivated = false 198 | m.encrypted = true 199 | if err := m.SaveSession(m.memorySession); err != nil { 200 | m.Logger.Error("saving session: ", err) 201 | } 202 | return err 203 | } 204 | -------------------------------------------------------------------------------- /internal/aes_ige/aes.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package ige 4 | 5 | import ( 6 | "bytes" 7 | "crypto/aes" 8 | "crypto/rand" 9 | "crypto/sha256" 10 | "math/big" 11 | 12 | "github.com/amarnathcjd/gogram/internal/utils" 13 | "github.com/pkg/errors" 14 | ) 15 | 16 | type AesBlock [aes.BlockSize]byte 17 | type AesKV [32]byte 18 | type AesIgeBlock [48]byte 19 | 20 | func MessageKey(authKey, msgPadded []byte, decode bool) []byte { 21 | var x int 22 | if decode { 23 | x = 8 24 | } else { 25 | x = 0 26 | } 27 | 28 | // `msg_key_large = SHA256 (substr (auth_key, 88+x, 32) + plaintext + random_padding);` 29 | var msgKeyLarge [sha256.Size]byte 30 | { 31 | h := sha256.New() 32 | 33 | substr := authKey[88+x:] 34 | _, _ = h.Write(substr[:32]) 35 | _, _ = h.Write(msgPadded) 36 | 37 | h.Sum(msgKeyLarge[:0]) 38 | } 39 | r := make([]byte, 16) 40 | // `msg_key = substr (msg_key_large, 8, 16);` 41 | copy(r, msgKeyLarge[8:8+16]) 42 | return r 43 | } 44 | 45 | func Encrypt(msg, authKey []byte) (out, msgKey []byte, _ error) { 46 | return encrypt(msg, authKey, false) 47 | } 48 | 49 | func encrypt(msg, authKey []byte, decode bool) (out, msgKey []byte, _ error) { 50 | padding := 16 + (16-(len(msg)%16))&15 51 | data := make([]byte, len(msg)+padding) 52 | n := copy(data, msg) 53 | 54 | // Fill padding using secure PRNG. 55 | // 56 | // See https://core.telegram.org/mtproto/description#encrypted-message-encrypted-data. 57 | if _, err := rand.Read(data[n:]); err != nil { 58 | return nil, nil, err 59 | } 60 | 61 | msgKey = MessageKey(authKey, data, decode) 62 | aesKey, aesIV := aesKeys(msgKey[:], authKey, decode) 63 | 64 | c, err := NewCipher(aesKey[:], aesIV[:]) 65 | if err != nil { 66 | return nil, nil, err 67 | } 68 | 69 | out = make([]byte, len(data)) 70 | if err := c.doAES256IGEencrypt(data, out); err != nil { 71 | return nil, nil, err 72 | } 73 | 74 | return out, msgKey, nil 75 | } 76 | 77 | func Decrypt(msg, authKey, checkData []byte) ([]byte, error) { 78 | return decrypt(msg, authKey, checkData, true) 79 | } 80 | 81 | func decrypt(msg, authKey, msgKey []byte, decode bool) ([]byte, error) { 82 | aesKey, aesIV := aesKeys(msgKey, authKey, decode) 83 | 84 | c, err := NewCipher(aesKey[:], aesIV[:]) 85 | if err != nil { 86 | return nil, err 87 | } 88 | 89 | out := make([]byte, len(msg)) 90 | if err := c.doAES256IGEdecrypt(msg, out); err != nil { 91 | return nil, err 92 | } 93 | 94 | return out, nil 95 | } 96 | 97 | func doAES256IGEencrypt(data, out, key, iv []byte) error { 98 | c, err := NewCipher(key, iv) 99 | if err != nil { 100 | return err 101 | } 102 | return c.doAES256IGEencrypt(data, out) 103 | } 104 | 105 | func doAES256IGEdecrypt(data, out, key, iv []byte) error { 106 | c, err := NewCipher(key, iv) 107 | if err != nil { 108 | return err 109 | } 110 | return c.doAES256IGEdecrypt(data, out) 111 | } 112 | 113 | // DecryptMessageWithTempKeys decrypts a message using temporary keys obtained during the Diffie-Hellman key exchange. 114 | func DecryptMessageWithTempKeys(msg []byte, nonceSecond, nonceServer *big.Int) ([]byte, error) { 115 | key, iv, errTemp := generateTempKeys(nonceSecond, nonceServer) 116 | if errTemp != nil { 117 | return nil, errTemp 118 | } 119 | decodedWithHash := make([]byte, len(msg)) 120 | err := doAES256IGEdecrypt(msg, decodedWithHash, key, iv) 121 | if err != nil { 122 | return nil, err 123 | } 124 | 125 | // decodedWithHash := SHA1(answer) + answer + (0-15); 16; 126 | decodedHash := decodedWithHash[:20] 127 | decodedMessage := decodedWithHash[20:] 128 | 129 | for i := len(decodedMessage) - 1; i > len(decodedMessage)-16; i-- { 130 | if bytes.Equal(decodedHash, utils.Sha1Byte(decodedMessage[:i])) { 131 | return decodedMessage[:i], nil 132 | } 133 | } 134 | 135 | return nil, errors.New("couldn't trim message: hashes incompatible on more than 16 tries") 136 | } 137 | 138 | // EncryptMessageWithTempKeys encrypts a message using temporary keys obtained during the Diffie-Hellman key exchange. 139 | func EncryptMessageWithTempKeys(msg []byte, nonceSecond, nonceServer *big.Int) ([]byte, error) { 140 | hash := utils.Sha1Byte(msg) 141 | 142 | totalLen := len(hash) + len(msg) 143 | overflowedLen := totalLen % 16 144 | needToAdd := 16 - overflowedLen 145 | 146 | msg = bytes.Join([][]byte{hash, msg, utils.RandomBytes(needToAdd)}, []byte{}) 147 | return encryptMessageWithTempKeys(msg, nonceSecond, nonceServer) 148 | } 149 | 150 | func encryptMessageWithTempKeys(msg []byte, nonceSecond, nonceServer *big.Int) ([]byte, error) { 151 | key, iv, errTemp := generateTempKeys(nonceSecond, nonceServer) 152 | if errTemp != nil { 153 | return nil, errTemp 154 | } 155 | 156 | encodedWithHash := make([]byte, len(msg)) 157 | err := doAES256IGEencrypt(msg, encodedWithHash, key, iv) 158 | if err != nil { 159 | return nil, err 160 | } 161 | 162 | return encodedWithHash, nil 163 | } 164 | 165 | // https://core.telegram.org/mtproto/auth_key#server-responds-in-two-ways 166 | // 167 | // generateTempKeys generates temporary keys for encryption during the key exchange process. 168 | func generateTempKeys(nonceSecond, nonceServer *big.Int) (key, iv []byte, err error) { 169 | if nonceSecond == nil { 170 | return nil, nil, errors.New("nonceSecond is nil") 171 | } 172 | if nonceServer == nil { 173 | return nil, nil, errors.New("nonceServer is nil") 174 | } 175 | 176 | // nonceSecond + nonceServer 177 | t1 := make([]byte, 48) 178 | copy(t1[0:], nonceSecond.Bytes()) 179 | copy(t1[32:], nonceServer.Bytes()) 180 | // SHA1 of nonceSecond + nonceServer 181 | hash1 := utils.Sha1Byte(t1) 182 | 183 | // nonceServer + nonceSecond 184 | t2 := make([]byte, 48) 185 | copy(t2[0:], nonceServer.Bytes()) 186 | copy(t2[16:], nonceSecond.Bytes()) 187 | // SHA1 of nonceServer + nonceSecond 188 | hash2 := utils.Sha1Byte(t2) 189 | 190 | // SHA1(nonceSecond + nonceServer) + substr (SHA1(nonceServer + nonceSecond), 0, 12); 191 | tmpAESKey := make([]byte, 32) 192 | // SHA1 of nonceSecond + nonceServer 193 | copy(tmpAESKey[0:], hash1) 194 | // substr (0 to 12) of SHA1 of nonceServer + nonceSecond 195 | copy(tmpAESKey[20:], hash2[0:12]) 196 | 197 | t3 := make([]byte, 64) // nonceSecond + nonceSecond 198 | copy(t3[0:], nonceSecond.Bytes()) 199 | copy(t3[32:], nonceSecond.Bytes()) 200 | hash3 := utils.Sha1Byte(t3) // SHA1 of nonceSecond + nonceSecond 201 | 202 | // substr (SHA1(server_nonce + new_nonce), 12, 8) + SHA1(new_nonce + new_nonce) + substr (new_nonce, 0, 4); 203 | tmpAESIV := make([]byte, 32) 204 | // substr (12 to 8 ) of SHA1 of nonceServer + nonceSecond 205 | copy(tmpAESIV[0:], hash2[12:12+8]) 206 | // SHA1 of nonceSecond + nonceSecond 207 | copy(tmpAESIV[8:], hash3) 208 | // substr (nonceSecond, 0, 4) 209 | copy(tmpAESIV[28:], nonceSecond.Bytes()[0:4]) 210 | 211 | return tmpAESKey, tmpAESIV, nil 212 | } 213 | -------------------------------------------------------------------------------- /internal/aes_ige/aes_common.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package ige 4 | 5 | import ( 6 | "bytes" 7 | "crypto/aes" 8 | "crypto/cipher" 9 | ) 10 | 11 | func EncryptAES(data []byte, key string) ([]byte, error) { 12 | block, err := aes.NewCipher([]byte(key)) 13 | if err != nil { 14 | return nil, err 15 | } 16 | b := pkcs5Padding(data, block.BlockSize()) 17 | blockMode := cipher.NewCBCEncrypter(block, []byte(key)[:block.BlockSize()]) 18 | crypted := make([]byte, len(b)) 19 | blockMode.CryptBlocks(crypted, b) 20 | return crypted, nil 21 | } 22 | 23 | func DecryptAES(data []byte, key string) ([]byte, error) { 24 | block, err := aes.NewCipher([]byte(key)) 25 | if err != nil { 26 | return nil, err 27 | } 28 | blockMode := cipher.NewCBCDecrypter(block, []byte(key)[:block.BlockSize()]) 29 | origData := make([]byte, len(data)) 30 | blockMode.CryptBlocks(origData, data) 31 | origData = pkcs5UnPadding(origData) 32 | return origData, nil 33 | } 34 | 35 | func pkcs5Padding(ciphertext []byte, blockSize int) []byte { 36 | padding := blockSize - len(ciphertext)%blockSize 37 | padtext := bytes.Repeat([]byte{byte(padding)}, padding) 38 | return append(ciphertext, padtext...) 39 | } 40 | 41 | func pkcs5UnPadding(origData []byte) []byte { 42 | length := len(origData) 43 | if length == 0 { 44 | return origData 45 | } 46 | unpadding := int(origData[length-1]) 47 | return origData[:(length - unpadding)] 48 | } 49 | -------------------------------------------------------------------------------- /internal/aes_ige/errors.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package ige 4 | 5 | import "github.com/pkg/errors" 6 | 7 | var ( 8 | ErrDataTooSmall = errors.New("AES256IGE: data too small") 9 | ErrDataNotDivisible = errors.New("AES256IGE: data not divisible by block size") 10 | ) 11 | -------------------------------------------------------------------------------- /internal/aes_ige/ige_cipher.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package ige 4 | 5 | import ( 6 | "crypto/aes" 7 | "crypto/cipher" 8 | "crypto/sha256" 9 | 10 | "github.com/amarnathcjd/gogram/internal/utils" 11 | "github.com/pkg/errors" 12 | ) 13 | 14 | type Cipher struct { 15 | block cipher.Block 16 | v [3]AesBlock 17 | t, x, y []byte 18 | } 19 | 20 | // NewCipher 21 | func NewCipher(key, iv []byte) (*Cipher, error) { 22 | const ( 23 | firstBlock = iota 24 | secondBlock 25 | thirdBlock 26 | ) 27 | 28 | var err error 29 | 30 | c := new(Cipher) 31 | c.block, err = aes.NewCipher(key) 32 | if err != nil { 33 | return nil, errors.Wrap(err, "creating new cipher") 34 | } 35 | 36 | c.t = c.v[firstBlock][:] 37 | c.x = c.v[secondBlock][:] 38 | c.y = c.v[thirdBlock][:] 39 | copy(c.x, iv[:aes.BlockSize]) 40 | copy(c.y, iv[aes.BlockSize:]) 41 | 42 | return c, nil 43 | } 44 | 45 | func (c *Cipher) doAES256IGEencrypt(in, out []byte) error { //nolint:dupl 46 | if err := isCorrectData(in); err != nil { 47 | return err 48 | } 49 | 50 | for i := 0; i < len(in); i += aes.BlockSize { 51 | utils.Xor(c.x, in[i:i+aes.BlockSize]) 52 | c.block.Encrypt(c.t, c.x) 53 | utils.Xor(c.t, c.y) 54 | c.x, c.y = c.t, in[i:i+aes.BlockSize] 55 | copy(out[i:], c.t) 56 | } 57 | return nil 58 | } 59 | 60 | func (c *Cipher) doAES256IGEdecrypt(in, out []byte) error { //nolint:dupl 61 | if err := isCorrectData(in); err != nil { 62 | return err 63 | } 64 | 65 | for i := 0; i < len(in); i += aes.BlockSize { 66 | utils.Xor(c.y, in[i:i+aes.BlockSize]) 67 | c.block.Decrypt(c.t, c.y) 68 | utils.Xor(c.t, c.x) 69 | c.y, c.x = c.t, in[i:i+aes.BlockSize] 70 | copy(out[i:], c.t) 71 | } 72 | return nil 73 | } 74 | 75 | func isCorrectData(data []byte) error { 76 | if len(data) < aes.BlockSize { 77 | return ErrDataTooSmall 78 | } 79 | if len(data)%aes.BlockSize != 0 { 80 | return ErrDataNotDivisible 81 | } 82 | return nil 83 | } 84 | 85 | // -------------------------------------------------------------------------------------------------- 86 | 87 | func aesKeys(msgKey, authKey []byte, decode bool) (aesKey, aesIv [32]byte) { 88 | var x int 89 | if decode { 90 | x = 8 91 | } else { 92 | x = 0 93 | } 94 | 95 | // aes_key = substr (sha256_a, 0, 8) + substr (sha256_b, 8, 16) + substr (sha256_a, 24, 8); 96 | computeAesKey := func(sha256a, sha256b []byte) (v [32]byte) { 97 | n := copy(v[:], sha256a[:8]) 98 | n += copy(v[n:], sha256b[8:16+8]) 99 | copy(v[n:], sha256a[24:24+8]) 100 | return v 101 | } 102 | // aes_iv = substr (sha256_b, 0, 8) + substr (sha256_a, 8, 16) + substr (sha256_b, 24, 8); 103 | computeAesIV := func(sha256b, sha256a []byte) (v [32]byte) { 104 | n := copy(v[:], sha256a[:8]) 105 | n += copy(v[n:], sha256b[8:16+8]) 106 | copy(v[n:], sha256a[24:24+8]) 107 | return v 108 | } 109 | 110 | var sha256a, sha256b [256]byte 111 | // sha256_a = SHA256 (msg_key + substr (auth_key, x, 36)); 112 | { 113 | h := sha256.New() 114 | 115 | _, _ = h.Write(msgKey) 116 | _, _ = h.Write(authKey[x : x+36]) 117 | 118 | h.Sum(sha256a[:0]) 119 | } 120 | // sha256_b = SHA256 (substr (auth_key, 40+x, 36) + msg_key); 121 | { 122 | h := sha256.New() 123 | 124 | substr := authKey[40+x:] 125 | _, _ = h.Write(substr[:36]) 126 | _, _ = h.Write(msgKey) 127 | 128 | h.Sum(sha256b[:0]) 129 | } 130 | 131 | return computeAesKey(sha256a[:], sha256b[:]), computeAesIV(sha256a[:], sha256b[:]) 132 | } 133 | -------------------------------------------------------------------------------- /internal/aes_ige/password.go: -------------------------------------------------------------------------------- 1 | package ige 2 | 3 | import ( 4 | "crypto/hmac" 5 | "crypto/rand" 6 | "crypto/sha256" 7 | "crypto/sha512" 8 | "hash" 9 | "math/big" 10 | 11 | "github.com/pkg/errors" 12 | ) 13 | 14 | func GetInputCheckPassword(password string, srpB []byte, mp *ModPow, random []byte) (*SrpAnswer, error) { 15 | if password == "" { 16 | return nil, nil 17 | } 18 | err := validateCurrentAlgo(srpB, mp) 19 | if err != nil { 20 | return nil, errors.Wrap(err, "validating CurrentAlgo") 21 | } 22 | p := BytesToBig(mp.P) 23 | g := big.NewInt(int64(mp.G)) 24 | gBytes := Pad256(g.Bytes()) 25 | a := BytesToBig(random) 26 | ga := Pad256(BigExp(g, a, p).Bytes()) 27 | gb := Pad256(srpB) 28 | u := BytesToBig(calcSHA256(ga, gb)) 29 | x := BytesToBig(PasswordHash2([]byte(password), mp.Salt1, mp.Salt2)) 30 | v := BigExp(g, x, p) 31 | k := BytesToBig(calcSHA256(mp.P, gBytes)) 32 | kv := k.Mul(k, v).Mod(k, p) 33 | t := BytesToBig(srpB) 34 | if t.Sub(t, kv).Cmp(big.NewInt(0)) == -1 { 35 | t.Add(t, p) 36 | } 37 | 38 | sa := Pad256(BigExp(t, u.Mul(u, x).Add(u, a), p).Bytes()) 39 | 40 | ka := calcSHA256(sa) 41 | 42 | M1 := calcSHA256( 43 | BytesXor(calcSHA256(mp.P), calcSHA256(gBytes)), 44 | calcSHA256(mp.Salt1), 45 | calcSHA256(mp.Salt2), 46 | ga, 47 | gb, 48 | ka, 49 | ) 50 | 51 | return &SrpAnswer{ 52 | GA: ga, 53 | M1: M1, 54 | }, nil 55 | } 56 | 57 | type ModPow struct { 58 | Salt1 []byte 59 | Salt2 []byte 60 | G int32 61 | P []byte 62 | } 63 | 64 | type SrpAnswer struct { 65 | GA []byte 66 | M1 []byte 67 | } 68 | 69 | func validateCurrentAlgo(srpB []byte, mp *ModPow) error { 70 | if dhHandshakeCheckConfigIsError(mp.G, mp.P) { 71 | return errors.New("receive invalid config g") 72 | } 73 | 74 | p := BytesToBig(mp.P) 75 | gb := BytesToBig(srpB) 76 | 77 | if big.NewInt(0).Cmp(gb) != -1 || gb.Cmp(p) != -1 || len(srpB) < 248 || len(srpB) > 256 { 78 | return errors.New("receive invalid value of B") 79 | } 80 | 81 | return nil 82 | } 83 | 84 | func saltingHashing(data, salt []byte) []byte { 85 | return calcSHA256(salt, data, salt) 86 | } 87 | 88 | func passwordHash1(password, salt1, salt2 []byte) []byte { 89 | return saltingHashing(saltingHashing(password, salt1), salt2) 90 | } 91 | 92 | func PasswordHash2(password, salt1, salt2 []byte) []byte { 93 | return saltingHashing(pbkdf2sha512(passwordHash1(password, salt1, salt2), salt1, 100000), salt2) 94 | } 95 | 96 | func pbkdf2sha512(hash1, salt1 []byte, i int) []byte { 97 | return AlgoKey(hash1, salt1, i, 64, sha512.New) 98 | } 99 | 100 | func Pad256(b []byte) []byte { 101 | if len(b) >= 256 { 102 | return b[len(b)-256:] 103 | } 104 | 105 | tmp := make([]byte, 256) 106 | copy(tmp[256-len(b):], b) 107 | 108 | return tmp 109 | } 110 | 111 | func calcSHA256(arrays ...[]byte) []byte { 112 | h := sha256.New() 113 | for _, arr := range arrays { 114 | h.Write(arr) 115 | } 116 | return h.Sum(nil) 117 | } 118 | 119 | func BytesToBig(b []byte) *big.Int { 120 | return new(big.Int).SetBytes(b) 121 | } 122 | 123 | func BigExp(x, y, m *big.Int) *big.Int { 124 | return new(big.Int).Exp(x, y, m) 125 | } 126 | 127 | func dhHandshakeCheckConfigIsError(_ int32, _ []byte) bool { 128 | return false 129 | } 130 | 131 | func AlgoKey(password, salt []byte, iter, keyLen int, h func() hash.Hash) []byte { 132 | prf := hmac.New(h, password) 133 | hashLen := prf.Size() 134 | numBlocks := (keyLen + hashLen - 1) / hashLen 135 | 136 | var buf [4]byte 137 | dk := make([]byte, 0, numBlocks*hashLen) 138 | U := make([]byte, hashLen) 139 | for block := 1; block <= numBlocks; block++ { 140 | prf.Reset() 141 | prf.Write(salt) 142 | buf[0] = byte(block >> 24) 143 | buf[1] = byte(block >> 16) 144 | buf[2] = byte(block >> 8) 145 | buf[3] = byte(block) 146 | prf.Write(buf[:4]) 147 | dk = prf.Sum(dk) 148 | T := dk[len(dk)-hashLen:] 149 | copy(U, T) 150 | 151 | for n := 2; n <= iter; n++ { 152 | prf.Reset() 153 | prf.Write(U) 154 | U = U[:0] 155 | U = prf.Sum(U) 156 | for x := range U { 157 | T[x] ^= U[x] 158 | } 159 | } 160 | } 161 | return dk[:keyLen] 162 | } 163 | 164 | func BytesXor(a, b []byte) []byte { 165 | res := make([]byte, len(a)) 166 | copy(res, a) 167 | for i := range res { 168 | res[i] ^= b[i] 169 | } 170 | return res 171 | } 172 | 173 | func RandomBytes(size int) []byte { 174 | b := make([]byte, size) 175 | _, _ = rand.Read(b) 176 | return b 177 | } 178 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/gen/common.go: -------------------------------------------------------------------------------- 1 | package gen 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/dave/jennifer/jen" 7 | 8 | "github.com/amarnathcjd/gogram/internal/cmd/tlgen/tlparser" 9 | ) 10 | 11 | func (*Generator) generateMethodCallerFunc(method tlparser.Method) *jen.Statement { 12 | resp := createParamsStructFromMethod(method) 13 | maximumPositionalArguments := 0 14 | if haveOptionalParams(resp.Parameters) { 15 | maximumPositionalArguments++ 16 | } 17 | 18 | funcParameters := make([]jen.Code, 0) 19 | methodName := goify(method.Name, true) 20 | typeName := methodName + "Params" 21 | 22 | argsAsSingleItem := false 23 | if len(resp.Parameters) > maximumPositionalArguments { 24 | argsAsSingleItem = true 25 | funcParameters = []jen.Code{jen.Id("params").Id("*" + typeName)} 26 | } 27 | 28 | parameters := jen.Dict{} 29 | for _, arg := range funcParameters { 30 | parameters[arg] = arg 31 | } 32 | 33 | requestStruct := jen.Op("&").Id(typeName).Values(parameters) 34 | if argsAsSingleItem { 35 | requestStruct = jen.Id("params") 36 | } 37 | 38 | assertedType := goify(method.Response.Type, true) 39 | //firstErrorReturn := jen.Code(jen.Nil()) 40 | if assertedType == "Bool" { 41 | assertedType = "bool" 42 | //firstErrorReturn = jen.False() 43 | } 44 | if assertedType == "Long" { 45 | assertedType = "int64" 46 | //firstErrorReturn = jen.Lit(0) 47 | } 48 | if assertedType == "Int" { 49 | assertedType = "int" 50 | //firstErrorReturn = jen.Lit(0) 51 | } 52 | if assertedType == "int256" { 53 | assertedType = "*tl.Int256" 54 | } 55 | 56 | if method.Response.IsList { 57 | assertedType = "[]" + assertedType 58 | } 59 | 60 | return jen.Func().Params(jen.Id("c").Id("*Client")).Id(methodName).Params(funcParameters...).Params(jen.Id(assertedType), jen.Error()).Block( 61 | jen.Var().Id("resp").Id(assertedType), 62 | jen.Err().Op(":=").Id("c.MakeRequest").Call(requestStruct, jen.Id("&resp")), 63 | jen.Return(jen.Id("resp"), jen.Err()), 64 | ) 65 | } 66 | 67 | func createCrcFunc(typ string, crc uint32) *jen.Statement { 68 | hex := fmt.Sprintf("0x%x", crc) 69 | return jen.Func().Params(jen.Id(typ)).Id("CRC").Params().Uint32(). 70 | Id("{" + jen.Return(jen.Id(hex)).GoString() + "}") 71 | } 72 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/gen/gen.go: -------------------------------------------------------------------------------- 1 | package gen 2 | 3 | import ( 4 | "bytes" 5 | "fmt" 6 | "os" 7 | "path/filepath" 8 | 9 | "github.com/dave/jennifer/jen" 10 | "github.com/pkg/errors" 11 | 12 | "github.com/amarnathcjd/gogram/internal/cmd/tlgen/tlparser" 13 | ) 14 | 15 | var capitalizePatterns = []string{ 16 | "id", 17 | "api", 18 | "url", 19 | "p2p", 20 | "sha", 21 | "srp", 22 | } 23 | 24 | type Generator struct { 25 | schema *internalSchema 26 | outdir string 27 | 28 | PackageName string 29 | PackageHeader string 30 | } 31 | 32 | func NewGenerator(tlschema *tlparser.Schema, licenseHeader, outdir string) (*Generator, error) { 33 | internalSchema, err := createInternalSchema(tlschema) 34 | if err != nil { 35 | return nil, errors.Wrap(err, "analyzing schema") 36 | } 37 | 38 | return &Generator{ 39 | schema: internalSchema, 40 | outdir: outdir, 41 | PackageName: "telegram", 42 | PackageHeader: licenseHeader + "\nCode generated by tlgen; DO NOT EDIT.", 43 | }, nil 44 | } 45 | 46 | func (g *Generator) Generate(d bool) error { 47 | err := g.generateFile(g.generateEnumDefinitions, filepath.Join(g.outdir, "enums_gen.go"), d) 48 | if err != nil { 49 | return fmt.Errorf("generate enums: %w", err) 50 | } 51 | 52 | err = g.generateFile(g.generateSpecificStructs, filepath.Join(g.outdir, "types_gen.go"), d) 53 | if err != nil { 54 | return fmt.Errorf("generate types: %w", err) 55 | } 56 | 57 | err = g.generateFile(g.generateInterfaces, filepath.Join(g.outdir, "interfaces_gen.go"), d) 58 | if err != nil { 59 | return fmt.Errorf("generate interfaces: %w", err) 60 | } 61 | 62 | err = g.generateFile(g.generateMethods, filepath.Join(g.outdir, "methods_gen.go"), d) 63 | if err != nil { 64 | return fmt.Errorf("generate methods: %w", err) 65 | } 66 | 67 | err = g.generateFile(g.generateInit, filepath.Join(g.outdir, "init_gen.go"), d) 68 | if err != nil { 69 | return fmt.Errorf("generate init: %w", err) 70 | } 71 | 72 | return nil 73 | } 74 | 75 | func (*Generator) generateFile(f func(file *jen.File, d bool), filename string, genDocs bool) error { 76 | file := jen.NewFile("telegram") 77 | file.HeaderComment("Code generated by TLParser; DO NOT EDIT. (c) @amarnathcjd") 78 | f(file, genDocs) 79 | 80 | buf := bytes.NewBuffer([]byte{}) 81 | if err := file.Render(buf); err != nil { 82 | return err 83 | } 84 | 85 | return os.WriteFile(filename, buf.Bytes(), 0600) 86 | } 87 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/gen/schema.go: -------------------------------------------------------------------------------- 1 | package gen 2 | 3 | import ( 4 | "strings" 5 | 6 | "github.com/amarnathcjd/gogram/internal/cmd/tlgen/tlparser" 7 | ) 8 | 9 | type goifiedName = string 10 | type nativeName = string 11 | 12 | type internalSchema struct { 13 | InterfaceCommnets map[nativeName]string 14 | Types map[nativeName][]tlparser.Object 15 | SingleInterfaceTypes []tlparser.Object 16 | Enums map[nativeName][]enum 17 | Methods []tlparser.Method 18 | } 19 | 20 | type enum struct { 21 | Name nativeName 22 | CRC uint32 23 | } 24 | 25 | func createInternalSchema(nativeSchema *tlparser.Schema) (*internalSchema, error) { 26 | internalSchema := &internalSchema{ 27 | InterfaceCommnets: make(map[string]string), 28 | Enums: make(map[string][]enum), 29 | Types: make(map[string][]tlparser.Object), 30 | SingleInterfaceTypes: make([]tlparser.Object, 0), 31 | Methods: make([]tlparser.Method, 0), 32 | } 33 | 34 | reversedObjects := make(map[string][]tlparser.Object) 35 | for _, obj := range nativeSchema.Objects { 36 | if reversedObjects[obj.Interface] == nil { 37 | reversedObjects[obj.Interface] = make([]tlparser.Object, 0) 38 | } 39 | 40 | reversedObjects[obj.Interface] = append(reversedObjects[obj.Interface], obj) 41 | } 42 | 43 | for interfaceName, objects := range reversedObjects { 44 | for _, obj := range objects { 45 | if strings.EqualFold(obj.Name, obj.Interface) { 46 | obj.Name += "Obj" 47 | } 48 | } 49 | 50 | if interfaceIsEnum(objects) { 51 | enums := make([]enum, len(objects)) 52 | for i, obj := range objects { 53 | enums[i] = enum{ 54 | Name: obj.Name, 55 | CRC: obj.CRC, 56 | } 57 | } 58 | 59 | internalSchema.Enums[interfaceName] = enums 60 | continue 61 | } 62 | 63 | if len(objects) == 1 { 64 | internalSchema.SingleInterfaceTypes = append(internalSchema.SingleInterfaceTypes, objects[0]) 65 | // delete(reversedObjects, interfaceName) 66 | continue 67 | } 68 | 69 | internalSchema.Types[interfaceName] = objects 70 | } 71 | 72 | internalSchema.Methods = nativeSchema.Methods 73 | internalSchema.InterfaceCommnets = nativeSchema.TypeComments 74 | return internalSchema, nil 75 | } 76 | 77 | func (g *Generator) getAllConstructors() (structs, enums []goifiedName) { 78 | structs, enums = make([]string, 0), make([]string, 0) 79 | 80 | for _, items := range g.schema.Types { 81 | for _, _struct := range items { 82 | t := goify(_struct.Name, true) 83 | if goify(_struct.Name, true) == goify(_struct.Interface, true) { 84 | t = goify(_struct.Name+"Obj", true) 85 | } 86 | structs = append(structs, t) 87 | } 88 | } 89 | for _, _struct := range g.schema.SingleInterfaceTypes { 90 | structs = append(structs, goify(_struct.Name, true)) 91 | } 92 | for _, method := range g.schema.Methods { 93 | structs = append(structs, goify(method.Name+"Params", true)) 94 | } 95 | 96 | for _, items := range g.schema.Enums { 97 | for _, enum := range items { 98 | enums = append(enums, goify(enum.Name, true)) 99 | } 100 | } 101 | 102 | return structs, enums 103 | } 104 | 105 | func interfaceIsEnum(in []tlparser.Object) bool { 106 | for _, obj := range in { 107 | if len(obj.Parameters) > 0 { 108 | return false 109 | } 110 | } 111 | 112 | return true 113 | } 114 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/gen/tl_gen_enums.go: -------------------------------------------------------------------------------- 1 | package gen 2 | 3 | import ( 4 | "fmt" 5 | "sort" 6 | 7 | "github.com/dave/jennifer/jen" 8 | ) 9 | 10 | func (g *Generator) generateEnumDefinitions(file *jen.File, _ bool) { 11 | enumTypes := make([]string, len(g.schema.Enums)) 12 | enumIndex := 0 13 | for _type := range g.schema.Enums { 14 | enumTypes[enumIndex] = _type 15 | enumIndex++ 16 | } 17 | 18 | sort.Strings(enumTypes) 19 | 20 | for _, enumType := range enumTypes { 21 | values := g.schema.Enums[enumType] 22 | sort.Slice(values, func(i, j int) bool { 23 | return values[i].Name < values[j].Name 24 | }) 25 | 26 | file.Add(g.generateSpecificEnum(enumType, values)...) 27 | } 28 | } 29 | 30 | func (*Generator) generateSpecificEnum(enumType string, enumValues []enum) []jen.Code { 31 | total := make([]jen.Code, 0) 32 | 33 | typeID := goify(enumType, true) 34 | 35 | enumDef := jen.Type().Id(typeID).Uint32() 36 | total = append(total, enumDef, jen.Line()) 37 | 38 | opc := make([]jen.Code, len(enumValues)) 39 | cases := make([]jen.Code, len(enumValues)) 40 | for i, id := range enumValues { 41 | name := goify(id.Name, true) 42 | 43 | opc[i] = jen.Id(name).Id(typeID).Op("=").Id(fmt.Sprintf("%#v", id.CRC)) 44 | cases[i] = jen.Case(jen.Id(typeID).Call(jen.Id(fmt.Sprintf("%#v", id.CRC)))).Block(jen.Return(jen.Lit(id.Name))) 45 | } 46 | 47 | total = append(total, jen.Const().Defs(opc...), jen.Line()) 48 | 49 | cases = append(cases, jen.Default().Block(jen.Return(jen.Lit("")))) 50 | 51 | stringFunc := jen.Func().Params(jen.Id("e").Id(typeID)).Id("String").Params().String().Block( 52 | jen.Switch(jen.Id("e")).Block(cases...), 53 | ) 54 | 55 | crcFunc := jen.Func().Params(jen.Id("e").Id(typeID)).Id("CRC").Params().Uint32(). 56 | Id("{ return uint32(e) }") 57 | 58 | total = append(total, 59 | stringFunc, 60 | jen.Line(), 61 | jen.Line(), 62 | crcFunc, 63 | jen.Line(), 64 | jen.Line(), 65 | ) 66 | 67 | return total 68 | } 69 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/gen/tl_gen_init.go: -------------------------------------------------------------------------------- 1 | package gen 2 | 3 | import ( 4 | "sort" 5 | 6 | "github.com/dave/jennifer/jen" 7 | ) 8 | 9 | var tlPackagePath = "github.com/amarnathcjd/gogram/internal/encoding/tl" 10 | var errorsPackagePath = "github.com/pkg/errors" 11 | 12 | func (g *Generator) generateInit(file *jen.File, _ bool) { 13 | structs, enums := g.getAllConstructors() 14 | 15 | initFunc := jen.Func().Id("init").Params().Block( 16 | g.createInitStructs(structs...), 17 | jen.Line(), 18 | g.createInitEnums(enums...), 19 | ) 20 | 21 | file.Add(initFunc) 22 | } 23 | 24 | func (*Generator) createInitStructs(itemNames ...string) jen.Code { 25 | sort.Strings(itemNames) 26 | 27 | structs := make([]jen.Code, len(itemNames)) 28 | for i, item := range itemNames { 29 | structs[i] = jen.Op("&").Id(item).Block() 30 | } 31 | 32 | return jen.Qual(tlPackagePath, "RegisterObjects").Call( 33 | structs..., 34 | ) 35 | } 36 | 37 | func (*Generator) createInitEnums(itemNames ...string) jen.Code { 38 | sort.Strings(itemNames) 39 | 40 | enums := make([]jen.Code, len(itemNames)) 41 | for i, item := range itemNames { 42 | enums[i] = jen.Id(item) 43 | } 44 | 45 | return jen.Qual(tlPackagePath, "RegisterEnums").Call( 46 | enums..., 47 | ) 48 | } 49 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/gen/tl_gen_interfaces.go: -------------------------------------------------------------------------------- 1 | package gen 2 | 3 | import ( 4 | "sort" 5 | "sync" 6 | 7 | "github.com/amarnathcjd/gogram/internal/cmd/tlgen/tlparser" 8 | "github.com/dave/jennifer/jen" 9 | ) 10 | 11 | func (g *Generator) generateInterfaces(f *jen.File, d bool) { 12 | keys := make([]string, 0, len(g.schema.Types)) 13 | for key := range g.schema.Types { 14 | keys = append(keys, key) 15 | } 16 | sort.Strings(keys) 17 | 18 | // wg := sync.WaitGroup{} 19 | // for _, key := range keys { 20 | // structs := g.schema.Types[key] 21 | 22 | // fmt.Println("Gk", key) 23 | // wg.Add(1) 24 | // go func(structs []tlparser.Object, key string) { 25 | // defer wg.Done() 26 | // for j, _type := range structs { 27 | // go func(_type tlparser.Object, j int, key string) { 28 | // g.schema.Types[key][j].Comment = g.generateComment(_type.Name, "constructor") 29 | 30 | // fmt.Println("Gk", key, "Comment", g.schema.Types[key][j].Comment) 31 | // }(_type, j, key) 32 | // } 33 | // }(structs, key) 34 | // } 35 | 36 | // wg.Wait() 37 | 38 | for _, i := range keys { 39 | f.Add(jen.Type().Id(goify(i, true)).Interface( 40 | jen.Qual(tlPackagePath, "Object"), 41 | jen.Id("Implements"+goify(i, true)).Params(), 42 | )) 43 | 44 | structs := g.schema.Types[i] 45 | 46 | sort.Slice(structs, func(i, j int) bool { 47 | return structs[i].Name < structs[j].Name 48 | }) 49 | 50 | if d { 51 | wg := sync.WaitGroup{} 52 | for i, _type := range structs { 53 | wg.Add(1) 54 | go func(_type tlparser.Object, i int) { 55 | defer wg.Done() 56 | comment, pComments := g.generateComment(_type.Name, "constructor") 57 | structs[i].Comment = comment 58 | 59 | if pComments != nil && len(pComments) == len(_type.Parameters) { 60 | for j := range _type.Parameters { 61 | pComments[j] = cleanComment(pComments[j]) 62 | structs[i].Parameters[j].Comment = pComments[j] 63 | } 64 | } 65 | }(_type, i) 66 | } 67 | 68 | wg.Wait() 69 | } 70 | 71 | for _, _type := range structs { 72 | if goify(_type.Name, true) == goify(i, true) { 73 | _type.Name += "Obj" 74 | } 75 | 76 | f.Add(g.generateStructTypeAndMethods(_type, []string{goify(i, true)})) 77 | f.Line() 78 | } 79 | } 80 | } 81 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/gen/tl_gen_methods.go: -------------------------------------------------------------------------------- 1 | package gen 2 | 3 | import ( 4 | "io" 5 | "log" 6 | "net/http" 7 | "regexp" 8 | "sort" 9 | "strings" 10 | "sync" 11 | 12 | "github.com/dave/jennifer/jen" 13 | 14 | "github.com/amarnathcjd/gogram/internal/cmd/tlgen/tlparser" 15 | ) 16 | 17 | var maximumPositionalArguments = 5 18 | 19 | func (g *Generator) generateMethods(f *jen.File, d bool) { 20 | sort.Slice(g.schema.Methods, func(i, j int) bool { 21 | return g.schema.Methods[i].Name < g.schema.Methods[j].Name 22 | }) 23 | 24 | if d { 25 | wg := sync.WaitGroup{} 26 | for i, method := range g.schema.Methods { 27 | wg.Add(1) 28 | go func(method tlparser.Method, i int) { 29 | defer wg.Done() 30 | g.schema.Methods[i].Comment, _ = g.generateComment(method.Name, "method") 31 | }(method, i) 32 | } 33 | 34 | wg.Wait() 35 | } 36 | 37 | for _, method := range g.schema.Methods { 38 | 39 | f.Add(g.generateStructTypeAndMethods(tlparser.Object{ 40 | Name: method.Name + "Params", 41 | Comment: "", 42 | CRC: method.CRC, 43 | Parameters: method.Parameters, 44 | }, nil)) 45 | f.Line() 46 | if method.Comment != "" { 47 | f.Comment(method.Comment) 48 | } 49 | f.Add(g.generateMethodFunction(&method)) 50 | f.Line() 51 | } 52 | 53 | // sort.Strings(keys) 54 | // 55 | // for _, i := range keys { 56 | // structs := g.schema.Types[i] 57 | // 58 | // sort.Slice(structs, func(i, j int) bool { 59 | // return structs[i].Name < structs[j].Name 60 | // }) 61 | // 62 | // for _, _type := range structs { 63 | // f.Add(g.generateStructTypeAndMethods(_type, []string{goify(i, true)})) 64 | // f.Line() 65 | // } 66 | // } 67 | } 68 | 69 | func (g *Generator) generateComment(name, _type string) (string, []string) { 70 | var base = "https://corefork.telegram.org/" + _type + "/" 71 | req, _ := http.NewRequest("GET", base+name, http.NoBody) 72 | log.Println("tlgen: fetching", req.URL.String()) 73 | 74 | resp, err := http.DefaultClient.Do(req) 75 | if err != nil { 76 | return "", nil 77 | } 78 | 79 | if resp.StatusCode != 200 { 80 | return "", nil 81 | } 82 | 83 | body, err := io.ReadAll(resp.Body) 84 | if err != nil { 85 | return "", nil 86 | } 87 | 88 | ack := string(body) 89 | 90 | matches := regexTableTag.FindAllStringSubmatch(ack, -1) 91 | 92 | var descs []string 93 | 94 | for _, match := range matches { 95 | descs = append(descs, match[1]) 96 | } 97 | 98 | ack = strings.Split(ack, "
")[1] 99 | ack = strings.Split(ack, "

")[0] 100 | ack = strings.ReplaceAll(ack, "

", "") 101 | //ack = strings.ReplaceAll(ack, "see .", "") 102 | ack = regexLinkTag.ReplaceAllString(ack, "[$2](https://corefork.telegram.org$1)") 103 | ack = regexp.MustCompile(`\[(.*?)\]\(.*?\)`).ReplaceAllString(ack, "$1") 104 | 105 | ack = regexCodeTag.ReplaceAllString(ack, "`$1`") 106 | 107 | ack = strings.TrimSpace(ack) 108 | 109 | if strings.Contains(ack, "The page has not been saved") { 110 | return "", nil 111 | } 112 | 113 | if strings.Contains(ack, `

    `) { 114 | return "", nil 115 | } 116 | 117 | return ack, descs 118 | } 119 | 120 | func (g *Generator) generateMethodFunction(obj *tlparser.Method) jen.Code { 121 | resp := g.typeIdFromSchemaType(obj.Response.Type) 122 | if obj.Response.IsList { 123 | resp = jen.Index().Add(resp) 124 | } 125 | 126 | nuk := jen.Nil() 127 | if obj.Response.Type == "Bool" { 128 | resp = jen.Op("").Qual("", "bool") 129 | nuk = jen.Bool() 130 | } 131 | 132 | responses := []jen.Code{resp, jen.Error()} 133 | 134 | // data, err := c.MakeRequest(params) 135 | // if err != nil { 136 | // return nil, errors.Wrap(err, "sedning AuthSendCode") 137 | // } 138 | // 139 | // resp, ok := data.(*AuthSentCode) 140 | // if !ok { 141 | // panic("got invalid response type: " + reflect.TypeOf(data).String()) 142 | // } 143 | // 144 | // return resp, nil 145 | 146 | method := jen.Func().Params(jen.Id("c").Op("*").Id("Client")).Id(goify(obj.Name, true)).Params(g.generateArgumentsForMethod(obj)...).Params(responses...).Block( 147 | jen.List(jen.Id("responseData"), jen.Id("err")).Op(":=").Id("c").Dot("MakeRequest").Call(g.generateMethodArgumentForMakingRequest(obj)), 148 | jen.If(jen.Err().Op("!=").Nil()).Block( 149 | jen.Return(nuk, jen.Qual(errorsPackagePath, "Wrap").Call(jen.Err(), jen.Lit("sending "+goify(obj.Name, true)))), 150 | ), 151 | jen.Line(), 152 | jen.List(jen.Id("resp"), jen.Id("ok")).Op(":=").Id("responseData").Assert(resp), 153 | jen.If(jen.Op("!").Id("ok")).Block( 154 | jen.Panic(jen.Lit("got invalid response type: ").Op("+").Qual("reflect", "TypeOf").Call(jen.Id("responseData")).Dot("String").Call()), 155 | ), 156 | jen.Return(jen.Id("resp"), jen.Nil()), 157 | ) 158 | 159 | return method 160 | } 161 | 162 | func (g *Generator) generateArgumentsForMethod(obj *tlparser.Method) []jen.Code { 163 | if len(obj.Parameters) == 0 { 164 | return []jen.Code{} 165 | } 166 | if len(obj.Parameters) > maximumPositionalArguments { 167 | return []jen.Code{jen.Id("params").Op("*").Id(goify(obj.Name, true) + "Params")} 168 | } 169 | 170 | items := make([]jen.Code, 0) 171 | 172 | for i, p := range obj.Parameters { 173 | item := jen.Id(goify(p.Name, false)) 174 | if i == len(obj.Parameters)-1 || p.Type != obj.Parameters[i+1].Type || p.IsVector != obj.Parameters[i+1].IsVector { 175 | if p.Type == "bitflags" { 176 | continue 177 | } 178 | 179 | if p.IsVector { 180 | item = item.Add(jen.Index(), g.typeIdFromSchemaType(p.Type)) 181 | } else { 182 | item = item.Add(g.typeIdFromSchemaType(p.Type)) 183 | } 184 | } 185 | 186 | items = append(items, item) 187 | } 188 | return items 189 | } 190 | 191 | func (g *Generator) generateMethodArgumentForMakingRequest(obj *tlparser.Method) *jen.Statement { 192 | if len(obj.Parameters) > maximumPositionalArguments { 193 | return jen.Id("params") 194 | } 195 | 196 | dict := jen.Dict{} 197 | for _, p := range obj.Parameters { 198 | if p.Type == "bitflags" { 199 | continue 200 | } 201 | 202 | dict[jen.Id(goify(p.Name, true))] = jen.Id(goify(p.Name, false)) 203 | } 204 | 205 | return jen.Op("&").Id(goify(obj.Name, true) + "Params").Values(dict) 206 | } 207 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/gen/tl_gen_structs.go: -------------------------------------------------------------------------------- 1 | package gen 2 | 3 | import ( 4 | "fmt" 5 | "sort" 6 | "sync" 7 | 8 | "github.com/dave/jennifer/jen" 9 | "github.com/k0kubun/pp" 10 | 11 | "github.com/amarnathcjd/gogram/internal/cmd/tlgen/tlparser" 12 | ) 13 | 14 | func (g *Generator) generateSpecificStructs(f *jen.File, d bool) { 15 | sort.Slice(g.schema.SingleInterfaceTypes, func(i, j int) bool { 16 | return g.schema.SingleInterfaceTypes[i].Name < g.schema.SingleInterfaceTypes[j].Name 17 | }) 18 | 19 | if d { 20 | wg := sync.WaitGroup{} 21 | for i, _type := range g.schema.SingleInterfaceTypes { 22 | wg.Add(1) 23 | go func(_type tlparser.Object, i int) { 24 | defer wg.Done() 25 | g.schema.SingleInterfaceTypes[i].Comment, _ = g.generateComment(_type.Name, "constructor") 26 | }(_type, i) 27 | } 28 | 29 | wg.Wait() 30 | } 31 | 32 | for _, _type := range g.schema.SingleInterfaceTypes { 33 | f.Add(g.generateStructTypeAndMethods(_type, nil)) 34 | f.Line() 35 | } 36 | } 37 | 38 | func (g *Generator) generateStructTypeAndMethods(definition tlparser.Object, implementsMethods []string) jen.Code { 39 | structName := goify(definition.Name, true) 40 | containsOptionalParameters := false 41 | var typeDefinition jen.Code 42 | 43 | fields := make([]jen.Code, len(definition.Parameters)) 44 | for i, param := range definition.Parameters { 45 | if param.IsOptional { 46 | containsOptionalParameters = true 47 | } 48 | 49 | if param.Type == "bitflags" { 50 | continue 51 | } 52 | fields[i] = g.generateStructParameter(¶m) 53 | } 54 | typeDefinition = jen.Type().Id(structName).Struct(fields...) 55 | 56 | // func (*T) CRC() uint32 { return 0x89abcdef } 57 | var crcFunc jen.Code 58 | f := jen.Func().Params(jen.Op("*").Id(structName)).Id("CRC").Params().Uint32().Block( 59 | jen.Return(jen.Id(fmt.Sprintf("%#v", definition.CRC))), 60 | ) 61 | crcFunc = f 62 | 63 | // can be nil 64 | var fieldIndexFunc jen.Code 65 | if containsOptionalParameters { 66 | flagBitIndex := -1 // index of the flags parameter 67 | if containsOptionalParameters { 68 | for i, param := range definition.Parameters { 69 | if param.Name == "flags" && param.Type == "bitflags" || param.Name == "flags2" && param.Type == "bitflags" { 70 | flagBitIndex = i 71 | } 72 | } 73 | } 74 | if flagBitIndex == -1 { 75 | pp.Println(definition) 76 | panic("optional bitflag not found!") 77 | } 78 | 79 | f := jen.Func().Params(jen.Op("*").Id(structName)).Id("FlagIndex").Params().Int().Block( 80 | jen.Return(jen.Lit(flagBitIndex)), 81 | ) 82 | fieldIndexFunc = f 83 | } 84 | 85 | // func (*T) Implements() {} 86 | var implementFuncs []jen.Code 87 | if implementsMethods != nil { 88 | implementFuncs = make([]jen.Code, len(implementsMethods)) 89 | for i, suffixName := range implementsMethods { 90 | f := jen.Func().Params(jen.Op("*").Id(structName)).Id("Implements" + suffixName).Params().Block() 91 | implementFuncs[i] = f 92 | } 93 | } 94 | 95 | result := &jen.Statement{} 96 | if definition.Comment != "" { 97 | result = result.Comment(definition.Comment) 98 | result = result.Line() 99 | } 100 | 101 | result = result.Add(typeDefinition, jen.Line(), jen.Line()) 102 | result = result.Add(crcFunc, jen.Line(), jen.Line()) 103 | if fieldIndexFunc != nil { 104 | result = result.Add(fieldIndexFunc, jen.Line(), jen.Line()) 105 | } 106 | 107 | if implementFuncs != nil { 108 | result = result.Add(implementFuncs...) 109 | } 110 | result = result.Add(jen.Line(), jen.Line()) 111 | 112 | return result 113 | } 114 | 115 | func (g *Generator) generateStructParameter(param *tlparser.Parameter) *jen.Statement { 116 | goifiedName := goify(param.Name, true) 117 | tag := "" 118 | f := jen.Id(goifiedName) 119 | if param.IsVector { 120 | f = f.Index() 121 | } 122 | 123 | if param.IsOptional { 124 | if param.Version == 1 { 125 | tag = fmt.Sprintf("flag:%v", param.BitToTrigger) 126 | } else if param.Version == 2 { 127 | tag = fmt.Sprintf("flag2:%v", param.BitToTrigger) 128 | } 129 | } 130 | 131 | if param.Type == "true" { 132 | tag += ",encoded_in_bitflags" 133 | } 134 | 135 | f = f.Add(g.typeIdFromSchemaType(param.Type)) 136 | 137 | if tag != "" { 138 | f = f.Tag(map[string]string{"tl": tag}) 139 | } 140 | 141 | if param.Comment != "" { 142 | f = f.Comment(param.Comment) 143 | } 144 | 145 | return f 146 | } 147 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/gen/utils.go: -------------------------------------------------------------------------------- 1 | package gen 2 | 3 | import ( 4 | "fmt" 5 | "regexp" 6 | "strings" 7 | "unicode" 8 | 9 | "github.com/dave/jennifer/jen" 10 | "github.com/iancoleman/strcase" 11 | 12 | "github.com/amarnathcjd/gogram/internal/cmd/tlgen/tlparser" 13 | ) 14 | 15 | func createParamsStructFromMethod(method tlparser.Method) tlparser.Object { 16 | return tlparser.Object{ 17 | Name: method.Name + "Params", 18 | CRC: method.CRC, 19 | Parameters: method.Parameters, 20 | } 21 | } 22 | 23 | func haveOptionalParams(params []tlparser.Parameter) bool { 24 | for _, param := range params { 25 | if param.IsOptional { 26 | return true 27 | } 28 | } 29 | 30 | return false 31 | } 32 | 33 | func maxBitflag(params []tlparser.Parameter) int { 34 | maximum := 0 35 | for _, param := range params { 36 | if param.BitToTrigger > maximum { 37 | maximum = param.BitToTrigger 38 | } 39 | } 40 | 41 | return maximum 42 | } 43 | 44 | func goify(name string, public bool) string { 45 | delim := strcase.ToDelimited(name, '|') 46 | delim = strings.ReplaceAll(delim, ".", "|") 47 | splitted := strings.Split(delim, "|") 48 | for i, item := range splitted { 49 | item = strings.ToLower(item) 50 | if SliceContains(capitalizePatterns, item) { 51 | item = strings.ToUpper(item) 52 | } 53 | 54 | itemRunes := []rune(item) 55 | 56 | if i == 0 && !public { 57 | itemRunes = []rune(strings.ToLower(item)) 58 | } else { 59 | itemRunes[0] = unicode.ToUpper(itemRunes[0]) 60 | } 61 | 62 | splitted[i] = string(itemRunes) 63 | } 64 | 65 | return strings.Join(splitted, "") 66 | } 67 | 68 | func (g *Generator) typeIdFromSchemaType(t string) *jen.Statement { 69 | item := &jen.Statement{} 70 | switch t { 71 | case "Bool": 72 | item = jen.Bool() 73 | case "long": 74 | item = jen.Int64() 75 | case "int256": 76 | item = jen.Qual(tlPackagePath, "Int256") 77 | case "double": 78 | item = jen.Float64() 79 | case "int": 80 | item = jen.Int32() 81 | case "string": 82 | item = jen.String() 83 | case "bytes": 84 | item = jen.Index().Byte() 85 | case "bitflags": 86 | panic("bitflags cant be generated or even cath in this part") 87 | case "true": 88 | item = jen.Bool() 89 | default: 90 | if _, ok := g.schema.Enums[t]; ok { 91 | item = jen.Id(goify(t, true)) 92 | break 93 | } 94 | if _, ok := g.schema.Types[t]; ok { 95 | item = jen.Id(goify(t, true)) 96 | break 97 | } 98 | found := false 99 | for _, _struct := range g.schema.SingleInterfaceTypes { 100 | if _struct.Interface == t { 101 | item = jen.Id("*" + goify(_struct.Name, true)) 102 | found = true 103 | break 104 | } 105 | } 106 | if found { 107 | break 108 | } 109 | // pp.Fprintln(os.Stderr, g.schema) 110 | //panic("'" + t + "'") 111 | fmt.Println("panic: ", t) 112 | } 113 | 114 | return item 115 | } 116 | 117 | func SliceContains(slice []string, item string) bool { 118 | for _, i := range slice { 119 | if i == item { 120 | return true 121 | } 122 | } 123 | 124 | return false 125 | } 126 | 127 | var ( 128 | regexLinkTag = regexp.MustCompile(`(?i)([^<]+)`) 129 | regexStrongTag = regexp.MustCompile(`(?i)([^<]+)`) 130 | regexMarkdownLink = regexp.MustCompile(`\[(.+)\]\(.+\)`) 131 | regexSeeHereTag = regexp.MustCompile(`(?i)see here[^.]*`) 132 | regexCodeTag = regexp.MustCompile(`(?i)([^<]+)`) 133 | regexBreakTag = regexp.MustCompile(`(?i)
    `) 134 | regexArrowRightTag = regexp.MustCompile(`(?i)»`) 135 | regexExtraSpaces = regexp.MustCompile(`(?i)\s+\.`) 136 | regexTrailingComma = regexp.MustCompile(`(?i),\s*$`) 137 | regexTableTag = regexp.MustCompile(`.*?\s*(.*?)`) 138 | ) 139 | 140 | func cleanComment(comment string) string { 141 | comment = regexLinkTag.ReplaceAllString(comment, "$2") 142 | comment = regexStrongTag.ReplaceAllString(comment, "$1") 143 | comment = regexMarkdownLink.ReplaceAllString(comment, "$1") 144 | comment = regexSeeHereTag.ReplaceAllString(comment, "") 145 | comment = regexCodeTag.ReplaceAllString(comment, "$1") 146 | comment = regexBreakTag.ReplaceAllString(comment, "\n") 147 | comment = regexArrowRightTag.ReplaceAllString(comment, "") 148 | comment = regexExtraSpaces.ReplaceAllString(comment, ".") 149 | comment = regexTrailingComma.ReplaceAllString(comment, "") 150 | 151 | return comment 152 | } 153 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/go.mod: -------------------------------------------------------------------------------- 1 | module github.com/amarnathcjd/gogram/internal/cmd/tlgen 2 | 3 | go 1.23 4 | 5 | require ( 6 | github.com/dave/jennifer v1.7.1 7 | github.com/iancoleman/strcase v0.3.0 8 | github.com/k0kubun/pp v3.0.1+incompatible 9 | github.com/pkg/errors v0.9.1 10 | ) 11 | 12 | require ( 13 | github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88 // indirect 14 | github.com/mattn/go-colorable v0.1.13 // indirect 15 | github.com/mattn/go-isatty v0.0.20 // indirect 16 | golang.org/x/sys v0.27.0 // indirect 17 | ) 18 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/go.sum: -------------------------------------------------------------------------------- 1 | github.com/dave/jennifer v1.7.0 h1:uRbSBH9UTS64yXbh4FrMHfgfY762RD+C7bUPKODpSJE= 2 | github.com/dave/jennifer v1.7.0/go.mod h1:nXbxhEmQfOZhWml3D1cDK5M1FLnMSozpbFN/m3RmGZc= 3 | github.com/dave/jennifer v1.7.1 h1:B4jJJDHelWcDhlRQxWeo0Npa/pYKBLrirAQoTN45txo= 4 | github.com/dave/jennifer v1.7.1/go.mod h1:nXbxhEmQfOZhWml3D1cDK5M1FLnMSozpbFN/m3RmGZc= 5 | github.com/iancoleman/strcase v0.3.0 h1:nTXanmYxhfFAMjZL34Ov6gkzEsSJZ5DbhxWjvSASxEI= 6 | github.com/iancoleman/strcase v0.3.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= 7 | github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88 h1:uC1QfSlInpQF+M0ao65imhwqKnz3Q2z/d8PWZRMQvDM= 8 | github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q1U84EfirKl04SVQ/s7nPm1ZPhiXd34z40TNz36k= 9 | github.com/k0kubun/pp v3.0.1+incompatible h1:3tqvf7QgUnZ5tXO6pNAZlrvHgl6DvifjDrd9g2S9Z40= 10 | github.com/k0kubun/pp v3.0.1+incompatible/go.mod h1:GWse8YhT0p8pT4ir3ZgBbfZild3tgzSScAn6HmfYukg= 11 | github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= 12 | github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= 13 | github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= 14 | github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= 15 | github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= 16 | github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= 17 | github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= 18 | golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 19 | golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= 20 | golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34= 21 | golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= 22 | golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s= 23 | golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= 24 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/tlparser/cursor.go: -------------------------------------------------------------------------------- 1 | package tlparser 2 | 3 | import ( 4 | "io" 5 | "unicode" 6 | ) 7 | 8 | type Cursor struct { 9 | source []rune 10 | pos int 11 | } 12 | 13 | // TODO: add `Line() int` and `Col() int` methods 14 | func NewCursor(source string) *Cursor { 15 | return &Cursor{ 16 | source: []rune(source), 17 | } 18 | } 19 | 20 | func (p *Cursor) current() rune { 21 | return p.source[p.pos] 22 | } 23 | 24 | func (p *Cursor) next() error { 25 | if p.pos >= len(p.source)-1 { 26 | return io.EOF 27 | } 28 | 29 | p.pos++ 30 | return nil 31 | } 32 | 33 | func (p *Cursor) Unread(count int) { 34 | p.pos -= count 35 | if p.pos <= 0 { 36 | p.pos = 0 37 | } 38 | } 39 | 40 | func (p *Cursor) Skip(count int) { 41 | p.pos += count 42 | if p.pos >= len(p.source)-1 { 43 | p.pos = len(p.source) - 1 44 | } 45 | } 46 | 47 | func (p *Cursor) SkipSpaces() { 48 | for unicode.IsSpace(p.current()) { 49 | if err := p.next(); err != nil { // EOF 50 | break 51 | } 52 | } 53 | } 54 | 55 | func (p *Cursor) ReadAt(at rune) (string, error) { 56 | var str []rune 57 | for { 58 | r := p.current() 59 | if r == at { 60 | return string(str), nil 61 | } 62 | 63 | str = append(str, r) 64 | if err := p.next(); err != nil { 65 | return "", err 66 | } 67 | } 68 | } 69 | 70 | func (p *Cursor) ReadSymbol() (rune, error) { 71 | r := p.current() 72 | err := p.next() 73 | return r, err 74 | } 75 | 76 | func (p *Cursor) ReadDigits() (string, error) { 77 | var digits []rune 78 | for unicode.IsDigit(p.current()) { 79 | digits = append(digits, p.current()) 80 | if err := p.next(); err != nil { 81 | return "", err 82 | } 83 | } 84 | 85 | return string(digits), nil 86 | } 87 | 88 | func (p *Cursor) IsNext(s string) bool { 89 | for i, exp := range s { 90 | if p.current() != exp { 91 | p.Unread(i) 92 | return false 93 | } 94 | _ = p.next() 95 | } 96 | 97 | return true 98 | } 99 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/tlparser/excluded.go: -------------------------------------------------------------------------------- 1 | package tlparser 2 | 3 | import "fmt" 4 | 5 | var excludedDefinitions = map[string]null{ 6 | "true": {}, 7 | "boolFalse": {}, 8 | "boolTrue": {}, 9 | "vector": {}, 10 | 11 | "invokeAfterMsg": {}, 12 | "invokeAfterMsgs": {}, 13 | "initConnection": {}, 14 | "invokeWithLayer": {}, 15 | "invokeWithoutUpdates": {}, 16 | "invokeWithMessagesRange": {}, 17 | "invokeWithTakeout": {}, 18 | } 19 | 20 | var excludedTypes = map[string]null{ 21 | "int": {}, 22 | "long": {}, 23 | "double": {}, 24 | "string": {}, 25 | "bytes": {}, 26 | } 27 | 28 | type errExcluded struct { 29 | name string 30 | } 31 | 32 | func (e errExcluded) Error() string { 33 | return fmt.Sprintf("excluded: %s", e.name) 34 | } 35 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/tlparser/extra.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2023 RoseLoverX 2 | 3 | package tlparser 4 | 5 | type null = struct{} 6 | -------------------------------------------------------------------------------- /internal/cmd/tlgen/tlparser/schema.go: -------------------------------------------------------------------------------- 1 | package tlparser 2 | 3 | type Schema struct { 4 | Objects []Object 5 | Methods []Method 6 | TypeComments map[string]string 7 | } 8 | 9 | type Object struct { 10 | Name string 11 | Comment string 12 | CRC uint32 13 | Parameters []Parameter 14 | Interface string 15 | } 16 | 17 | type Parameter struct { 18 | Name string 19 | Type string 20 | Comment string 21 | IsVector bool 22 | IsOptional bool 23 | Version int 24 | BitToTrigger int 25 | } 26 | 27 | type Method struct { 28 | Name string 29 | CRC uint32 30 | Comment string 31 | Parameters []Parameter 32 | Response MethodResponse 33 | } 34 | 35 | type MethodResponse struct { 36 | Type string 37 | IsList bool 38 | } 39 | -------------------------------------------------------------------------------- /internal/encoding/tl/common_types.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package tl 4 | 5 | import ( 6 | "math/big" 7 | ) 8 | 9 | // Int128 is alias-like type for fixed size of big int (1024 bit value). It using only for tl objects encoding 10 | // cause native big.Int isn't supported for en(de)coding 11 | type Int128 struct { 12 | *big.Int 13 | } 14 | 15 | // NewInt128 creates int128 with zero value 16 | func NewInt128() *Int128 { 17 | return &Int128{Int: big.NewInt(0).SetBytes(make([]byte, Int128Len))} 18 | } 19 | 20 | // NewInt128 creates int128 with random value 21 | func RandomInt128() *Int128 { 22 | i := &Int128{Int: big.NewInt(0)} 23 | i.SetBytes(RandomBytes(Int128Len)) 24 | return i 25 | } 26 | 27 | // func reflectIsInt128(v reflect.Value) bool { 28 | // _, ok := v.Interface().(*Int128) 29 | // return ok 30 | // } 31 | 32 | // MarshalTL implements tl marshaler from this package. Just don't use it by your hands, tl.Encoder does all 33 | // what you need 34 | func (i *Int128) MarshalTL(e *Encoder) error { 35 | e.PutRawBytes(BigIntBytes(i.Int, Int128Len*bitsInByte)) 36 | return nil 37 | } 38 | 39 | // UnmarshalTL implements tl unmarshaler from this package. Just don't use it by your hands, tl.Decoder does 40 | // all what you need 41 | func (i *Int128) UnmarshalTL(d *Decoder) error { 42 | val := d.PopRawBytes(Int128Len) 43 | if d.err != nil { 44 | return d.err 45 | } 46 | i.Int = big.NewInt(0).SetBytes(val) 47 | return nil 48 | } 49 | 50 | // Int256 is alias-like type for fixed size of big int (2048 bit value). It using only for tl objects encoding 51 | // cause native big.Int isn't supported for en(de)coding 52 | type Int256 struct { 53 | *big.Int 54 | } 55 | 56 | // NewInt256 creates int256 with zero value 57 | func NewInt256() *Int256 { 58 | return &Int256{Int: big.NewInt(0).SetBytes(make([]byte, Int256Len))} 59 | } 60 | 61 | // NewInt256 creates int256 with random value 62 | func RandomInt256() *Int256 { 63 | i := &Int256{big.NewInt(0)} 64 | i.SetBytes(RandomBytes(Int256Len)) 65 | return i 66 | } 67 | 68 | // func reflectIsInt256(v reflect.Value) bool { 69 | // _, ok := v.Interface().(*Int256) 70 | // return ok 71 | // } 72 | 73 | // MarshalTL implements tl marshaler from this package. Just don't use it by your hands, tl.Encoder does all 74 | // what you need 75 | func (i *Int256) MarshalTL(e *Encoder) error { 76 | e.PutRawBytes(BigIntBytes(i.Int, Int256Len*bitsInByte)) 77 | return nil 78 | } 79 | 80 | // UnmarshalTL implements tl unmarshaler from this package. Just don't use it by your hands, tl.Decoder does 81 | // all what you need 82 | func (i *Int256) UnmarshalTL(d *Decoder) error { 83 | val := d.PopRawBytes(Int256Len) 84 | if d.err != nil { 85 | return d.err 86 | } 87 | i.Int = big.NewInt(0).SetBytes(val) 88 | return nil 89 | } 90 | -------------------------------------------------------------------------------- /internal/encoding/tl/const.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package tl 4 | 5 | const ( 6 | WordLen = 4 // Size of a word in TL (32 bits) 7 | LongLen = WordLen * 2 // int64 occupies 8 bytes 8 | DoubleLen = WordLen * 2 // float64 occupies 8 bytes 9 | Int128Len = WordLen * 4 // int128 occupies 16 bytes 10 | Int256Len = WordLen * 8 // int256 occupies 32 bytes 11 | 12 | // Magic Numbers 13 | MaxArrayElements = 0xfe // Maximum number of elements that can be encoded in an array 14 | 15 | MagicNumber = 0xfe // 254 16 | 17 | // https://core.telegram.org/schema/mtproto 18 | CrcVector uint32 = 0x1cb5c415 19 | CrcFalse uint32 = 0xbc799737 20 | CrcTrue uint32 = 0x997275b5 21 | CrcNull uint32 = 0x56730bcc 22 | 23 | bitsInByte = 8 // Number of bits in a byte (for consistency) 24 | ) 25 | -------------------------------------------------------------------------------- /internal/encoding/tl/cursor_r.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package tl 4 | 5 | import ( 6 | "bytes" 7 | "encoding/binary" 8 | "fmt" 9 | "io" 10 | "math" 11 | "reflect" 12 | 13 | "github.com/pkg/errors" 14 | ) 15 | 16 | // A Decoder reads and decodes TL values from an input stream. 17 | type Decoder struct { 18 | buf *bytes.Reader 19 | err error 20 | 21 | // see Decoder.ExpectTypesInInterface description 22 | expectedTypes []reflect.Type 23 | } 24 | 25 | // NewDecoder returns a new decoder that reads from r. 26 | // 27 | // Note: The decoder cannot work with partial data. The entire input must be read before decoding can begin. 28 | func NewDecoder(r io.Reader) (*Decoder, error) { 29 | data, err := io.ReadAll(r) 30 | if err != nil { 31 | return nil, errors.Wrap(err, "reading data before decoding") 32 | } 33 | 34 | return &Decoder{buf: bytes.NewReader(data)}, nil 35 | } 36 | 37 | // ExpectTypesInInterface defines how the decoder should parse implicit objects. 38 | // 39 | // How `expectedTypes` works: 40 | // 41 | // Imagine you want to parse a `[]int32`, but you might also receive `[]int64`, `SomeCustomType`, 42 | // or even `[][]bool`. How do you handle this? 43 | // 44 | // `expectedTypes` stores your predictions. For example, if you encounter an unknown type, it 45 | // will parse it as `int32` instead of `int64`. 46 | // 47 | // If you have predictions deeper than the first unknown type, you can tell the decoder to use those 48 | // predicted values. 49 | // 50 | // So, next time you have a structure with an `any` field that expects to contain `[]float64` 51 | // or similar, use this feature via `d.ExpectTypesInInterface()`. 52 | func (d *Decoder) ExpectTypesInInterface(types ...reflect.Type) { 53 | d.expectedTypes = types 54 | } 55 | 56 | func (d *Decoder) read(buf []byte) { 57 | if d.err != nil { 58 | return 59 | } 60 | 61 | n, err := d.buf.Read(buf) 62 | if err != nil { 63 | d.unread(n) 64 | d.err = err 65 | return 66 | } 67 | 68 | if n != len(buf) { 69 | d.unread(n) 70 | d.err = fmt.Errorf("buffer weren't fully read: want %v bytes, got %v", len(buf), n) 71 | return 72 | } 73 | } 74 | 75 | func (d *Decoder) unread(count int) { 76 | for i := 0; i < count; i++ { 77 | if d.buf.UnreadByte() != nil { 78 | return 79 | } 80 | } 81 | } 82 | 83 | func (d *Decoder) PopLong() int64 { 84 | val := make([]byte, LongLen) 85 | d.read(val) 86 | if d.err != nil { 87 | return 0 88 | } 89 | 90 | return int64(binary.LittleEndian.Uint64(val)) 91 | } 92 | 93 | func (d *Decoder) PopDouble() float64 { 94 | val := make([]byte, DoubleLen) 95 | d.read(val) 96 | if d.err != nil { 97 | return 0 98 | } 99 | 100 | return math.Float64frombits(binary.LittleEndian.Uint64(val)) 101 | } 102 | 103 | func (d *Decoder) PopUint() uint32 { 104 | val := make([]byte, WordLen) 105 | d.read(val) 106 | if d.err != nil { 107 | return 0 108 | } 109 | 110 | return binary.LittleEndian.Uint32(val) 111 | } 112 | 113 | func (d *Decoder) PopRawBytes(size int) []byte { 114 | if size < 0 { 115 | return nil 116 | } 117 | 118 | val := make([]byte, size) 119 | d.read(val) 120 | if d.err != nil { 121 | return nil 122 | } 123 | 124 | return val 125 | } 126 | 127 | func (d *Decoder) PopBool() bool { 128 | crc := d.PopUint() 129 | if d.err != nil { 130 | return false 131 | } 132 | 133 | switch crc { 134 | case CrcTrue: 135 | return true 136 | case CrcFalse: 137 | return false 138 | default: 139 | d.err = fmt.Errorf("not a bool value, actually: %#v", crc) 140 | return false 141 | } 142 | } 143 | 144 | func (d *Decoder) PopNull() { 145 | crc := d.PopUint() 146 | if d.err != nil { 147 | return 148 | } 149 | 150 | if crc != CrcNull { 151 | d.err = fmt.Errorf("not a null value, actually: %#v", crc) 152 | return 153 | } 154 | } 155 | 156 | func (d *Decoder) PopCRC() uint32 { 157 | return d.PopUint() // The CRC calculation appears to be in big-endian order, but it's not entirely clear. 158 | } 159 | 160 | func (d *Decoder) PopInt() int32 { 161 | return int32(d.PopUint()) 162 | } 163 | 164 | func (d *Decoder) GetRestOfMessage() ([]byte, error) { 165 | return io.ReadAll(d.buf) 166 | } 167 | 168 | func (d *Decoder) DumpWithoutRead() ([]byte, error) { 169 | data, err := io.ReadAll(d.buf) 170 | if err != nil { 171 | return nil, err 172 | } 173 | 174 | d.unread(len(data)) 175 | return data, nil 176 | } 177 | 178 | func (d *Decoder) PopVector(as reflect.Type) any { 179 | return d.popVector(as, false) 180 | } 181 | 182 | func (d *Decoder) popVector(as reflect.Type, ignoreCRC bool) any { 183 | if d.err != nil { 184 | return nil 185 | } 186 | if !ignoreCRC { 187 | crc := d.PopCRC() 188 | if d.err != nil { 189 | d.err = errors.Wrap(d.err, "read crc") 190 | return nil 191 | } 192 | 193 | if crc != CrcVector { 194 | d.err = fmt.Errorf("not a vector: 0x%08x, want: 0x%08x", crc, CrcVector) 195 | return nil 196 | } 197 | } 198 | 199 | size := d.PopUint() 200 | if d.err != nil { 201 | d.err = errors.Wrap(d.err, "read vector size") 202 | return nil 203 | } 204 | 205 | x := reflect.MakeSlice(reflect.SliceOf(as), int(size), int(size)) 206 | for i := 0; i < int(size); i++ { 207 | var val reflect.Value 208 | if as.Kind() == reflect.Ptr { 209 | val = reflect.New(as.Elem()) 210 | } else { 211 | val = reflect.New(as).Elem() 212 | } 213 | 214 | d.decodeValue(val) 215 | if d.err != nil { 216 | return nil 217 | } 218 | 219 | x.Index(i).Set(val) 220 | } 221 | 222 | return x.Interface() 223 | } 224 | 225 | func (d *Decoder) PopMessage() []byte { 226 | val := []byte{0} 227 | 228 | d.read(val) 229 | if d.err != nil { 230 | return nil 231 | } 232 | 233 | firstByte := val[0] 234 | 235 | var realSize int 236 | var lenNumberSize int 237 | 238 | if firstByte != MagicNumber { 239 | realSize = int(firstByte) 240 | lenNumberSize = 1 241 | } else { 242 | 243 | val = make([]byte, WordLen-1) 244 | d.read(val) 245 | if d.err != nil { 246 | d.err = errors.Wrapf(d.err, "reading last %v bytes of message size", WordLen-1) 247 | return nil 248 | } 249 | 250 | val = append(val, 0x0) 251 | 252 | realSize = int(binary.LittleEndian.Uint32(val)) 253 | lenNumberSize = WordLen 254 | } 255 | 256 | buf := make([]byte, realSize) 257 | d.read(buf) 258 | if d.err != nil { 259 | d.err = errors.Wrapf(d.err, "reading message data with len of %v", realSize) 260 | return nil 261 | } 262 | 263 | readLen := lenNumberSize + realSize 264 | if readLen%WordLen != 0 { 265 | voidBytes := make([]byte, WordLen-readLen%WordLen) 266 | d.read(voidBytes) 267 | if d.err != nil { 268 | d.err = errors.Wrapf(d.err, "reading %v last void bytes", WordLen-readLen%WordLen) 269 | return nil 270 | } 271 | 272 | for _, b := range voidBytes { 273 | if b != 0 { 274 | d.err = fmt.Errorf("some of void bytes doesn't equal zero: %#v", voidBytes) 275 | return nil 276 | } 277 | } 278 | } 279 | 280 | return buf 281 | } 282 | -------------------------------------------------------------------------------- /internal/encoding/tl/cursor_w.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package tl 4 | 5 | import ( 6 | "encoding/binary" 7 | "fmt" 8 | "io" 9 | "math" 10 | ) 11 | 12 | type Encoder struct { 13 | w io.Writer 14 | // this error is last unsuccessful write into w. if this err != nil, 15 | // write() method will not write enay data 16 | err error 17 | } 18 | 19 | func NewEncoder(w io.Writer) *Encoder { 20 | return &Encoder{w: w} 21 | } 22 | 23 | func (e *Encoder) write(b []byte) { 24 | if e.err != nil { 25 | return 26 | } 27 | 28 | n, err := e.w.Write(b) 29 | if err != nil { 30 | e.err = err 31 | return 32 | } 33 | 34 | if n != len(b) { 35 | e.err = &ErrorPartialWrite{Has: n, Want: len(b)} 36 | } 37 | } 38 | 39 | // CheckErr must be called after encoding has been finished. If this function returns a non-nil value, 40 | // the encoding has failed, and the resulting data should not be used. 41 | func (e *Encoder) CheckErr() error { 42 | return e.err 43 | } 44 | 45 | // PutBool is a very specific type. Since there are separate constructors for true and false, 46 | // they can be considered as two CRC constants. 47 | func (e *Encoder) PutBool(v bool) { 48 | crc := CrcFalse 49 | if v { 50 | crc = CrcTrue 51 | } 52 | 53 | e.PutUint(uint32(crc)) 54 | } 55 | 56 | func (e *Encoder) putUint8(v uint8) { 57 | tmp := [1]byte{v} 58 | e.write(tmp[:]) 59 | } 60 | 61 | func (e *Encoder) PutUint(v uint32) { 62 | buf := make([]byte, WordLen) 63 | binary.LittleEndian.PutUint32(buf, v) 64 | e.write(buf) 65 | } 66 | 67 | // PutCRC is an alias for Encoder.PutUint. It is used for better code readability and self-documentation. 68 | func (e *Encoder) PutCRC(v uint32) { 69 | e.PutUint(v) // The CRC calculation order is unclear, but it is not necessarily big-endian. 70 | } 71 | 72 | func (e *Encoder) PutInt(v int32) { 73 | e.PutUint(uint32(v)) 74 | } 75 | 76 | func (e *Encoder) PutLong(v int64) { 77 | buf := make([]byte, LongLen) 78 | binary.LittleEndian.PutUint64(buf, uint64(v)) 79 | e.write(buf) 80 | } 81 | 82 | func (e *Encoder) PutDouble(v float64) { 83 | buf := make([]byte, DoubleLen) 84 | binary.LittleEndian.PutUint64(buf, math.Float64bits(v)) 85 | e.write(buf) 86 | } 87 | 88 | func (e *Encoder) PutMessage(b []byte) { 89 | size := len(b) 90 | pad := 0 91 | 92 | maxLen := 1 << 24 // 3 bytes 24 bits, the first one is 0xfe, the remaining 3 times the length 93 | if size > maxLen { 94 | e.err = fmt.Errorf("message entity too large: expect less than %v, got %v", maxLen, size) 95 | return 96 | } 97 | 98 | switch { 99 | case size == 0: // optimization for empty messages 100 | e.PutUint(0) 101 | return 102 | case size < MagicNumber: 103 | pad = padding4(size + 1) 104 | e.putUint8(uint8(size)) 105 | default: 106 | pad = padding4(size) 107 | e.PutUint(uint32(size)<<8 | MagicNumber) 108 | } 109 | 110 | e.write(b) 111 | 112 | if pad > 0 { 113 | var zero [4]byte 114 | e.write(zero[:pad]) 115 | } 116 | } 117 | 118 | func (e *Encoder) PutString(msg string) { 119 | e.PutMessage([]byte(msg)) 120 | } 121 | 122 | func (e *Encoder) PutRawBytes(b []byte) { 123 | e.write(b) 124 | } 125 | 126 | func (e *Encoder) PutVector(v any) { 127 | e.encodeVector(sliceToInterfaceSlice(v)...) 128 | } 129 | -------------------------------------------------------------------------------- /internal/encoding/tl/encoder.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package tl 4 | 5 | import ( 6 | "bytes" 7 | "fmt" 8 | "reflect" 9 | "sync" 10 | 11 | "github.com/pkg/errors" 12 | ) 13 | 14 | var bufferPool = sync.Pool{ 15 | New: func() any { 16 | return bytes.NewBuffer(make([]byte, 8*1024)) // 8kb 17 | }, 18 | } 19 | 20 | func Marshal(v any) ([]byte, error) { 21 | buf := bufferPool.Get().(*bytes.Buffer) 22 | defer bufferPool.Put(buf) 23 | buf.Reset() 24 | 25 | encoder := NewEncoder(buf) 26 | encoder.encodeValue(reflect.ValueOf(v)) 27 | if err := encoder.CheckErr(); err != nil { 28 | return nil, err 29 | } 30 | 31 | return bytes.Clone(buf.Bytes()), nil 32 | } 33 | 34 | func (c *Encoder) encodeValue(value reflect.Value) { 35 | if m, ok := value.Interface().(Marshaler); ok { 36 | if c.err != nil { 37 | return 38 | } 39 | c.err = m.MarshalTL(c) 40 | return 41 | } 42 | 43 | switch value.Type().Kind() { 44 | case reflect.Uint32: 45 | c.PutUint(uint32(value.Uint())) 46 | 47 | case reflect.Int32: 48 | c.PutUint(uint32(value.Int())) 49 | 50 | case reflect.Int64: 51 | c.PutLong(value.Int()) 52 | 53 | case reflect.Float64: 54 | c.PutDouble(value.Float()) 55 | 56 | case reflect.Bool: 57 | c.PutBool(value.Bool()) 58 | 59 | case reflect.String: 60 | c.PutString(value.String()) 61 | 62 | case reflect.Struct: 63 | c.encodeStruct(value.Addr()) 64 | 65 | case reflect.Ptr, reflect.Interface: 66 | if value.IsNil() { 67 | c.err = errors.New("value can't be nil") 68 | break 69 | } 70 | 71 | c.encodeValue(value.Elem()) 72 | 73 | case reflect.Slice: 74 | if b, ok := value.Interface().([]byte); ok { 75 | c.PutMessage(b) 76 | break 77 | } 78 | 79 | c.encodeVector(sliceToInterfaceSlice(value.Interface())...) 80 | 81 | case reflect.Int, reflect.Int8, reflect.Int16, 82 | reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint64: 83 | c.err = fmt.Errorf("int kind: %v (must be converted to int32, int64 or uint32 explicitly)", value.Kind()) 84 | 85 | case reflect.Float32, reflect.Complex64, reflect.Complex128: 86 | c.err = fmt.Errorf("float kind: %s (must be converted to float64 explicitly)", value.Kind()) 87 | 88 | default: 89 | c.err = fmt.Errorf("unsupported type: %v", value.Type()) 90 | } 91 | } 92 | 93 | // v must be pointer to struct 94 | func (c *Encoder) encodeStruct(v reflect.Value) { 95 | if c.err != nil { 96 | return 97 | } 98 | 99 | o, ok := v.Interface().(Object) 100 | if !ok { 101 | c.err = errors.New(v.Type().String() + " doesn't implement tl.Object interface") 102 | return 103 | } 104 | 105 | var hasFlagsField bool 106 | var flag uint32 107 | var flagIndex int 108 | g, ok := v.Interface().(FlagIndexGetter) 109 | if ok { 110 | hasFlagsField = true 111 | flagIndex = g.FlagIndex() 112 | } 113 | 114 | v = reflect.Indirect(v) 115 | 116 | // what we checked and what we know about value: 117 | // 1) it's not Marshaler (marshaler object already parsing in c.encodeValue()) 118 | // 2) implements tl.Object 119 | // 3) definitely struct (we don't call encodeStruct(), only in c.encodeValue()) 120 | // 4) not nil (structs can't be nil, only pointers and interfaces) 121 | c.PutCRC(o.CRC()) 122 | var tmpObjects = make([]reflect.Value, 0) 123 | 124 | vtyp := v.Type() 125 | 126 | for i := 0; i < v.NumField(); i++ { 127 | // THIS PART is appending to object meta value, that actually don't writing in real encodeValue 128 | if hasFlagsField && flagIndex == i { 129 | tmpObjects = append(tmpObjects, reflect.ValueOf(0)) 130 | } 131 | 132 | info, err := parseTag(vtyp.Field(i).Tag) 133 | if err != nil { 134 | c.err = errors.Wrapf(err, "parsing tag of field %v", vtyp.Field(i).Name) 135 | return 136 | } 137 | 138 | if info == nil { 139 | // If there is no tag, then this is a mandatory field, meaning we write 100%. 140 | tmpObjects = append(tmpObjects, v.Field(i)) 141 | continue 142 | } 143 | 144 | if info.ignore { 145 | continue 146 | } 147 | 148 | if info.encodedInBitflag && vtyp.Field(i).Type.Kind() != reflect.Bool { 149 | c.err = fmt.Errorf("field '%s': only bool values can be encoded in bitflag", vtyp.Field(i).Name) 150 | return 151 | } 152 | 153 | fieldVal := v.Field(i) 154 | if !fieldVal.IsZero() { 155 | // Tag is there, this is 100% optional field 156 | flag |= 1 << info.index 157 | if info.encodedInBitflag { 158 | continue 159 | } 160 | 161 | tmpObjects = append(tmpObjects, v.Field(i)) 162 | 163 | continue 164 | } 165 | } 166 | 167 | for i, elem := range tmpObjects { 168 | // if you asking, wtf is here: continuing, cause we injected int value (native int, not int32), so we 169 | // CAN skip this iter 170 | if hasFlagsField && flagIndex == i { 171 | c.PutUint(flag) 172 | continue 173 | } 174 | 175 | c.encodeValue(elem) 176 | if c.err != nil { 177 | return 178 | } 179 | } 180 | } 181 | 182 | func (c *Encoder) encodeVector(slice ...any) { 183 | c.PutCRC(CrcVector) 184 | c.PutUint(uint32(len(slice))) 185 | 186 | for i, item := range slice { 187 | c.encodeValue(reflect.ValueOf(item)) 188 | if c.CheckErr() != nil { 189 | c.err = errors.Wrapf(c.err, "[%v]", i) 190 | } 191 | } 192 | } 193 | -------------------------------------------------------------------------------- /internal/encoding/tl/errors.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024,RoseLoverX 2 | 3 | package tl 4 | 5 | import "fmt" 6 | 7 | type ErrRegisteredObjectNotFound struct { 8 | Crc uint32 9 | Data []byte 10 | } 11 | 12 | func (e *ErrRegisteredObjectNotFound) Error() string { 13 | return fmt.Sprintf("object with provided crc not registered: 0x%08x", e.Crc) 14 | } 15 | 16 | type ErrMustParseSlicesExplicitly struct{} 17 | 18 | func (e *ErrMustParseSlicesExplicitly) Error() string { 19 | return "got vector CRC code when parsing unknown object: vectors can't be parsed as predicted objects" 20 | } 21 | 22 | type ErrorPartialWrite struct { 23 | Has int 24 | Want int 25 | } 26 | 27 | func (e *ErrorPartialWrite) Error() string { 28 | return fmt.Sprintf("write failed: only %v bytes were written, expected %v", e.Has, e.Want) 29 | } 30 | -------------------------------------------------------------------------------- /internal/encoding/tl/object.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package tl 4 | 5 | type Object interface { 6 | CRC() uint32 7 | } 8 | 9 | type FlagIndexGetter interface { 10 | FlagIndex() int 11 | } 12 | 13 | type Marshaler interface { 14 | MarshalTL(*Encoder) error 15 | } 16 | 17 | type Unmarshaler interface { 18 | UnmarshalTL(*Decoder) error 19 | } 20 | 21 | //==========================================================================================================// 22 | // Next types are specific structs for handling bool types, slice and null as object. // // 23 | //==========================================================================================================// 24 | 25 | // PseudoTrue is a support struct which is required to get native 26 | type PseudoTrue struct{} 27 | 28 | func (*PseudoTrue) CRC() uint32 { 29 | return CrcTrue 30 | } 31 | 32 | // PseudoFalse is a support struct which is required to get native 33 | type PseudoFalse struct{} 34 | 35 | func (*PseudoFalse) CRC() uint32 { 36 | return CrcFalse 37 | } 38 | 39 | type PseudoNil struct{} 40 | 41 | func (*PseudoNil) CRC() uint32 { 42 | return CrcNull 43 | } 44 | 45 | // you won't use it, right? 46 | func (*PseudoNil) Unwrap() any { 47 | return nil 48 | } 49 | 50 | // WrappedSlice is pseudo type. YOU SHOULD NOT use it customly, instead, you must encode/decode value by 51 | // encoder.PutVector or decoder.PopVector 52 | type WrappedSlice struct { 53 | data any 54 | } 55 | 56 | func (*WrappedSlice) CRC() uint32 { 57 | return CrcVector 58 | } 59 | 60 | func (w *WrappedSlice) Unwrap() any { 61 | return w.data 62 | } 63 | 64 | func UnwrapNativeTypes(in Object) any { 65 | switch i := in.(type) { 66 | case *PseudoTrue: 67 | return true 68 | case *PseudoFalse: 69 | return false 70 | case *PseudoNil: 71 | return nil 72 | case *WrappedSlice: 73 | return i.Unwrap() 74 | default: 75 | return in 76 | } 77 | } 78 | -------------------------------------------------------------------------------- /internal/encoding/tl/register.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package tl 4 | 5 | import ( 6 | "fmt" 7 | "reflect" 8 | ) 9 | 10 | var ( 11 | // used by decoder, guaranteed that types are convertible to tl.Object 12 | objectByCrc = make(map[uint32]reflect.Type) // this value setting by registerObject(), DO NOT CALL IT BY HANDS 13 | enumCrcs = make(map[uint32]struct{}) 14 | ) 15 | 16 | func registerObject(o Object) { 17 | if o == nil { 18 | panic("object is nil") 19 | } 20 | objectByCrc[o.CRC()] = reflect.TypeOf(o) 21 | } 22 | 23 | func registerEnum(o Object) { 24 | registerObject(o) 25 | enumCrcs[o.CRC()] = struct{}{} 26 | } 27 | 28 | func RegisterObjects(obs ...Object) { 29 | for _, o := range obs { 30 | if val, found := objectByCrc[o.CRC()]; found { 31 | panic(fmt.Errorf("object with that crc already registered as %v: 0x%08x", val.String(), o.CRC())) 32 | } 33 | 34 | registerObject(o) 35 | } 36 | } 37 | 38 | func RegisterEnums(enums ...Object) { 39 | for _, e := range enums { 40 | if _, found := enumCrcs[e.CRC()]; found { 41 | panic(fmt.Errorf("enum with that crc already registered")) 42 | } 43 | 44 | registerEnum(e) 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /internal/encoding/tl/tag.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package tl 4 | 5 | import ( 6 | "fmt" 7 | "reflect" 8 | "strconv" 9 | "strings" 10 | 11 | "github.com/pkg/errors" 12 | ) 13 | 14 | const tagName = "tl" 15 | 16 | type fieldTag struct { 17 | index int // flags: 18 | encodedInBitflag bool // encoded_in_bitflags 19 | ignore bool // - 20 | optional bool // omitempty 21 | version int // flags||flags2 22 | } 23 | 24 | func parseTag(s reflect.StructTag) (*fieldTag, error) { 25 | tags, err := parseFunc(string(s)) 26 | if err != nil { 27 | return nil, errors.Wrap(err, "parsing field tags") 28 | } 29 | 30 | tag, err := tags.Get(tagName) 31 | if err != nil { 32 | return nil, nil 33 | } 34 | 35 | info := &fieldTag{} 36 | 37 | if tag.Name == "-" { 38 | info.ignore = true 39 | return info, nil 40 | } 41 | 42 | var flagIndexSet bool 43 | if strings.HasPrefix(tag.Name, "flag2:") { 44 | num := strings.TrimPrefix(tag.Name, "flag2:") 45 | index, err := parseUintMax32(num) 46 | info.index = int(index) 47 | if err != nil { 48 | return nil, errors.Wrapf(err, "parsing index number '%s'", num) 49 | } 50 | 51 | info.optional = true 52 | 53 | flagIndexSet = true 54 | info.version = 2 55 | } else if strings.HasPrefix(tag.Name, "flag:") { 56 | num := strings.TrimPrefix(tag.Name, "flag:") 57 | index, err := parseUintMax32(num) 58 | info.index = int(index) 59 | if err != nil { 60 | return nil, errors.Wrapf(err, "parsing index number '%s'", num) 61 | } 62 | 63 | info.optional = true 64 | info.version = 1 65 | 66 | flagIndexSet = true 67 | } 68 | 69 | if haveInSlice("encoded_in_bitflags", tag.Options) { 70 | if !flagIndexSet { 71 | return nil, errors.New("have 'encoded_in_bitflag' option without flag index") 72 | } 73 | 74 | info.encodedInBitflag = true 75 | } 76 | 77 | if haveInSlice("omitempty", tag.Options) { 78 | info.optional = true 79 | } 80 | 81 | return info, nil 82 | } 83 | 84 | // ! slicetricks 85 | func haveInSlice(s string, slice []string) bool { 86 | for _, item := range slice { 87 | if item == s { 88 | return true 89 | } 90 | } 91 | 92 | return false 93 | } 94 | 95 | var ( 96 | errTagSyntax = errors.New("bad syntax for struct tag pair") 97 | errTagKeySyntax = errors.New("bad syntax for struct tag key") 98 | errTagValueSyntax = errors.New("bad syntax for struct tag value") 99 | 100 | errKeyNotSet = errors.New("tag key does not exist") 101 | errTagNotExist = errors.New("tag does not exist") 102 | ) 103 | 104 | // Tags represent a set of tags from a single struct field 105 | type Tags struct { 106 | tags []*Tag 107 | } 108 | 109 | // Tag defines a single struct's string literal tag 110 | type Tag struct { 111 | // Key is the tag key, such as json, xml, etc.. 112 | // i.e: `json:"foo,omitempty". Here key is: "json" 113 | Key string 114 | 115 | // Name is a part of the value 116 | // i.e: `json:"foo,omitempty". Here name is: "foo" 117 | Name string 118 | 119 | // Options is a part of the value. It contains a slice of tag options i.e: 120 | // `json:"foo,omitempty". Here options is: ["omitempty"] 121 | Options []string 122 | } 123 | 124 | // Parse parses a single struct field tag and returns the set of tags. 125 | func parseFunc(tag string) (*Tags, error) { 126 | var tags []*Tag 127 | 128 | hasTag := tag != "" 129 | 130 | // NOTE(arslan) following code is from reflect and vet package with some 131 | // modifications to collect all necessary information and extend it with 132 | // usable methods 133 | for tag != "" { 134 | // Skip leading space. 135 | i := 0 136 | for i < len(tag) && tag[i] == ' ' { 137 | i++ 138 | } 139 | tag = tag[i:] 140 | if tag == "" { 141 | break 142 | } 143 | 144 | // Scan to colon. A space, a quote or a control character is a syntax 145 | // error. Strictly speaking, control chars include the range [0x7f, 146 | // 0x9f], not just [0x00, 0x1f], but in practice, we ignore the 147 | // multi-byte control characters as it is simpler to inspect the tag's 148 | // bytes than the tag's runes. 149 | i = 0 150 | for i < len(tag) && tag[i] > ' ' && tag[i] != ':' && tag[i] != '"' && tag[i] != 0x7f { 151 | i++ 152 | } 153 | 154 | if i == 0 { 155 | return nil, errTagKeySyntax 156 | } 157 | if i+1 >= len(tag) || tag[i] != ':' { 158 | return nil, errTagSyntax 159 | } 160 | if tag[i+1] != '"' { 161 | return nil, errTagValueSyntax 162 | } 163 | 164 | key := string(tag[:i]) 165 | tag = tag[i+1:] 166 | 167 | // Scan quoted string to find value. 168 | i = 1 169 | for i < len(tag) && tag[i] != '"' { 170 | if tag[i] == '\\' { 171 | i++ 172 | } 173 | i++ 174 | } 175 | if i >= len(tag) { 176 | return nil, errTagValueSyntax 177 | } 178 | 179 | qvalue := string(tag[:i+1]) 180 | tag = tag[i+1:] 181 | 182 | value, err := strconv.Unquote(qvalue) 183 | if err != nil { 184 | return nil, errTagValueSyntax 185 | } 186 | 187 | res := strings.Split(value, ",") 188 | name := res[0] 189 | options := res[1:] 190 | if len(options) == 0 { 191 | options = nil 192 | } 193 | 194 | tags = append(tags, &Tag{ 195 | Key: key, 196 | Name: name, 197 | Options: options, 198 | }) 199 | } 200 | 201 | if hasTag && len(tags) == 0 { 202 | return nil, nil 203 | } 204 | 205 | return &Tags{ 206 | tags: tags, 207 | }, nil 208 | } 209 | 210 | // Get returns the tag associated with the given key. If the key is present 211 | // in the tag the value (which may be empty) is returned. Otherwise the 212 | // returned value will be the empty string. The ok return value reports whether 213 | // the tag exists or not (which the return value is nil). 214 | func (t *Tags) Get(key string) (*Tag, error) { 215 | for _, tag := range t.tags { 216 | if tag.Key == key { 217 | return tag, nil 218 | } 219 | } 220 | 221 | return nil, errTagNotExist 222 | } 223 | 224 | // Set sets the given tag. If the tag key already exists it'll override it 225 | func (t *Tags) Set(tag *Tag) error { 226 | if tag.Key == "" { 227 | return errKeyNotSet 228 | } 229 | 230 | added := false 231 | for i, tg := range t.tags { 232 | if tg.Key == tag.Key { 233 | added = true 234 | t.tags[i] = tag 235 | } 236 | } 237 | 238 | if !added { 239 | // this means this is a new tag, add it 240 | t.tags = append(t.tags, tag) 241 | } 242 | 243 | return nil 244 | } 245 | 246 | const ( 247 | bit32 = 5 // 5 bits to make 32 different variants 248 | defaultBase = 10 // base 10 of numbers 249 | ) 250 | 251 | func parseUintMax32(s string) (uint8, error) { 252 | if pos, err := strconv.ParseUint(s, defaultBase, bit32); err == nil { 253 | return uint8(pos), nil 254 | } 255 | 256 | return 0, fmt.Errorf("invalid uint32 value: %s", s) 257 | } 258 | -------------------------------------------------------------------------------- /internal/encoding/tl/utils.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package tl 4 | 5 | import ( 6 | "crypto/rand" 7 | "crypto/sha1" 8 | "fmt" 9 | "math/big" 10 | "reflect" 11 | ) 12 | 13 | func padding4(size int) int { 14 | t := (-uint64(size)) & 3 15 | return int(t) 16 | } 17 | 18 | func haveFlag(v any) bool { 19 | typ := reflect.TypeOf(v) 20 | for i := 0; i < typ.NumField(); i++ { 21 | _, found := typ.Field(i).Tag.Lookup(tagName) 22 | if found { 23 | info, err := parseTag(typ.Field(i).Tag) 24 | if err != nil { 25 | continue 26 | } 27 | 28 | if info.ignore { 29 | continue 30 | } 31 | 32 | return true 33 | } 34 | } 35 | 36 | return false 37 | } 38 | 39 | func sliceToInterfaceSlice(in any) []any { 40 | if in == nil { 41 | return nil 42 | } 43 | 44 | ival := reflect.ValueOf(in) 45 | if ival.Type().Kind() != reflect.Slice { 46 | panic("not a slice: " + ival.Type().String()) 47 | } 48 | 49 | res := make([]any, ival.Len()) 50 | for i := 0; i < ival.Len(); i++ { 51 | res[i] = ival.Index(i).Interface() 52 | } 53 | 54 | return res 55 | } 56 | 57 | func Sha1Byte(input []byte) []byte { 58 | r := sha1.Sum(input) 59 | return r[:] 60 | } 61 | 62 | func Sha1(input string) []byte { 63 | r := sha1.Sum([]byte(input)) 64 | return r[:] 65 | } 66 | 67 | func RandomBytes(size int) []byte { 68 | b := make([]byte, size) 69 | _, _ = rand.Read(b) 70 | return b 71 | } 72 | 73 | var bitlen = []int{ 74 | 1 << 3, // 8 75 | 1 << 4, // 16 76 | 1 << 5, // 32 77 | 1 << 6, // 64 78 | 1 << 7, // 128 79 | 1 << 8, // 256 80 | 1 << 9, // 512 81 | 1 << 10, // 1024 82 | 1 << 11, // 2048 83 | } 84 | 85 | func BigIntBytes(v *big.Int, bitsize int) []byte { 86 | vbytes := v.Bytes() 87 | vbytesLen := len(vbytes) 88 | for i, b := range bitlen { 89 | if b == bitsize { 90 | break 91 | } 92 | 93 | if i == len(bitlen)-1 { 94 | panic(fmt.Errorf("bitsize not squaring by 2: bitsize %v", bitsize)) 95 | } 96 | } 97 | 98 | offset := bitsize/8 - vbytesLen 99 | if offset < 0 { 100 | panic(fmt.Errorf("bitsize too small: have %v, want at least %v", bitsize, vbytes)) 101 | } 102 | 103 | return append(make([]byte, offset), vbytes...) 104 | } 105 | -------------------------------------------------------------------------------- /internal/keys/keys.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package keys 4 | 5 | import ( 6 | "bytes" 7 | "crypto/rsa" 8 | "crypto/sha1" 9 | "crypto/x509" 10 | "encoding/pem" 11 | "fmt" 12 | "log" 13 | "math/big" 14 | 15 | "github.com/amarnathcjd/gogram/internal/encoding/tl" 16 | ) 17 | 18 | var RsaKeys = "-----BEGIN RSA PUBLIC KEY-----\nMIIBCgKCAQEAwVACPi9w23mF3tBkdZz+zwrzKOaaQdr01vAbU4E1pvkfj4sqDsm6\nlyDONS789sVoD/xCS9Y0hkkC3gtL1tSfTlgCMOOul9lcixlEKzwKENj1Yz/s7daS\nan9tqw3bfUV/nqgbhGX81v/+7RFAEd+RwFnK7a+XYl9sluzHRyVVaTTveB2GazTw\nEfzk2DWgkBluml8OREmvfraX3bkHZJTKX4EQSjBbbdJ2ZXIsRrYOXfaA+xayEGB+\n8hdlLmAjbCVfaigxX0CDqWeR1yFL9kwd9P0NsZRPsmoqVwMbMu7mStFai6aIhc3n\nSlv8kg9qv1m6XHVQY3PnEw+QQtqSIXklHwIDAQAB\n-----END RSA PUBLIC KEY-----\n\n-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAruw2yP/BCcsJliRoW5eB\nVBVle9dtjJw+OYED160Wybum9SXtBBLXriwt4rROd9csv0t0OHCaTmRqBcQ0J8fx\nhN6/cpR1GWgOZRUAiQxoMnlt0R93LCX/j1dnVa/gVbCjdSxpbrfY2g2L4frzjJvd\nl84Kd9ORYjDEAyFnEA7dD556OptgLQQ2e2iVNq8NZLYTzLp5YpOdO1doK+ttrltg\ngTCy5SrKeLoCPPbOgGsdxJxyz5KKcZnSLj16yE5HvJQn0CNpRdENvRUXe6tBP78O\n39oJ8BTHp9oIjd6XWXAsp2CvK45Ol8wFXGF710w9lwCGNbmNxNYhtIkdqfsEcwR5\nJwIDAQAB\n-----END PUBLIC KEY-----\n\n-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvfLHfYH2r9R70w8prHbl\nWt/nDkh+XkgpflqQVcnAfSuTtO05lNPspQmL8Y2XjVT4t8cT6xAkdgfmmvnvRPOO\nKPi0OfJXoRVylFzAQG/j83u5K3kRLbae7fLccVhKZhY46lvsueI1hQdLgNV9n1cQ\n3TDS2pQOCtovG4eDl9wacrXOJTG2990VjgnIKNA0UMoP+KF03qzryqIt3oTvZq03\nDyWdGK+AZjgBLaDKSnC6qD2cFY81UryRWOab8zKkWAnhw2kFpcqhI0jdV5QaSCEx\nvnsjVaX0Y1N0870931/5Jb9ICe4nweZ9kSDF/gip3kWLG0o8XQpChDfyvsqB9OLV\n/wIDAQAB\n-----END PUBLIC KEY-----\n\n-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAs/ditzm+mPND6xkhzwFI\nz6J/968CtkcSE/7Z2qAJiXbmZ3UDJPGrzqTDHkO30R8VeRM/Kz2f4nR05GIFiITl\n4bEjvpy7xqRDspJcCFIOcyXm8abVDhF+th6knSU0yLtNKuQVP6voMrnt9MV1X92L\nGZQLgdHZbPQz0Z5qIpaKhdyA8DEvWWvSUwwc+yi1/gGaybwlzZwqXYoPOhwMebzK\nUk0xW14htcJrRrq+PXXQbRzTMynseCoPIoke0dtCodbA3qQxQovE16q9zz4Otv2k\n4j63cz53J+mhkVWAeWxVGI0lltJmWtEYK6er8VqqWot3nqmWMXogrgRLggv/Nbbo\noQIDAQAB\n-----END PUBLIC KEY-----\n\n-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvmpxVY7ld/8DAjz6F6q0\n5shjg8/4p6047bn6/m8yPy1RBsvIyvuDuGnP/RzPEhzXQ9UJ5Ynmh2XJZgHoE9xb\nnfxL5BXHplJhMtADXKM9bWB11PU1Eioc3+AXBB8QiNFBn2XI5UkO5hPhbb9mJpjA\n9Uhw8EdfqJP8QetVsI/xrCEbwEXe0xvifRLJbY08/Gp66KpQvy7g8w7VB8wlgePe\nxW3pT13Ap6vuC+mQuJPyiHvSxjEKHgqePji9NP3tJUFQjcECqcm0yV7/2d0t/pbC\nm+ZH1sadZspQCEPPrtbkQBlvHb4OLiIWPGHKSMeRFvp3IWcmdJqXahxLCUS1Eh6M\nAQIDAQAB\n-----END PUBLIC KEY-----" 19 | 20 | // RSAFingerprint calculates the fingerprint of an RSA key. 21 | // 22 | // Since an RSA key in MTProto is represented as a TL object, a buffer is used for the calculation. 23 | // For more information, see: https://core.telegram.org/mtproto/auth_key 24 | func RSAFingerprint(key *rsa.PublicKey) []byte { 25 | if key == nil { 26 | log.Fatal("key is nil") 27 | } 28 | exponentAsBigInt := (big.NewInt(0)).SetInt64(int64(key.E)) 29 | 30 | buf := bytes.NewBuffer(nil) 31 | e := tl.NewEncoder(buf) 32 | e.PutMessage(key.N.Bytes()) 33 | e.PutMessage(exponentAsBigInt.Bytes()) 34 | 35 | fingerprint := Sha1(buf.String()) 36 | return []byte(fingerprint)[12:] 37 | } 38 | 39 | func ParsePublicKey(data string) (*rsa.PublicKey, error) { 40 | block, _ := pem.Decode([]byte(data)) 41 | if block == nil { 42 | return nil, fmt.Errorf("failed to parse PEM block containing the public key") 43 | } 44 | 45 | key, err := pemBytesToRsa(block.Bytes) 46 | if err != nil { 47 | return nil, fmt.Errorf("failed to parse public key: %s", err) 48 | } 49 | 50 | return key, nil 51 | } 52 | 53 | func GetRSAKeys() ([]*rsa.PublicKey, error) { 54 | data := []byte(RsaKeys) 55 | keys := make([]*rsa.PublicKey, 0) 56 | for { 57 | block, rest := pem.Decode(data) 58 | if block == nil { 59 | break 60 | } 61 | 62 | key, err := pemBytesToRsa(block.Bytes) 63 | if err != nil { 64 | const offset = 1 65 | return nil, fmt.Errorf("failed to parse key at offset %d: %s", len(data)-len(rest)+offset, err) 66 | } 67 | 68 | keys = append(keys, key) 69 | data = rest 70 | } 71 | 72 | return keys, nil 73 | } 74 | 75 | func pemBytesToRsa(data []byte) (*rsa.PublicKey, error) { 76 | key, err := x509.ParsePKCS1PublicKey(data) 77 | if err == nil { 78 | return key, nil 79 | } 80 | 81 | if err.Error() == "x509: failed to parse public key (use ParsePKIXPublicKey instead for this key format)" { 82 | var k any 83 | k, err = x509.ParsePKIXPublicKey(data) 84 | if err == nil { 85 | return k.(*rsa.PublicKey), nil 86 | } 87 | } 88 | 89 | return nil, err 90 | } 91 | 92 | func SaveRsaKey(key *rsa.PublicKey) string { 93 | data := x509.MarshalPKCS1PublicKey(key) 94 | buf := bytes.NewBufferString("") 95 | err := pem.Encode(buf, &pem.Block{ 96 | Type: "RSA PUBLIC KEY", 97 | Bytes: data, 98 | }) 99 | if err != nil { 100 | log.Fatal(err) 101 | } 102 | 103 | return buf.String() 104 | } 105 | 106 | func Sha1(input string) []byte { 107 | r := sha1.Sum([]byte(input)) 108 | return r[:] 109 | } 110 | -------------------------------------------------------------------------------- /internal/math/math.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | package math 3 | 4 | import ( 5 | "crypto/rsa" 6 | "math" 7 | "math/big" 8 | "math/rand" 9 | "time" 10 | ) 11 | 12 | var ( 13 | // all of them uses just for code simplification 14 | big0 = big.NewInt(0) 15 | big1 = big.NewInt(1) 16 | big15 = big.NewInt(15) 17 | big17 = big.NewInt(17) 18 | ) 19 | 20 | // DoRSAencrypt encrypts exactly 1 message block of size 255 with the public key. 21 | // Specific algorithm for mtproto, because the documentation does not indicate is 22 | // this encryption working by OAEP spec or any else 23 | func DoRSAencrypt(block []byte, key *rsa.PublicKey) []byte { 24 | if len(block) != math.MaxUint8 { 25 | panic("block size isn't equal 255 bytes") 26 | } 27 | z := big.NewInt(0).SetBytes(block) 28 | exponent := big.NewInt(int64(key.E)) 29 | 30 | c := big.NewInt(0).Exp(z, exponent, key.N) 31 | 32 | res := make([]byte, 256) 33 | copy(res, c.Bytes()) 34 | 35 | return res 36 | } 37 | 38 | // SplitPQ splits a number into two primes, while p1 < p2 39 | // Part of diffie hellman's algorithm, how it works - no idea 40 | func SplitPQ(pq *big.Int) (p1, p2 *big.Int) { 41 | // Benchmark: Fac 15x faster than SplitPQ 42 | // TODO: test extensively for fail cases 43 | rndmax := big.NewInt(0).SetBit(big.NewInt(0), 64, 1) 44 | 45 | what := big.NewInt(0).Set(pq) 46 | rnd := rand.New(rand.NewSource(time.Now().UnixNano())) 47 | g := big.NewInt(0) 48 | i := 0 49 | for !(g.Cmp(big1) == 1 && g.Cmp(what) == -1) { 50 | q := big.NewInt(0).Rand(rnd, rndmax) 51 | q = q.And(q, big15) 52 | q = q.Add(q, big17) 53 | q = q.Mod(q, what) 54 | 55 | x := big.NewInt(0).Rand(rnd, rndmax) 56 | whatnext := big.NewInt(0).Sub(what, big1) 57 | x = x.Mod(x, whatnext) 58 | x = x.Add(x, big1) 59 | 60 | y := big.NewInt(0).Set(x) 61 | lim := 1 << (uint(i) + 18) 62 | j := 1 63 | flag := true 64 | 65 | for j < lim && flag { 66 | a := big.NewInt(0).Set(x) 67 | b := big.NewInt(0).Set(x) 68 | c := big.NewInt(0).Set(q) 69 | 70 | for b.Cmp(big0) == 1 { 71 | b2 := big.NewInt(0) 72 | if b2.And(b, big1).Cmp(big0) == 1 { 73 | c.Add(c, a) 74 | if c.Cmp(what) >= 0 { 75 | c.Sub(c, what) 76 | } 77 | } 78 | a.Add(a, a) 79 | if a.Cmp(what) >= 0 { 80 | a.Sub(a, what) 81 | } 82 | b.Rsh(b, 1) 83 | } 84 | x.Set(c) 85 | 86 | z := big.NewInt(0) 87 | if x.Cmp(y) == -1 { 88 | z.Add(what, x) 89 | z.Sub(z, y) 90 | } else { 91 | z.Sub(x, y) 92 | } 93 | g.GCD(nil, nil, z, what) 94 | 95 | if (j & (j - 1)) == 0 { 96 | y.Set(x) 97 | } 98 | j++ 99 | 100 | if g.Cmp(big1) != 0 { 101 | flag = false 102 | } 103 | } 104 | i++ 105 | } 106 | 107 | p1 = big.NewInt(0).Set(g) 108 | p2 = big.NewInt(0).Div(what, g) 109 | 110 | if p1.Cmp(p2) == 1 { 111 | p1, p2 = p2, p1 112 | } 113 | 114 | return p1, p2 115 | } 116 | 117 | func MakeGAB(g int32, g_a, dh_prime *big.Int) (b, g_b, g_ab *big.Int) { 118 | rnd := rand.New(rand.NewSource(time.Now().UnixNano())) 119 | rndmax := big.NewInt(0).SetBit(big.NewInt(0), 2048, 1) 120 | b = big.NewInt(0).Rand(rnd, rndmax) 121 | g_b = big.NewInt(0).Exp(big.NewInt(int64(g)), b, dh_prime) 122 | g_ab = big.NewInt(0).Exp(g_a, b, dh_prime) 123 | 124 | return 125 | } 126 | 127 | func Xor(dst, src []byte) { 128 | for i := range dst { 129 | dst[i] ^= src[i] 130 | } 131 | } 132 | 133 | // Fac splits a number into two primes, while p < q 134 | // Part of diffie hellman's algorithm 135 | // Uses Pollard's rho algorithm 136 | func Fac(pq *big.Int) (p, q *big.Int) { 137 | p = big.NewInt(0).Set(pq) 138 | q = big.NewInt(1) 139 | 140 | x := big.NewInt(2) 141 | y := big.NewInt(2) 142 | d := big.NewInt(1) 143 | 144 | for d.Cmp(big.NewInt(1)) == 0 { 145 | x = f(x, pq) 146 | y = f(f(y, pq), pq) 147 | 148 | temp := big.NewInt(0).Set(x) 149 | temp.Sub(temp, y) 150 | temp.Abs(temp) 151 | d.GCD(nil, nil, temp, pq) 152 | } 153 | 154 | p.Set(d) 155 | q.Div(pq, d) 156 | 157 | if p.Cmp(q) == 1 { 158 | p, q = q, p 159 | } 160 | 161 | return p, q 162 | } 163 | 164 | func f(x, n *big.Int) *big.Int { 165 | result := big.NewInt(0).Set(x) 166 | result.Mul(result, result) 167 | result.Add(result, big.NewInt(1)) 168 | result.Mod(result, n) 169 | return result 170 | } 171 | -------------------------------------------------------------------------------- /internal/mode/arbiged.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package mode 4 | 5 | import ( 6 | "encoding/binary" 7 | "fmt" 8 | 9 | "io" 10 | 11 | "github.com/amarnathcjd/gogram/internal/encoding/tl" 12 | ) 13 | 14 | type abridged struct { 15 | conn io.ReadWriter 16 | } 17 | 18 | var _ Mode = (*abridged)(nil) 19 | 20 | var transportModeAbridged = [...]byte{0xef} // 0xef is a magic number 21 | 22 | func (*abridged) getModeAnnouncement() []byte { 23 | return transportModeAbridged[:] 24 | } 25 | 26 | const ( 27 | // If the packet length is greater than or equal to 127 words, we encode 4 bytes for the length: 28 | // - 1 byte is a magic number (0x7f). 29 | // - The remaining 3 bytes represent the actual length in little-endian order. 30 | // 31 | // See: https://core.telegram.org/mtproto/mtproto-transports#abridged 32 | magicValueSizeMoreThanSingleByte = 0x7f 33 | ) 34 | 35 | func (m *abridged) WriteMsg(msg []byte) error { 36 | if len(msg)%4 != 0 { 37 | return ErrNotMultiple{Len: len(msg)} 38 | } 39 | 40 | bsize := make([]byte, 4) 41 | 42 | msgLength := len(msg) / tl.WordLen 43 | if msgLength < int(magicValueSizeMoreThanSingleByte) { 44 | bsize[0] = byte(msgLength) 45 | bsize = bsize[:1] 46 | } else { 47 | binary.LittleEndian.PutUint32(bsize, uint32(msgLength)<<8|magicValueSizeMoreThanSingleByte) 48 | } 49 | 50 | if _, err := m.conn.Write(bsize); err != nil { 51 | return err 52 | } 53 | if _, err := m.conn.Write(msg); err != nil { 54 | return err 55 | } 56 | 57 | return nil 58 | } 59 | 60 | func (m *abridged) ReadMsg() ([]byte, error) { 61 | sizeBuf := make([]byte, 4) 62 | n, err := m.conn.Read(sizeBuf[:1]) 63 | if err != nil { 64 | return nil, err 65 | } 66 | if n != 1 { 67 | return nil, fmt.Errorf("need to read at least 1 byte") 68 | } 69 | 70 | size := int(sizeBuf[0]) 71 | 72 | if size == magicValueSizeMoreThanSingleByte { 73 | n, err := m.conn.Read(sizeBuf[:3]) 74 | if err != nil { 75 | return nil, err 76 | } 77 | if n != 3 { 78 | return nil, fmt.Errorf("need to read 3 bytes, got %v", n) 79 | } 80 | 81 | size = int(binary.LittleEndian.Uint32(sizeBuf)) 82 | } 83 | 84 | size *= tl.WordLen 85 | 86 | msg := make([]byte, size) 87 | 88 | n, err = m.conn.Read(msg) 89 | if err != nil { 90 | return nil, err 91 | } 92 | if n != int(size) { 93 | return nil, fmt.Errorf("expected to read %d bytes, got %d", size, n) 94 | } 95 | 96 | return msg, nil 97 | } 98 | -------------------------------------------------------------------------------- /internal/mode/errors.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package mode 4 | 5 | import ( 6 | "fmt" 7 | 8 | "github.com/pkg/errors" 9 | ) 10 | 11 | var ( 12 | ErrInterfaceIsNil = errors.New("interface is nil") 13 | ErrModeNotSupported = errors.New("mode is not supported") 14 | ErrAmbiguousModeAnnounce = errors.New("ambiguous mode announce, expected other byte sequence") 15 | ) 16 | 17 | type ErrNotMultiple struct { 18 | Len int 19 | } 20 | 21 | func (e ErrNotMultiple) Error() string { 22 | msg := "size of message not multiple of 4" 23 | if e.Len != 0 { 24 | return fmt.Sprintf(msg+" (got %v)", e.Len) 25 | } 26 | return msg 27 | } 28 | -------------------------------------------------------------------------------- /internal/mode/full.go: -------------------------------------------------------------------------------- 1 | package mode 2 | 3 | import ( 4 | "encoding/binary" 5 | "errors" 6 | "fmt" 7 | "hash/crc32" 8 | "io" 9 | ) 10 | 11 | var ( 12 | ErrChecksumMismatch = errors.New("checksum mismatch") 13 | ) 14 | 15 | type full struct { 16 | conn io.ReadWriter 17 | seqNo uint32 18 | } 19 | 20 | func (m *full) WriteMsg(msg []byte) error { 21 | msgLen := uint32(len(msg) + 12) // Header size is 12 bytes 22 | 23 | buf := make([]byte, msgLen) 24 | binary.LittleEndian.PutUint32(buf[0:4], msgLen) 25 | binary.LittleEndian.PutUint32(buf[4:8], m.seqNo) 26 | copy(buf[8:8+len(msg)], msg) 27 | 28 | checksum := crc32sum(buf[:8+len(msg)]) 29 | binary.LittleEndian.PutUint32(buf[8+len(msg):], checksum) 30 | 31 | if _, err := m.conn.Write(buf); err != nil { 32 | return err 33 | } 34 | 35 | m.seqNo++ 36 | return nil 37 | } 38 | 39 | func (m *full) ReadMsg() ([]byte, error) { 40 | bsize := make([]byte, 4) 41 | _, err := io.ReadFull(m.conn, bsize) 42 | if err != nil { 43 | return nil, err 44 | } 45 | size := int(binary.LittleEndian.Uint32(bsize)) 46 | 47 | if size > 16*1024*1024 { // 16MB 48 | return nil, fmt.Errorf("invalid message size: %d", size) 49 | } 50 | 51 | buf := make([]byte, size) 52 | // panic: runtime error: slice bounds out of range [4:2] 53 | if size < 8 { 54 | return nil, fmt.Errorf("invalid message size: %d", size) 55 | } 56 | _, err = io.ReadFull(m.conn, buf[4:]) 57 | if err != nil { 58 | return nil, err 59 | } 60 | copy(buf, bsize) 61 | 62 | _ = binary.LittleEndian.Uint32(buf[4:]) // seqNo 63 | checksum := binary.LittleEndian.Uint32(buf[size-4:]) 64 | 65 | if crc32sum(buf[:size-4]) != checksum { 66 | return nil, ErrChecksumMismatch 67 | } 68 | 69 | return buf[8 : size-4], nil 70 | } 71 | 72 | func (*full) getModeAnnouncement() []byte { 73 | return nil 74 | } 75 | 76 | var _ Mode = (*full)(nil) 77 | 78 | func crc32sum(b []byte) uint32 { 79 | return crc32.ChecksumIEEE(b) 80 | } 81 | -------------------------------------------------------------------------------- /internal/mode/intermediate.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package mode 4 | 5 | import ( 6 | "encoding/binary" 7 | "fmt" 8 | "io" 9 | 10 | "github.com/amarnathcjd/gogram/internal/encoding/tl" 11 | ) 12 | 13 | type intermediate struct { 14 | conn io.ReadWriter 15 | } 16 | 17 | var _ Mode = (*intermediate)(nil) 18 | 19 | var transportModeIntermediate = [...]byte{0xee, 0xee, 0xee, 0xee} // meta:immutable 20 | 21 | func (*intermediate) getModeAnnouncement() []byte { 22 | return transportModeIntermediate[:] 23 | } 24 | 25 | func (m *intermediate) WriteMsg(msg []byte) error { 26 | size := make([]byte, tl.WordLen) 27 | binary.LittleEndian.PutUint32(size, uint32(len(msg))) 28 | if _, err := m.conn.Write(size); err != nil { 29 | return err 30 | } 31 | if _, err := m.conn.Write(msg); err != nil { 32 | return err 33 | } 34 | 35 | return nil 36 | } 37 | 38 | func (m *intermediate) ReadMsg() ([]byte, error) { 39 | sizeBuf := make([]byte, tl.WordLen) 40 | n, err := io.ReadFull(m.conn, sizeBuf) 41 | if err != nil { 42 | return nil, err 43 | } 44 | if n != tl.WordLen { 45 | return nil, fmt.Errorf("size is not length of int32, expected 4 bytes, got %d", n) 46 | } 47 | 48 | size := binary.LittleEndian.Uint32(sizeBuf) 49 | 50 | if size > 1<<30 { // can case memory exhaustion 51 | return nil, fmt.Errorf("invalid message size: %d", size) 52 | } 53 | 54 | msg := make([]byte, int(size)) 55 | n, err = io.ReadFull(m.conn, msg) 56 | if err != nil { 57 | return nil, err 58 | } 59 | if n != int(size) { 60 | return nil, fmt.Errorf("expected to read %d bytes, got %d", size, n) 61 | } 62 | 63 | return msg, nil 64 | } 65 | -------------------------------------------------------------------------------- /internal/mode/mode.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package mode 4 | 5 | import ( 6 | "bytes" 7 | "io" 8 | 9 | "github.com/pkg/errors" 10 | ) 11 | 12 | // Mode is an interface that defines how the connection sides determine the size of transmitted messages. 13 | // Unlike HTTP or UDP connections, raw TCP connections and WebSockets don't have a standard way to 14 | // determine the size of transmitted or received messages. Their main purpose is to transmit bytes in 15 | // the correct order. Mode allows the connection sides to avoid analyzing traffic or using end-of-message 16 | // sequences. 17 | // 18 | // In the MTProto world, Mode acts like a microprotocol. It packages messages in a container that 19 | // announces its size in advance. 20 | type Mode interface { 21 | WriteMsg([]byte) error // this is not same as the io.Writer 22 | ReadMsg() ([]byte, error) 23 | 24 | // getModeAnnouncement returns announce byte sequence to other side 25 | getModeAnnouncement() []byte 26 | } 27 | 28 | type Variant uint8 29 | 30 | const ( 31 | Abridged Variant = iota 32 | Intermediate 33 | PaddedIntermediate 34 | Full 35 | ) 36 | 37 | func New(v Variant, conn io.ReadWriter) (Mode, error) { 38 | if conn == nil { 39 | return nil, ErrInterfaceIsNil 40 | } 41 | 42 | m, err := initMode(v, conn) 43 | if err != nil { 44 | return nil, err 45 | } 46 | announcement := m.getModeAnnouncement() 47 | _, err = conn.Write(announcement) 48 | if err != nil { 49 | return nil, errors.Wrap(err, "can't setup connection") 50 | } 51 | 52 | return m, nil 53 | } 54 | 55 | func initMode(v Variant, conn io.ReadWriter) (Mode, error) { 56 | switch v { 57 | case PaddedIntermediate: 58 | panic("not supported yet") 59 | case Abridged: 60 | return &abridged{conn: conn}, nil 61 | case Intermediate: 62 | return &intermediate{conn: conn}, nil 63 | case Full: 64 | return &full{conn: conn}, nil 65 | default: 66 | return nil, ErrModeNotSupported 67 | } 68 | } 69 | 70 | // Detect detects mode based on first byte sequence returned from conn 71 | func Detect(conn io.ReadWriter) (Mode, error) { 72 | if conn == nil { 73 | return nil, ErrInterfaceIsNil 74 | } 75 | b := []byte{0x0} 76 | _, err := conn.Read(b) 77 | if err != nil { 78 | return nil, err 79 | } 80 | 81 | var detectedMode Variant 82 | switch b[0] { 83 | case transportModeAbridged[0]: 84 | detectedMode = Abridged 85 | case transportModeIntermediate[0]: 86 | modeAnnounce := make([]byte, 4) 87 | copy(modeAnnounce, b) 88 | _, err = conn.Read(modeAnnounce[1:]) 89 | if err != nil { 90 | return nil, err 91 | } 92 | if !bytes.Equal(modeAnnounce, transportModeIntermediate[:]) { 93 | return nil, ErrAmbiguousModeAnnounce 94 | } 95 | detectedMode = Intermediate 96 | default: 97 | return nil, ErrModeNotSupported 98 | } 99 | 100 | return initMode(detectedMode, conn) 101 | } 102 | 103 | func GetVariant(m Mode) (Variant, error) { 104 | switch m.(type) { 105 | case *abridged: 106 | return Abridged, nil 107 | case *intermediate: 108 | return Intermediate, nil 109 | case *full: 110 | return Full, nil 111 | default: 112 | return Variant(0xff), errors.New("using custom mode, cant't detect") 113 | } 114 | } 115 | -------------------------------------------------------------------------------- /internal/mtproto/messages/messages.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package messages 4 | 5 | // messages provides functions for encoding and decoding messages in MTProto. 6 | // It handles the serialization and deserialization of messages using the MTProto protocol. 7 | import ( 8 | "bytes" 9 | "encoding/binary" 10 | "fmt" 11 | 12 | ige "github.com/amarnathcjd/gogram/internal/aes_ige" 13 | "github.com/amarnathcjd/gogram/internal/encoding/tl" 14 | "github.com/amarnathcjd/gogram/internal/utils" 15 | "github.com/pkg/errors" 16 | ) 17 | 18 | // Common is a message (either encrypted or unencrypted) used for communication between the client and server. 19 | type Common interface { 20 | GetMsg() []byte 21 | GetMsgID() int 22 | GetSeqNo() int 23 | } 24 | 25 | type Encrypted struct { 26 | Msg []byte 27 | MsgID int64 28 | AuthKeyHash []byte 29 | 30 | Salt int64 31 | SessionID int64 32 | SeqNo int32 33 | MsgKey []byte 34 | } 35 | 36 | func (msg *Encrypted) Serialize(client MessageInformator, seqNo int32) ([]byte, error) { 37 | obj := serializePacket(client, msg.Msg, msg.MsgID, seqNo) 38 | encryptedData, msgKey, err := ige.Encrypt(obj, client.GetAuthKey()) 39 | if err != nil { 40 | return nil, errors.Wrap(err, "encrypting") 41 | } 42 | 43 | buf := bytes.NewBuffer(nil) 44 | 45 | e := tl.NewEncoder(buf) 46 | e.PutRawBytes(utils.AuthKeyHash(client.GetAuthKey())) 47 | e.PutRawBytes(msgKey) 48 | e.PutRawBytes(encryptedData) 49 | 50 | return buf.Bytes(), nil 51 | } 52 | 53 | func DeserializeEncrypted(data, authKey []byte) (*Encrypted, error) { 54 | msg := new(Encrypted) 55 | 56 | buf := bytes.NewBuffer(data) 57 | d, err := tl.NewDecoder(buf) 58 | if err != nil { 59 | return nil, err 60 | } 61 | keyHash := d.PopRawBytes(tl.LongLen) 62 | if !bytes.Equal(keyHash, utils.AuthKeyHash(authKey)) { 63 | return nil, errors.New("wrong encryption key") 64 | } 65 | msg.MsgKey = d.PopRawBytes(tl.Int128Len) 66 | encryptedData := d.PopRawBytes(len(data) - (tl.LongLen + tl.Int128Len)) 67 | 68 | decrypted, err := ige.Decrypt(encryptedData, authKey, msg.MsgKey) 69 | if err != nil { 70 | return nil, errors.Wrap(err, "decrypting message") 71 | } 72 | buf = bytes.NewBuffer(decrypted) 73 | d, err = tl.NewDecoder(buf) 74 | if err != nil { 75 | return nil, err 76 | } 77 | msg.Salt = d.PopLong() 78 | msg.SessionID = d.PopLong() 79 | msg.MsgID = d.PopLong() 80 | msg.SeqNo = d.PopInt() 81 | messageLen := d.PopInt() 82 | 83 | if len(decrypted) < int(messageLen)-(tl.LongLen+tl.LongLen+tl.LongLen+tl.WordLen+tl.WordLen) { 84 | return nil, fmt.Errorf("message is smaller than it's defining: have %v, but messageLen is %v", len(decrypted), messageLen) 85 | } 86 | 87 | mod := msg.MsgID & 3 88 | if mod != 1 && mod != 3 { 89 | return nil, fmt.Errorf("wrong bits of message_id: %d", mod) 90 | } 91 | 92 | msgKey := ige.MessageKey(authKey, decrypted, true) 93 | if !bytes.Equal(msgKey, msg.MsgKey) { 94 | return nil, errors.New("wrong message key, can't trust to sender") 95 | } 96 | msg.Msg = d.PopRawBytes(int(messageLen)) 97 | 98 | return msg, nil 99 | } 100 | 101 | func (msg *Encrypted) GetMsg() []byte { 102 | return msg.Msg 103 | } 104 | 105 | func (msg *Encrypted) GetMsgID() int { 106 | return int(msg.MsgID) 107 | } 108 | 109 | func (msg *Encrypted) GetSeqNo() int { 110 | return int(msg.SeqNo) 111 | } 112 | 113 | type Unencrypted struct { 114 | Msg []byte 115 | MsgID int64 116 | } 117 | 118 | func (msg *Unencrypted) Serialize(_ MessageInformator) ([]byte, error) { 119 | buf := bytes.NewBuffer(nil) 120 | e := tl.NewEncoder(buf) 121 | // authKeyHash, always 0 if unencrypted 122 | e.PutLong(0) 123 | e.PutLong(msg.MsgID) 124 | e.PutInt(int32(len(msg.Msg))) 125 | e.PutRawBytes(msg.Msg) 126 | return buf.Bytes(), nil 127 | } 128 | 129 | func DeserializeUnencrypted(data []byte) (*Unencrypted, error) { 130 | msg := new(Unencrypted) 131 | d, _ := tl.NewDecoder(bytes.NewBuffer(data)) 132 | _ = d.PopRawBytes(tl.LongLen) // authKeyHash, always 0 if unencrypted 133 | 134 | msg.MsgID = d.PopLong() 135 | 136 | mod := msg.MsgID & 3 137 | if mod != 1 && mod != 3 { 138 | return nil, fmt.Errorf("wrong bits of message_id: %#v", uint64(mod)) 139 | } 140 | 141 | messageLen := d.PopUint() 142 | if len(data)-(tl.LongLen+tl.LongLen+tl.WordLen) != int(messageLen) { 143 | fmt.Println(len(data), int(messageLen), int(messageLen+(tl.LongLen+tl.LongLen+tl.WordLen))) 144 | return nil, fmt.Errorf("message not equal defined size: have %v, want %v", len(data), messageLen) 145 | } 146 | 147 | var err error 148 | msg.Msg, err = d.GetRestOfMessage() 149 | if err != nil { 150 | return nil, errors.Wrap(err, "getting real message") 151 | } 152 | 153 | return msg, nil 154 | } 155 | 156 | func (msg *Unencrypted) GetMsg() []byte { 157 | return msg.Msg 158 | } 159 | 160 | func (msg *Unencrypted) GetMsgID() int { 161 | return int(msg.MsgID) 162 | } 163 | 164 | func (msg *Unencrypted) GetSeqNo() int { 165 | return 0 166 | } 167 | 168 | // ------------------------------------------------------------------------------------------ 169 | // 170 | // MessageInformator is used to provide information about the current session for message serialization. 171 | // It is essentially an MTProto data structure. 172 | type MessageInformator interface { 173 | GetSessionID() int64 174 | GetSeqNo() int32 175 | GetServerSalt() int64 176 | GetAuthKey() []byte 177 | } 178 | 179 | func serializePacket(client MessageInformator, msg []byte, messageID int64, seqNo int32) []byte { 180 | buf := bytes.NewBuffer(nil) 181 | d := tl.NewEncoder(buf) 182 | 183 | saltBytes := make([]byte, tl.LongLen) 184 | binary.LittleEndian.PutUint64(saltBytes, uint64(client.GetServerSalt())) 185 | d.PutRawBytes(saltBytes) 186 | d.PutLong(client.GetSessionID()) 187 | d.PutLong(messageID) 188 | d.PutInt(seqNo) 189 | d.PutInt(int32(len(msg))) 190 | d.PutRawBytes(msg) 191 | return buf.Bytes() 192 | } 193 | -------------------------------------------------------------------------------- /internal/mtproto/objects/const.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package objects 4 | 5 | // in some cases you are required 6 | const ( 7 | // CrcRpcResult is a public variable as it is a specific constructor. 8 | CrcRpcResult = 0xf35c6d01 9 | CrcGzipPacked = 0x3072cfa1 10 | ) 11 | -------------------------------------------------------------------------------- /internal/mtproto/objects/init.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package objects 4 | 5 | import ( 6 | "github.com/amarnathcjd/gogram/internal/encoding/tl" 7 | ) 8 | 9 | func init() { 10 | tl.RegisterObjects( 11 | &ReqPQParams{}, 12 | &ReqDHParamsParams{}, 13 | &SetClientDHParamsParams{}, 14 | &PingParams{}, 15 | &ResPQ{}, 16 | &PQInnerData{}, 17 | &ServerDHParamsFail{}, 18 | &ServerDHParamsOk{}, 19 | &ServerDHInnerData{}, 20 | &ClientDHInnerData{}, 21 | &DHGenOk{}, 22 | &DHGenRetry{}, 23 | &DHGenFail{}, 24 | &RpcResult{}, 25 | &RpcError{}, 26 | &RpcAnswerUnknown{}, 27 | &RpcAnswerDroppedRunning{}, 28 | &RpcAnswerDropped{}, 29 | &FutureSalt{}, 30 | &FutureSalts{}, 31 | &Pong{}, 32 | &NewSessionCreated{}, 33 | &MessageContainer{}, 34 | &MsgCopy{}, 35 | &GzipPacked{}, 36 | &MsgsAck{}, 37 | &BadMsgNotification{}, 38 | &BadServerSalt{}, 39 | &MsgResendReq{}, 40 | &MsgsStateReq{}, 41 | &MsgsStateInfo{}, 42 | &MsgsAllInfo{}, 43 | &MsgsDetailedInfo{}, 44 | &MsgsNewDetailedInfo{}, 45 | ) 46 | } 47 | -------------------------------------------------------------------------------- /internal/mtproto/objects/methods.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package objects 4 | 5 | import ( 6 | "reflect" 7 | 8 | "github.com/pkg/errors" 9 | 10 | "github.com/amarnathcjd/gogram/internal/encoding/tl" 11 | ) 12 | 13 | type requester interface { 14 | MakeRequest(tl.Object) (any, error) 15 | } 16 | 17 | type ReqPQParams struct { 18 | Nonce *tl.Int128 19 | } 20 | 21 | func (*ReqPQParams) CRC() uint32 { 22 | return 0x60469778 23 | } 24 | 25 | func ReqPQ(m requester, nonce *tl.Int128) (*ResPQ, error) { 26 | data, err := m.MakeRequest(&ReqPQParams{Nonce: nonce}) 27 | if err != nil { 28 | return nil, errors.Wrap(err, "sending ReqPQ") 29 | } 30 | 31 | resp, ok := data.(*ResPQ) 32 | if !ok { 33 | return nil, errors.New("got invalid response type: " + reflect.TypeOf(data).String()) 34 | } 35 | 36 | return resp, nil 37 | } 38 | 39 | type ReqPQMultiParams struct { 40 | Nonce *tl.Int128 41 | } 42 | 43 | func (*ReqPQMultiParams) CRC() uint32 { 44 | return 0xbe7e8ef1 45 | } 46 | 47 | func ReqPQMulti(m requester, nonce *tl.Int128) (*ResPQ, error) { 48 | data, err := m.MakeRequest(&ReqPQMultiParams{Nonce: nonce}) 49 | if err != nil { 50 | return nil, errors.Wrap(err, "sending ReqPQMulti") 51 | } 52 | 53 | resp, ok := data.(*ResPQ) 54 | if !ok { 55 | return nil, errors.New("got invalid response type: " + reflect.TypeOf(data).String()) 56 | } 57 | 58 | return resp, nil 59 | } 60 | 61 | type ReqDHParamsParams struct { 62 | Nonce *tl.Int128 63 | ServerNonce *tl.Int128 64 | P []byte 65 | Q []byte 66 | PublicKeyFingerprint int64 67 | EncryptedData []byte 68 | } 69 | 70 | func (*ReqDHParamsParams) CRC() uint32 { 71 | return 0xd712e4be 72 | } 73 | 74 | func ReqDHParams( 75 | m requester, 76 | nonce, serverNonce *tl.Int128, p, q []byte, publicKeyFingerprint int64, encryptedData []byte, 77 | ) (ServerDHParams, error) { 78 | data, err := m.MakeRequest(&ReqDHParamsParams{ 79 | Nonce: nonce, 80 | ServerNonce: serverNonce, 81 | P: p, 82 | Q: q, 83 | PublicKeyFingerprint: publicKeyFingerprint, 84 | EncryptedData: encryptedData, 85 | }) 86 | if err != nil { 87 | return nil, errors.Wrap(err, "sending ReqDHParams") 88 | } 89 | 90 | resp, ok := data.(ServerDHParams) 91 | if !ok { 92 | return nil, errors.New("got invalid response type: " + reflect.TypeOf(data).String()) 93 | } 94 | 95 | return resp, nil 96 | } 97 | 98 | type SetClientDHParamsParams struct { 99 | Nonce *tl.Int128 100 | ServerNonce *tl.Int128 101 | EncryptedData []byte 102 | } 103 | 104 | func (*SetClientDHParamsParams) CRC() uint32 { 105 | return 0xf5045f1f 106 | } 107 | 108 | func SetClientDHParams(m requester, nonce, serverNonce *tl.Int128, encryptedData []byte) (SetClientDHParamsAnswer, error) { 109 | data, err := m.MakeRequest(&SetClientDHParamsParams{ 110 | Nonce: nonce, 111 | ServerNonce: serverNonce, 112 | EncryptedData: encryptedData, 113 | }) 114 | if err != nil { 115 | return nil, errors.Wrap(err, "sending Ping") 116 | } 117 | 118 | resp, ok := data.(SetClientDHParamsAnswer) 119 | if !ok { 120 | return nil, errors.New("got invalid response type: " + reflect.TypeOf(data).String()) 121 | } 122 | 123 | return resp, nil 124 | } 125 | 126 | // rpc_drop_answer 127 | // get_future_salts 128 | 129 | type PingParams struct { 130 | PingID int64 131 | } 132 | 133 | func (*PingParams) CRC() uint32 { 134 | return 0x7abe77ec 135 | } 136 | 137 | func Ping(m requester, pingID int64) (*Pong, error) { 138 | data, err := m.MakeRequest(&PingParams{ 139 | PingID: pingID, 140 | }) 141 | if err != nil { 142 | return nil, errors.Wrap(err, "sending Ping") 143 | } 144 | 145 | resp, ok := data.(*Pong) 146 | if !ok { 147 | return nil, errors.New("got invalid response type: " + reflect.TypeOf(data).String()) 148 | } 149 | 150 | return resp, nil 151 | } 152 | 153 | // ping_delay_disconnect 154 | // destroy_session 155 | // http_wait 156 | 157 | // set_client_DH_params#f5045f1f nonce:int128 server_nonce:int128 encrypted_data:bytes = Set_client_DH_params_answer; 158 | 159 | // rpc_drop_answer#58e4a740 req_msg_id:long = RpcDropAnswer; 160 | // get_future_salts#b921bd04 num:int = FutureSalts; 161 | // ping_delay_disconnect#f3427b8c ping_id:long disconnect_delay:int = Pong; 162 | // destroy_session#e7512126 session_id:long = DestroySessionRes; 163 | 164 | // http_wait#9299359f max_delay:int wait_after:int max_wait:int = HttpWait; 165 | -------------------------------------------------------------------------------- /internal/session/file.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package session 4 | 5 | import ( 6 | "encoding/base64" 7 | "encoding/binary" 8 | "encoding/json" 9 | "fmt" 10 | "os" 11 | "path/filepath" 12 | "syscall" 13 | "time" 14 | 15 | aes "github.com/amarnathcjd/gogram/internal/aes_ige" 16 | "github.com/amarnathcjd/gogram/internal/encoding/tl" 17 | "github.com/pkg/errors" 18 | ) 19 | 20 | const defaultAESKey = "1234567890123456" 21 | 22 | type genericFileSessionLoader struct { 23 | path string 24 | lastEdited time.Time 25 | cached *Session 26 | key string 27 | } 28 | 29 | var _ SessionLoader = (*genericFileSessionLoader)(nil) 30 | 31 | func NewFromFile(path string, authAesKey string) SessionLoader { 32 | if authAesKey == "" { 33 | authAesKey = defaultAESKey 34 | } 35 | 36 | return &genericFileSessionLoader{path: path, key: authAesKey} 37 | } 38 | 39 | func (l *genericFileSessionLoader) Path() string { 40 | return l.path 41 | } 42 | 43 | func (l *genericFileSessionLoader) Key() string { 44 | return l.key 45 | } 46 | 47 | func (l *genericFileSessionLoader) Load() (*Session, error) { 48 | info, err := os.Stat(l.path) 49 | switch { 50 | case err == nil: 51 | case errors.Is(err, syscall.ENOENT): 52 | return nil, errors.Wrap(err, "file not found") 53 | default: 54 | return nil, err 55 | } 56 | 57 | if info.ModTime().Equal(l.lastEdited) && l.cached != nil { 58 | return l.cached, nil 59 | } 60 | 61 | data, err := os.ReadFile(l.path) 62 | data = decodeBytes(data, l.key) 63 | if err != nil { 64 | return nil, errors.Wrap(err, "reading file") 65 | } 66 | 67 | file := new(tokenStorageFormat) 68 | err = json.Unmarshal(data, file) 69 | if err != nil { 70 | return nil, errors.Wrap(err, "parsing file") 71 | } 72 | 73 | s, err := file.readSession() 74 | if err != nil { 75 | return nil, err 76 | } 77 | 78 | l.cached = s 79 | l.lastEdited = info.ModTime() 80 | 81 | return s, nil 82 | } 83 | 84 | func (l *genericFileSessionLoader) Store(s *Session) error { 85 | dir, _ := filepath.Split(l.path) 86 | if stat, err := os.Stat(dir); err != nil { 87 | return fmt.Errorf("%v: directory not found", dir) 88 | } else if !stat.IsDir() { 89 | return fmt.Errorf("%v: not a directory", dir) 90 | } 91 | file := new(tokenStorageFormat) 92 | file.writeSession(s) 93 | data, _ := json.Marshal(file) 94 | 95 | return os.WriteFile(l.path, encodeBytes(data, l.key), 0600) 96 | } 97 | 98 | func (l *genericFileSessionLoader) Delete() error { 99 | return os.Remove(l.path) 100 | } 101 | 102 | type tokenStorageFormat struct { 103 | Key string `json:"key"` 104 | Hash string `json:"hash"` 105 | Salt string `json:"salt"` 106 | Hostname string `json:"hostname"` 107 | AppID int32 `json:"app_id"` 108 | } 109 | 110 | func (t *tokenStorageFormat) writeSession(s *Session) { 111 | t.Key = base64.StdEncoding.EncodeToString(s.Key) 112 | t.Hash = base64.StdEncoding.EncodeToString(s.Hash) 113 | t.Salt = encodeInt64ToBase64(s.Salt) 114 | t.Hostname = s.Hostname 115 | t.AppID = s.AppID 116 | } 117 | 118 | func (t *tokenStorageFormat) readSession() (*Session, error) { 119 | s := new(Session) 120 | var err error 121 | 122 | s.Key, err = base64.StdEncoding.DecodeString(t.Key) 123 | if err != nil { 124 | return nil, errors.Wrap(err, "invalid binary data of 'key'") 125 | } 126 | s.Hash, err = base64.StdEncoding.DecodeString(t.Hash) 127 | if err != nil { 128 | return nil, errors.Wrap(err, "invalid binary data of 'hash'") 129 | } 130 | s.Salt, err = decodeInt64ToBase64(t.Salt) 131 | if err != nil { 132 | return nil, errors.Wrap(err, "invalid binary data of 'salt'") 133 | } 134 | s.Hostname = t.Hostname 135 | s.AppID = t.AppID 136 | return s, nil 137 | } 138 | 139 | func encodeInt64ToBase64(i int64) string { 140 | buf := make([]byte, tl.LongLen) 141 | binary.LittleEndian.PutUint64(buf, uint64(i)) 142 | return base64.StdEncoding.EncodeToString(buf) 143 | } 144 | 145 | func decodeInt64ToBase64(i string) (int64, error) { 146 | buf, err := base64.StdEncoding.DecodeString(i) 147 | if err != nil { 148 | return 0, err 149 | } 150 | return int64(binary.LittleEndian.Uint64(buf)), nil 151 | } 152 | 153 | func encodeBytes(b []byte, key string) []byte { 154 | aesByte, _ := aes.EncryptAES(b, key) 155 | return aesByte 156 | } 157 | 158 | func decodeBytes(b []byte, key string) []byte { 159 | aesByte, _ := aes.DecryptAES(b, key) 160 | return aesByte 161 | } 162 | 163 | func NewInMemory() SessionLoader { 164 | return &inMemorySessionLoader{} 165 | } 166 | 167 | type inMemorySessionLoader struct { 168 | s *Session 169 | } 170 | 171 | var _ SessionLoader = (*inMemorySessionLoader)(nil) 172 | 173 | func (l *inMemorySessionLoader) Path() string { 174 | return ":memory:" 175 | } 176 | 177 | func (l *inMemorySessionLoader) Key() string { 178 | return "in-memory" 179 | } 180 | 181 | func (l *inMemorySessionLoader) Load() (*Session, error) { 182 | return l.s, nil 183 | } 184 | 185 | func (l *inMemorySessionLoader) Store(s *Session) error { 186 | l.s = s 187 | return nil 188 | } 189 | 190 | func (l *inMemorySessionLoader) Delete() error { 191 | l.s = nil 192 | return nil 193 | } 194 | -------------------------------------------------------------------------------- /internal/session/interface.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package session 4 | 5 | import "errors" 6 | 7 | // SessionLoader is the interface which allows you to access sessions from different storages (like 8 | // filesystem, database, s3 storage, etc.) 9 | type SessionLoader interface { 10 | Load() (*Session, error) 11 | Store(*Session) error 12 | Path() string 13 | Key() string 14 | Delete() error 15 | } 16 | 17 | // Session is a basic data of specific session. Typically, session stores default hostname of mtproto server 18 | // (cause all accounts ties to specific server after sign in), session key, server hash and salt. 19 | type Session struct { 20 | Key []byte 21 | Hash []byte 22 | Salt int64 23 | Hostname string 24 | AppID int32 25 | } 26 | 27 | var ( 28 | ErrSessionNotFound = errors.New("session not found") 29 | ErrPathNotFound = "file not found" 30 | ErrFileNotExists = "no such file or directory" 31 | ) 32 | -------------------------------------------------------------------------------- /internal/session/string.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package session 4 | 5 | import ( 6 | "encoding/base64" 7 | "errors" 8 | "strconv" 9 | "strings" 10 | ) 11 | 12 | var ( 13 | ErrInvalidSession = errors.New("the session string is invalid/has been tampered with") 14 | ) 15 | 16 | type StringSession struct { 17 | authKey []byte 18 | authKeyHash []byte 19 | dcID int 20 | ipAddr string 21 | appID int32 22 | } 23 | 24 | func NewStringSession(authKey, authKeyHash []byte, dcID int, ipAddr string, appID int32) *StringSession { 25 | return &StringSession{ 26 | authKey: authKey, 27 | authKeyHash: authKeyHash, 28 | dcID: dcID, 29 | ipAddr: ipAddr, 30 | appID: appID, 31 | } 32 | } 33 | 34 | func NewEmptyStringSession() *StringSession { 35 | return &StringSession{} 36 | } 37 | 38 | func (s StringSession) AuthKey() []byte { 39 | return s.authKey 40 | } 41 | 42 | func (s StringSession) AuthKeyHash() []byte { 43 | return s.authKeyHash 44 | } 45 | 46 | func (s StringSession) DcID() int { 47 | return s.dcID 48 | } 49 | 50 | func (s StringSession) IpAddr() string { 51 | return s.ipAddr 52 | } 53 | 54 | func (s StringSession) AppID() int32 { 55 | return s.appID 56 | } 57 | 58 | func (s *StringSession) Encode() string { 59 | stringPrefix := "1BvX" 60 | sessionContents := []string{ 61 | string(s.authKey), 62 | string(s.authKeyHash), 63 | s.ipAddr, 64 | strconv.Itoa(s.dcID), 65 | strconv.FormatInt(int64(s.appID), 10), 66 | } 67 | return stringPrefix + base64.RawURLEncoding.EncodeToString([]byte(strings.Join(sessionContents, "::"))) 68 | } 69 | 70 | func (s *StringSession) Decode(encoded string) error { 71 | decoded, err := base64.RawURLEncoding.DecodeString(encoded[len("1BvX"):]) 72 | if err != nil { 73 | return err 74 | } 75 | decodedString := string(decoded) 76 | split := strings.Split(decodedString, "::") 77 | if len(split) != 5 { 78 | return ErrInvalidSession 79 | } 80 | for i, v := range split { 81 | switch i { 82 | case 0: 83 | s.authKey = []byte(v) 84 | case 1: 85 | s.authKeyHash = []byte(v) 86 | case 2: 87 | s.ipAddr = v 88 | case 3: 89 | dcId, err := strconv.Atoi(v) 90 | if err != nil { 91 | return err 92 | } 93 | 94 | s.dcID = dcId 95 | case 4: 96 | appId, err := strconv.ParseInt(v, 10, 32) 97 | if err != nil { 98 | return err 99 | } 100 | 101 | s.appID = int32(appId) 102 | } 103 | } 104 | return nil 105 | } 106 | -------------------------------------------------------------------------------- /internal/transport/connection.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package transport 4 | 5 | import ( 6 | "context" 7 | "io" 8 | "net" 9 | "net/url" 10 | "strings" 11 | "time" 12 | 13 | "github.com/pkg/errors" 14 | ) 15 | 16 | type tcpConn struct { 17 | reader *Reader 18 | conn *net.TCPConn 19 | timeout time.Duration 20 | } 21 | 22 | type TCPConnConfig struct { 23 | Ctx context.Context 24 | Host string 25 | IpV6 bool 26 | Timeout time.Duration 27 | Socks *url.URL 28 | } 29 | 30 | func NewTCP(cfg TCPConnConfig) (Conn, error) { 31 | if cfg.Socks != nil && cfg.Socks.Host != "" { 32 | return newSocksTCP(cfg) 33 | } 34 | 35 | tcpPrefix := "tcp" 36 | if cfg.IpV6 && !strings.Contains(cfg.Host, ".") { 37 | tcpPrefix = "tcp6" 38 | } 39 | 40 | tcpAddr, err := net.ResolveTCPAddr(tcpPrefix, cfg.Host) 41 | if err != nil { 42 | return nil, errors.Wrap(err, "resolving tcp") 43 | } 44 | conn, err := net.DialTCP(tcpPrefix, nil, tcpAddr) 45 | // if there is a timeout error, wait 2 secs and retry (only once) 46 | if netErr, ok := err.(net.Error); ok && netErr.Timeout() { 47 | time.Sleep(2 * time.Second) 48 | conn, err = net.DialTCP(tcpPrefix, nil, tcpAddr) 49 | } 50 | 51 | if err != nil { 52 | return nil, errors.Wrap(err, "dialing tcp") 53 | } 54 | 55 | conn.SetKeepAlive(true) 56 | 57 | return &tcpConn{ 58 | reader: NewReader(cfg.Ctx, conn), 59 | conn: conn, 60 | timeout: cfg.Timeout, 61 | }, nil 62 | } 63 | 64 | func newSocksTCP(cfg TCPConnConfig) (Conn, error) { 65 | conn, err := dialProxy(cfg.Socks, cfg.Host) 66 | if err != nil { 67 | return nil, err 68 | } 69 | return &tcpConn{ 70 | reader: NewReader(cfg.Ctx, conn), 71 | conn: conn.(*net.TCPConn), 72 | timeout: cfg.Timeout, 73 | }, nil 74 | } 75 | 76 | func (t *tcpConn) Close() error { 77 | return t.conn.Close() 78 | } 79 | 80 | func (t *tcpConn) Write(b []byte) (int, error) { 81 | return t.conn.Write(b) 82 | } 83 | 84 | func (t *tcpConn) Read(b []byte) (int, error) { 85 | if t.timeout > 0 { 86 | err := t.conn.SetReadDeadline(time.Now().Add(t.timeout)) 87 | if err != nil { 88 | return 0, errors.Wrap(err, "setting read deadline") 89 | } 90 | } 91 | 92 | n, err := t.reader.Read(b) 93 | if err != nil { 94 | if e, ok := err.(*net.OpError); ok || err == io.ErrClosedPipe { 95 | if e.Err.Error() == "i/o timeout" || err == io.ErrClosedPipe { 96 | return 0, errors.Wrap(err, "required to reconnect!") 97 | } 98 | } 99 | switch err { 100 | case io.EOF, context.Canceled: 101 | return 0, err 102 | default: 103 | return 0, errors.Wrap(err, "unexpected error") 104 | } 105 | } 106 | return n, nil 107 | } 108 | -------------------------------------------------------------------------------- /internal/transport/interfaces.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package transport 4 | 5 | import ( 6 | "io" 7 | ) 8 | 9 | type ConnConfig any 10 | type Conn io.ReadWriteCloser 11 | 12 | type ModeConfig = func(Conn) (Mode, error) 13 | type Mode interface { 14 | WriteMsg(msg []byte) error // this is not same as the io.Writer 15 | ReadMsg() ([]byte, error) 16 | } 17 | -------------------------------------------------------------------------------- /internal/transport/proxy.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package transport 4 | 5 | import ( 6 | "encoding/base64" 7 | "errors" 8 | "fmt" 9 | "io" 10 | "net" 11 | "net/url" 12 | "strconv" 13 | "time" 14 | ) 15 | 16 | const DefaultTimeout = 5 * time.Second 17 | 18 | func dialProxy(s *url.URL, address string) (net.Conn, error) { 19 | switch s.Scheme { 20 | case "socks5": 21 | return dialSocks5(s, address) 22 | case "socks4": 23 | return dialSocks4(s, address) 24 | case "http": 25 | return dialHTTP(s, address) 26 | default: 27 | return nil, fmt.Errorf("unsupported proxy scheme: %s", s.Scheme) 28 | } 29 | } 30 | 31 | func dialHTTP(s *url.URL, addr string) (net.Conn, error) { 32 | conn, err := net.DialTimeout("tcp", s.Hostname()+":"+s.Port(), DefaultTimeout) 33 | if err != nil { 34 | return nil, err 35 | } 36 | 37 | // Send CONNECT request 38 | _, err = fmt.Fprintf(conn, "CONNECT %s HTTP/1.1\r\nHost: %s\r\n", addr, addr) 39 | if err != nil { 40 | return nil, err 41 | } 42 | 43 | // Add Proxy-Authorization header if credentials are provided 44 | if s.User != nil && s.User.Username() != "" { 45 | username := s.User.Username() 46 | password, _ := s.User.Password() 47 | _, err = fmt.Fprintf(conn, "Proxy-Authorization: Basic %s\r\n", basicAuth(username, password)) 48 | if err != nil { 49 | return nil, err 50 | } 51 | } 52 | 53 | // End the HTTP request 54 | _, err = fmt.Fprint(conn, "\r\n") 55 | if err != nil { 56 | return nil, err 57 | } 58 | 59 | // Read the HTTP response 60 | buf := make([]byte, 12) 61 | _, err = io.ReadFull(conn, buf) 62 | if err != nil { 63 | return nil, err 64 | } 65 | 66 | // Check the response status code 67 | if string(buf[:9]) != "HTTP/1.1 " { 68 | return nil, errors.New("HTTP connect failed") 69 | } 70 | if string(buf[9:12]) != "200" { 71 | return nil, errors.New("HTTP connect failed") 72 | } 73 | 74 | return conn, nil 75 | } 76 | 77 | func basicAuth(username, password string) string { 78 | return base64.StdEncoding.EncodeToString([]byte(username + ":" + password)) 79 | } 80 | 81 | func dialSocks5(s *url.URL, addr string) (net.Conn, error) { 82 | conn, err := net.DialTimeout("tcp", s.Hostname()+":"+s.Port(), DefaultTimeout) 83 | if err != nil { 84 | return nil, err 85 | } 86 | 87 | // Authentication 88 | if s.User != nil && s.User.Username() != "" { 89 | username := s.User.Username() 90 | password, _ := s.User.Password() 91 | 92 | _, err = conn.Write([]byte{5, 2, 0, 2}) 93 | if err != nil { 94 | return nil, err 95 | } 96 | 97 | buf := make([]byte, 2) 98 | _, err = io.ReadFull(conn, buf) 99 | if err != nil { 100 | return nil, err 101 | } 102 | 103 | if buf[0] != 5 { 104 | return nil, errors.New("socks version not supported") 105 | } 106 | 107 | if buf[1] == 0 { 108 | // No authentication required 109 | } else if buf[1] == 2 { 110 | // Username/password authentication 111 | _, err = conn.Write(append([]byte{1, byte(len(username))}, []byte(username)...)) 112 | if err != nil { 113 | return nil, err 114 | } 115 | _, err = conn.Write(append([]byte{byte(len(password))}, []byte(password)...)) 116 | if err != nil { 117 | return nil, err 118 | } 119 | 120 | buf = make([]byte, 2) 121 | _, err = io.ReadFull(conn, buf) 122 | if err != nil { 123 | return nil, err 124 | } 125 | 126 | if buf[0] != 1 { 127 | return nil, errors.New("socks version not supported") 128 | } 129 | if buf[1] != 0 { 130 | return nil, errors.New("socks authentication failed") 131 | } 132 | } else { 133 | return nil, errors.New("socks authentication method not supported") 134 | } 135 | } else { 136 | // No authentication required 137 | _, err = conn.Write([]byte{5, 1, 0}) 138 | if err != nil { 139 | return nil, err 140 | } 141 | 142 | buf := make([]byte, 2) 143 | _, err = io.ReadFull(conn, buf) 144 | if err != nil { 145 | return nil, err 146 | } 147 | 148 | if buf[0] != 5 { 149 | return nil, errors.New("socks version not supported") 150 | } 151 | if buf[1] != 0 { 152 | return nil, errors.New("socks authentication failed") 153 | } 154 | } 155 | 156 | // Connect to the target address 157 | host, port, err := net.SplitHostPort(addr) 158 | if err != nil { 159 | return nil, err 160 | } 161 | 162 | ip := net.ParseIP(host) 163 | var atyp byte 164 | var dst []byte 165 | 166 | if ip == nil { 167 | atyp = 3 // Domain name 168 | dst = append([]byte{byte(len(host))}, []byte(host)...) 169 | } else if ip4 := ip.To4(); ip4 != nil { 170 | atyp = 1 // IPv4 address 171 | dst = ip4 172 | } else if ip6 := ip.To16(); ip6 != nil { 173 | atyp = 4 // IPv6 address 174 | dst = ip6 175 | } 176 | 177 | p, err := strconv.Atoi(port) 178 | if err != nil { 179 | return nil, err 180 | } 181 | 182 | _, err = conn.Write([]byte{5, 1, 0, atyp}) 183 | if err != nil { 184 | return nil, err 185 | } 186 | _, err = conn.Write(append(dst, byte(p>>8), byte(p))) 187 | if err != nil { 188 | return nil, err 189 | } 190 | 191 | buf := make([]byte, 4) 192 | _, err = io.ReadFull(conn, buf) 193 | if err != nil { 194 | return nil, err 195 | } 196 | 197 | if buf[0] != 5 { 198 | return nil, errors.New("socks version not supported") 199 | } 200 | if buf[1] != 0 { 201 | return nil, errors.New("socks connection failed") 202 | } 203 | 204 | switch buf[3] { 205 | case 1: // IPv4 address 206 | _, err = io.ReadFull(conn, buf[:4]) 207 | if err != nil { 208 | return nil, err 209 | } 210 | case 3: // Domain name 211 | _, err = io.ReadFull(conn, buf[:1]) 212 | if err != nil { 213 | return nil, err 214 | } 215 | n := int(buf[0]) 216 | _, err = io.ReadFull(conn, buf[:n]) 217 | if err != nil { 218 | return nil, err 219 | } 220 | case 4: // IPv6 address 221 | _, err = io.ReadFull(conn, buf[:16]) 222 | if err != nil { 223 | return nil, err 224 | } 225 | default: 226 | return nil, errors.New("socks address type not supported") 227 | } 228 | 229 | _, err = io.ReadFull(conn, buf[:2]) 230 | if err != nil { 231 | return nil, err 232 | } 233 | 234 | return conn, nil 235 | } 236 | 237 | func dialSocks4(s *url.URL, addr string) (net.Conn, error) { 238 | conn, err := net.DialTimeout("tcp", s.Hostname()+":"+s.Port(), DefaultTimeout) 239 | if err != nil { 240 | return nil, err 241 | } 242 | 243 | // Connect to the target address 244 | host, port, err := net.SplitHostPort(addr) 245 | if err != nil { 246 | return nil, err 247 | } 248 | 249 | ip := net.ParseIP(host) 250 | if ip == nil { 251 | return nil, errors.New("SOCKS4 only supports IP addresses") 252 | } 253 | 254 | ip4 := ip.To4() 255 | if ip4 == nil { 256 | return nil, errors.New("SOCKS4 only supports IPv4 addresses") 257 | } 258 | 259 | p, err := strconv.Atoi(port) 260 | if err != nil { 261 | return nil, err 262 | } 263 | 264 | // Send SOCKS4 connect request 265 | _, err = conn.Write([]byte{4, 1, byte(p >> 8), byte(p), ip4[0], ip4[1], ip4[2], ip4[3], 0}) 266 | if err != nil { 267 | return nil, err 268 | } 269 | 270 | // Read the SOCKS4 response 271 | buf := make([]byte, 8) 272 | _, err = io.ReadFull(conn, buf) 273 | if err != nil { 274 | return nil, err 275 | } 276 | 277 | if buf[0] != 0 { 278 | return nil, errors.New("SOCKS version not supported") 279 | } 280 | if buf[1] != 90 { 281 | return nil, errors.New("SOCKS connection failed") 282 | } 283 | 284 | return conn, nil 285 | } 286 | -------------------------------------------------------------------------------- /internal/transport/transport.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package transport 4 | 5 | import ( 6 | "context" 7 | "encoding/binary" 8 | "fmt" 9 | "io" 10 | "reflect" 11 | 12 | "github.com/amarnathcjd/gogram/internal/encoding/tl" 13 | "github.com/amarnathcjd/gogram/internal/mode" 14 | "github.com/amarnathcjd/gogram/internal/mtproto/messages" 15 | "github.com/pkg/errors" 16 | ) 17 | 18 | type Transport interface { 19 | Close() error 20 | WriteMsg(msg messages.Common, seqNo int32) error 21 | ReadMsg() (messages.Common, error) 22 | } 23 | 24 | type transport struct { 25 | conn Conn 26 | mode Mode 27 | m messages.MessageInformator 28 | } 29 | 30 | func NewTransport(m messages.MessageInformator, conn ConnConfig, modeVariant mode.Variant) (Transport, error) { 31 | t := &transport{ 32 | m: m, 33 | } 34 | 35 | var err error 36 | switch cfg := conn.(type) { 37 | case TCPConnConfig: 38 | t.conn, err = NewTCP(cfg) 39 | default: 40 | return nil, fmt.Errorf("unsupported connection type %v", reflect.TypeOf(conn).String()) 41 | } 42 | if err != nil { 43 | return nil, errors.Wrap(err, "setup connection") 44 | } 45 | 46 | t.mode, err = mode.New(modeVariant, t.conn) 47 | if err != nil { 48 | return nil, errors.Wrap(err, "setup mode") 49 | } 50 | 51 | return t, nil 52 | } 53 | 54 | func (t *transport) Close() error { 55 | return t.conn.Close() 56 | } 57 | 58 | func (t *transport) WriteMsg(msg messages.Common, seqNo int32) error { 59 | var data []byte 60 | switch message := msg.(type) { 61 | case *messages.Unencrypted: 62 | data, _ = message.Serialize(t.m) 63 | 64 | case *messages.Encrypted: 65 | var err error 66 | data, err = message.Serialize(t.m, seqNo) 67 | if err != nil { 68 | return errors.Wrap(err, "serializing message") 69 | } 70 | 71 | default: 72 | return fmt.Errorf("supported only mtproto predefined messages, got %v", reflect.TypeOf(msg).String()) 73 | } 74 | 75 | err := t.mode.WriteMsg(data) 76 | if err != nil { 77 | return errors.Wrap(err, "sending request") 78 | } 79 | return nil 80 | } 81 | 82 | func (t *transport) ReadMsg() (messages.Common, error) { 83 | data, err := t.mode.ReadMsg() 84 | if err != nil { 85 | switch err { 86 | case io.EOF, context.Canceled: 87 | return nil, err 88 | default: 89 | return nil, errors.Wrap(err, "reading message") 90 | } 91 | } 92 | 93 | if len(data) == tl.WordLen { 94 | code := int64(binary.LittleEndian.Uint32(data)) 95 | return nil, ErrCode(code) 96 | } 97 | 98 | var msg messages.Common 99 | if isPacketEncrypted(data) { 100 | msg, err = messages.DeserializeEncrypted(data, t.m.GetAuthKey()) 101 | } else { 102 | msg, err = messages.DeserializeUnencrypted(data) 103 | } 104 | if err != nil { 105 | return nil, errors.Wrap(err, "parsing message") 106 | } 107 | 108 | mod := msg.GetMsgID() & 3 // why 3? only god knows why 109 | if mod != 1 && mod != 3 { 110 | return nil, fmt.Errorf("wrong bits of message_id: %d", mod) 111 | } 112 | 113 | return msg, nil 114 | } 115 | 116 | func isPacketEncrypted(data []byte) bool { 117 | if len(data) < tl.DoubleLen { 118 | return false 119 | } 120 | authKeyHash := data[:tl.DoubleLen] 121 | return binary.LittleEndian.Uint64(authKeyHash) != 0 122 | } 123 | 124 | type ErrCode int64 125 | 126 | func (e ErrCode) Error() string { 127 | return fmt.Sprintf("code %v", int64(e)) 128 | } 129 | -------------------------------------------------------------------------------- /internal/transport/utils.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package transport 4 | 5 | import ( 6 | "fmt" 7 | ) 8 | 9 | type ErrNotMultiple struct { 10 | Len int 11 | } 12 | 13 | func (e *ErrNotMultiple) Error() string { 14 | msg := "size of message not multiple of 4" 15 | if e.Len != 0 { 16 | return fmt.Sprintf(msg+" (got %v)", e.Len) 17 | } 18 | return msg 19 | } 20 | -------------------------------------------------------------------------------- /internal/transport/writer.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package transport 4 | 5 | import ( 6 | "context" 7 | "fmt" 8 | "io" 9 | "strconv" 10 | ) 11 | 12 | // Reader is a wrapper around io.Reader, that allows to cancel read operation. 13 | type Reader struct { 14 | ctx context.Context 15 | data chan []byte 16 | 17 | sizeWant chan int 18 | 19 | err error 20 | r io.Reader 21 | } 22 | 23 | func (c *Reader) begin() { 24 | for { 25 | select { 26 | case <-c.ctx.Done(): 27 | close(c.data) 28 | close(c.sizeWant) 29 | return 30 | case sizeWant := <-c.sizeWant: 31 | buf := make([]byte, sizeWant) 32 | n, err := io.ReadFull(c.r, buf) 33 | if err != nil { 34 | c.err = err 35 | close(c.data) 36 | return 37 | } 38 | if n != sizeWant { 39 | panic("read " + strconv.Itoa(n) + ", want " + strconv.Itoa(sizeWant)) 40 | } 41 | c.data <- buf 42 | } 43 | } 44 | } 45 | 46 | func (c *Reader) Read(p []byte) (int, error) { 47 | defer func() { 48 | if r := recover(); r != nil { 49 | c.err = io.ErrClosedPipe 50 | } 51 | }() 52 | 53 | select { 54 | case <-c.ctx.Done(): 55 | return 0, c.ctx.Err() 56 | case c.sizeWant <- len(p): 57 | } 58 | 59 | select { 60 | case <-c.ctx.Done(): 61 | return 0, c.ctx.Err() 62 | case d, ok := <-c.data: 63 | if !ok { 64 | return 0, c.err 65 | } 66 | copy(p, d) 67 | return len(d), nil 68 | } 69 | } 70 | 71 | func (c *Reader) ReadByte() (byte, error) { 72 | b := make([]byte, 1) 73 | 74 | n, err := c.Read(b) 75 | if err != nil { 76 | return 0x0, err 77 | } 78 | if n != 1 { 79 | panic(fmt.Errorf("read more than 1 byte, got %v", n)) 80 | } 81 | 82 | return b[0], nil 83 | } 84 | 85 | func NewReader(ctx context.Context, r io.Reader) *Reader { 86 | c := &Reader{ 87 | r: r, 88 | ctx: ctx, 89 | data: make(chan []byte), 90 | sizeWant: make(chan int), 91 | } 92 | go c.begin() 93 | return c 94 | } 95 | -------------------------------------------------------------------------------- /internal/utils/logging.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package utils 4 | 5 | import ( 6 | "fmt" 7 | "log" 8 | "runtime" 9 | "strings" 10 | ) 11 | 12 | type LogLevel int 13 | 14 | const ( 15 | // DebugLevel is the lowest level of logging 16 | DebugLevel LogLevel = iota + 1 17 | // InfoLevel is the second lowest level of logging (default) 18 | InfoLevel 19 | // WarnLevel is the third highest level of logging 20 | WarnLevel 21 | // ErrorLevel is the highest level of logging 22 | ErrorLevel 23 | // NoLevel disables all logging 24 | NoLevel 25 | // TraceLevel is the highest level of logging 26 | TraceLevel 27 | ) 28 | 29 | var ( 30 | colorOff = []byte("\033[0m") 31 | colorRed = []byte("\033[0;31m") 32 | colorGreen = []byte("\033[0;32m") 33 | colorOrange = []byte("\033[0;33m") 34 | colorPurple = []byte("\033[0;35m") 35 | colorCyan = []byte("\033[0;36m") 36 | ) 37 | 38 | // Logger is the logging struct. 39 | type Logger struct { 40 | Level LogLevel 41 | Prefix string 42 | nocolor bool 43 | } 44 | 45 | // NoColor disables colorized output. 46 | func (l *Logger) NoColor(nocolor ...bool) *Logger { 47 | if len(nocolor) > 0 { 48 | l.nocolor = nocolor[0] 49 | } else { 50 | l.nocolor = true 51 | } 52 | 53 | return l 54 | } 55 | 56 | // Color enables colorized output. (default) 57 | func (l *Logger) Color() bool { 58 | return !l.nocolor 59 | } 60 | 61 | func (l *Logger) SetPrefix(prefix string) *Logger { 62 | l.Prefix = prefix 63 | return l 64 | } 65 | 66 | func (l *Logger) colorize(color []byte, s string) string { 67 | if l.nocolor { 68 | return s 69 | } 70 | return string(color) + s + string(colorOff) 71 | } 72 | 73 | func (l *Logger) Lev() LogLevel { 74 | return l.Level 75 | } 76 | 77 | // SetLevelString sets the level string 78 | func (l *Logger) SetLevel(level LogLevel) *Logger { 79 | l.Level = level 80 | return l 81 | } 82 | 83 | // Log logs a message at the given level. 84 | func (l *Logger) Error(v ...any) { 85 | // TODO: runtime.Caller(1) 86 | if l.Level <= ErrorLevel { 87 | log.Println(l.colorize(colorRed, "[error]"), l.Prefix, "-", getVariable(v...)) 88 | } 89 | } 90 | 91 | func (l *Logger) Warn(v ...any) { 92 | if l.Level <= WarnLevel { 93 | log.Println(l.colorize(colorOrange, "[warn] "), l.Prefix, "-", getVariable(v...)) 94 | } 95 | } 96 | 97 | func (l *Logger) Info(v ...any) { 98 | if l.Level <= InfoLevel { 99 | log.Println(l.colorize(colorGreen, "[info] "), l.Prefix, "-", getVariable(v...)) 100 | } 101 | } 102 | 103 | func (l *Logger) Debug(v ...any) { 104 | if l.Level <= DebugLevel { 105 | log.Println(l.colorize(colorPurple, "[debug]"), l.Prefix, "-", getVariable(v...)) 106 | } 107 | } 108 | 109 | func (l *Logger) Trace(v ...any) { 110 | if l.Level <= TraceLevel { 111 | log.Println(l.colorize(colorCyan, "[trace]"), l.Prefix, "-", getVariable(v...)) 112 | } 113 | } 114 | 115 | func (l *Logger) Panic(v ...any) { 116 | stack := make([]byte, 2048) 117 | runtime.Stack(stack, false) 118 | 119 | log.Println(l.colorize(colorCyan, "[panic]"), l.Prefix, "-", getVariable(v...), "\n", l.colorize(colorOrange, string(stack))) 120 | } 121 | 122 | // NewLogger returns a new Logger instance. 123 | func NewLogger(prefix string) *Logger { 124 | return &Logger{ 125 | Prefix: prefix, 126 | } 127 | } 128 | 129 | func getVariable(v ...any) string { 130 | if len(v) == 0 { 131 | return "" 132 | } 133 | if len(v) == 1 { 134 | return fmt.Sprint(v[0]) 135 | } 136 | return strings.Trim(fmt.Sprint(v...), "[]") 137 | } 138 | -------------------------------------------------------------------------------- /internal/utils/set.go: -------------------------------------------------------------------------------- 1 | package utils 2 | 3 | import ( 4 | "maps" 5 | "sync" 6 | ) 7 | 8 | const minSizeSet = 128 9 | 10 | type null = struct{} 11 | 12 | type SyncSet[T comparable] struct { 13 | mu sync.RWMutex 14 | m map[T]null 15 | } 16 | 17 | func NewSyncSet[T comparable]() *SyncSet[T] { 18 | return &SyncSet[T]{m: make(map[T]null, minSizeSet)} 19 | } 20 | 21 | func (s *SyncSet[T]) Clear() { 22 | s.mu.Lock() 23 | clear(s.m) 24 | s.mu.Unlock() 25 | } 26 | 27 | func (s *SyncSet[T]) Add(key T) bool { 28 | s.mu.Lock() 29 | prevLen := len(s.m) 30 | s.m[key] = null{} 31 | cLen := len(s.m) 32 | s.mu.Unlock() 33 | return prevLen != cLen 34 | } 35 | 36 | func (s *SyncSet[T]) Has(key T) bool { 37 | s.mu.RLock() 38 | _, ok := s.m[key] 39 | s.mu.RUnlock() 40 | return ok 41 | } 42 | 43 | func (s *SyncSet[T]) Delete(key T) { 44 | s.mu.Lock() 45 | delete(s.m, key) 46 | s.mu.Unlock() 47 | } 48 | 49 | func (s *SyncSet[T]) Pop(key T) bool { 50 | s.mu.Lock() 51 | _, ok := s.m[key] 52 | if ok { 53 | delete(s.m, key) 54 | } 55 | s.mu.Unlock() 56 | return ok 57 | } 58 | 59 | func (s *SyncSet[T]) ForEach(fn func(key T) bool) { 60 | s.mu.RLock() 61 | for key := range s.m { 62 | if !fn(key) { 63 | break 64 | } 65 | } 66 | s.mu.RUnlock() 67 | } 68 | 69 | func (s *SyncSet[T]) Keys() []T { 70 | s.mu.RLock() 71 | keys := make([]T, 0, len(s.m)) 72 | for key := range s.m { 73 | keys = append(keys, key) 74 | } 75 | s.mu.RUnlock() 76 | return keys 77 | } 78 | 79 | func (s *SyncSet[T]) Len() int { 80 | s.mu.RLock() 81 | c := len(s.m) 82 | s.mu.RUnlock() 83 | return c 84 | } 85 | 86 | func (s *SyncSet[T]) Clone() *SyncSet[T] { 87 | s.mu.RLock() 88 | m := maps.Clone(s.m) 89 | s.mu.RUnlock() 90 | return &SyncSet[T]{m: m} 91 | } 92 | -------------------------------------------------------------------------------- /internal/utils/sync.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package utils 4 | 5 | import ( 6 | "reflect" 7 | "sync" 8 | 9 | "github.com/amarnathcjd/gogram/internal/encoding/tl" 10 | ) 11 | 12 | type SyncIntObjectChan struct { 13 | mutex sync.RWMutex 14 | m map[int]chan tl.Object 15 | } 16 | 17 | func (s *SyncIntObjectChan) Reset() { 18 | s.mutex.Lock() 19 | defer s.mutex.Unlock() 20 | s.m = make(map[int]chan tl.Object) 21 | } 22 | 23 | func NewSyncIntObjectChan() *SyncIntObjectChan { 24 | return &SyncIntObjectChan{m: make(map[int]chan tl.Object)} 25 | } 26 | 27 | func (s *SyncIntObjectChan) Has(key int) bool { 28 | s.mutex.RLock() 29 | _, ok := s.m[key] 30 | s.mutex.RUnlock() 31 | return ok 32 | } 33 | 34 | func (s *SyncIntObjectChan) Get(key int) (chan tl.Object, bool) { 35 | s.mutex.RLock() 36 | defer s.mutex.RUnlock() 37 | v, ok := s.m[key] 38 | return v, ok 39 | } 40 | 41 | func (s *SyncIntObjectChan) Add(key int, value chan tl.Object) { 42 | s.mutex.Lock() 43 | s.m[key] = value 44 | s.mutex.Unlock() 45 | } 46 | 47 | func (s *SyncIntObjectChan) Keys() []int { 48 | keys := make([]int, 0, len(s.m)) 49 | s.mutex.RLock() 50 | defer s.mutex.RUnlock() 51 | for k := range s.m { 52 | keys = append(keys, k) 53 | } 54 | return keys 55 | } 56 | 57 | func (s *SyncIntObjectChan) Delete(key int) bool { 58 | s.mutex.Lock() 59 | _, ok := s.m[key] 60 | delete(s.m, key) 61 | s.mutex.Unlock() 62 | return ok 63 | } 64 | 65 | type SyncIntReflectTypes struct { 66 | mutex sync.RWMutex 67 | m map[int][]reflect.Type 68 | } 69 | 70 | func (s *SyncIntReflectTypes) Reset() { 71 | s.mutex.Lock() 72 | defer s.mutex.Unlock() 73 | s.m = make(map[int][]reflect.Type) 74 | } 75 | 76 | func NewSyncIntReflectTypes() *SyncIntReflectTypes { 77 | return &SyncIntReflectTypes{m: make(map[int][]reflect.Type)} 78 | } 79 | 80 | func (s *SyncIntReflectTypes) Has(key int) bool { 81 | s.mutex.RLock() 82 | _, ok := s.m[key] 83 | s.mutex.RUnlock() 84 | return ok 85 | } 86 | 87 | func (s *SyncIntReflectTypes) Get(key int) ([]reflect.Type, bool) { 88 | s.mutex.RLock() 89 | defer s.mutex.RUnlock() 90 | v, ok := s.m[key] 91 | return v, ok 92 | } 93 | 94 | func (s *SyncIntReflectTypes) Add(key int, value []reflect.Type) { 95 | s.mutex.Lock() 96 | s.m[key] = value 97 | s.mutex.Unlock() 98 | } 99 | 100 | func (s *SyncIntReflectTypes) Keys() []int { 101 | keys := make([]int, 0, len(s.m)) 102 | s.mutex.RLock() 103 | defer s.mutex.RUnlock() 104 | for k := range s.m { 105 | keys = append(keys, k) 106 | } 107 | return keys 108 | } 109 | 110 | func (s *SyncIntReflectTypes) Delete(key int) bool { 111 | s.mutex.Lock() 112 | _, ok := s.m[key] 113 | delete(s.m, key) 114 | s.mutex.Unlock() 115 | return ok 116 | } 117 | 118 | func (s *SyncIntObjectChan) Close() { 119 | s.mutex.Lock() 120 | defer s.mutex.Unlock() 121 | for k, v := range s.m { 122 | CloseChannelWithoutPanic(v) 123 | delete(s.m, k) 124 | } 125 | } 126 | 127 | func CloseChannelWithoutPanic(c chan tl.Object) { 128 | defer func() { 129 | if r := recover(); r != nil { 130 | close(c) 131 | } 132 | }() 133 | } 134 | -------------------------------------------------------------------------------- /internal/utils/utils.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package utils 4 | 5 | import ( 6 | cr "crypto/rand" 7 | "crypto/sha1" 8 | "fmt" 9 | "math/rand" 10 | "os" 11 | "runtime" 12 | "strings" 13 | "sync" 14 | "time" 15 | ) 16 | 17 | // ------------------ Telegram Data Center Configs ------------------ 18 | 19 | var DcList = DCOptions{ 20 | DCS: map[int][]DC{ 21 | 1: {{"149.154.175.58:443", false}}, 22 | 2: {{"149.154.167.50:443", false}}, 23 | 3: {{"149.154.175.100:443", false}}, 24 | 4: {{"149.154.167.91:443", false}, 25 | {"[2001:067c:04e8:f002::a]:443", true}}, // THIS IS DC2 IPv6 26 | 5: {{"91.108.56.151:443", false}}, 27 | }, 28 | TestDCs: map[int]string{ 29 | 1: "149.154.175.10:443", 30 | 2: "149.154.167.40:443", 31 | 3: "149.154.175.117:443", 32 | }, 33 | CdnDCs: map[int][]DC{ 34 | 201: {{"91.108.23.100:443", false}}, 35 | 203: {{"91.105.192.100:443", false}, 36 | {"[2a0a:f280:0203:000a:5000:0000:0000:0100]:443", true}}, 37 | }, 38 | } 39 | 40 | // TODO: Fix DC4 Ipv6 is Unreachable 41 | 42 | type DC struct { 43 | Addr string 44 | V bool 45 | } 46 | 47 | type DCOptions struct { 48 | DCS map[int][]DC 49 | TestDCs map[int]string 50 | CdnDCs map[int][]DC 51 | } 52 | 53 | func SetDCs(dcs map[int][]DC, cdnDcs map[int][]DC) { 54 | for key, newDCs := range dcs { 55 | DcList.DCS[key] = mergeUnique(DcList.DCS[key], newDCs) 56 | } 57 | 58 | for key, newCDNs := range cdnDcs { 59 | DcList.CdnDCs[key] = mergeUnique(DcList.CdnDCs[key], newCDNs) 60 | } 61 | } 62 | 63 | func mergeUnique(existing, new []DC) []DC { 64 | uniqueMap := make(map[DC]struct{}) 65 | 66 | for _, dc := range existing { 67 | uniqueMap[dc] = struct{}{} 68 | } 69 | 70 | for _, dc := range new { 71 | uniqueMap[dc] = struct{}{} 72 | } 73 | 74 | result := make([]DC, 0, len(uniqueMap)) 75 | for dc := range uniqueMap { 76 | result = append(result, dc) 77 | } 78 | 79 | return result 80 | } 81 | 82 | func GetAddr(dc int) (string, bool) { 83 | if addrs, ok := DcList.DCS[dc]; ok { 84 | return addrs[0].Addr, addrs[0].V 85 | } 86 | return "", false 87 | } 88 | 89 | func GetCdnAddr(dc int) (string, bool) { 90 | if addrs, ok := DcList.CdnDCs[dc]; ok { 91 | return addrs[0].Addr, addrs[0].V 92 | } 93 | return "", false 94 | } 95 | 96 | func GetHostIp(dc int, test bool, ipv6 bool) string { 97 | dcMap, ok := DcList.DCS[dc] 98 | if !ok { 99 | return "" 100 | } 101 | 102 | if test { 103 | if addr, ok := DcList.TestDCs[dc]; ok { 104 | return addr 105 | } 106 | } 107 | 108 | if ipv6 { 109 | for _, dc := range dcMap { 110 | if dc.V { 111 | return dc.Addr 112 | } 113 | } 114 | } 115 | 116 | for _, dc := range dcMap { 117 | if !dc.V { 118 | return FmtIp(dc.Addr) 119 | } 120 | } 121 | 122 | return dcMap[0].Addr 123 | } 124 | 125 | func SearchAddr(addr string) int { 126 | for dc, addrs := range DcList.DCS { 127 | for _, a := range addrs { 128 | if a.Addr == addr { 129 | return dc 130 | } 131 | } 132 | } 133 | 134 | if strings.Contains(addr, "91.108.56") { 135 | return 5 136 | } else if strings.Contains(addr, "149.154.175") { 137 | return 1 138 | } else if strings.Contains(addr, "149.154.167") { 139 | return 2 140 | } 141 | return 4 142 | } 143 | 144 | func FmtIp(ipv6WithPort string) string { 145 | if strings.HasPrefix(ipv6WithPort, "[") || strings.Contains(ipv6WithPort, ".") { 146 | return ipv6WithPort 147 | } 148 | 149 | lastColon := strings.LastIndex(ipv6WithPort, ":") 150 | if lastColon == -1 { 151 | return ipv6WithPort 152 | } 153 | 154 | address := ipv6WithPort[:lastColon] 155 | port := ipv6WithPort[lastColon+1:] 156 | 157 | // 2001:0b28:f23f:f005:0000:0000:0000:000a -> [2001:0b28:f23f:f005::a] 158 | // convert 0000:0000:0000:0000:0000:0000:0000:000a -> ::a 159 | address = strings.Replace(address, "0000:0000:0000:000", ":", 1) 160 | // remove preceding zeros 161 | address = strings.Replace(address, ":0", ":", -1) 162 | 163 | return fmt.Sprintf("[%s]:%s", address, port) 164 | } 165 | 166 | func Vtcp(isV6 bool) string { 167 | if isV6 { 168 | return "Tcp6" 169 | } 170 | return "Tcp" 171 | } 172 | 173 | type PingParams struct { 174 | PingID int64 175 | } 176 | 177 | func (*PingParams) CRC() uint32 { 178 | return 0x7abe77ec 179 | } 180 | 181 | type UpdatesGetStateParams struct{} 182 | 183 | func NewMsgIDGenerator() func(timeOffset int64) int64 { 184 | var ( 185 | mu sync.Mutex 186 | lastMsgID int64 187 | ) 188 | return func(timeOffset int64) int64 { 189 | mu.Lock() 190 | defer mu.Unlock() 191 | 192 | now_time := time.Now().Add(time.Duration(timeOffset) * time.Second) 193 | now := now_time.UnixNano() 194 | 195 | nowSec := now / int64(time.Second) 196 | nowNano := (now % int64(time.Second)) & -4 // mod 4 197 | 198 | msgID := (nowSec << 32) | nowNano 199 | if msgID <= lastMsgID { 200 | msgID = lastMsgID + 4 201 | } 202 | 203 | lastMsgID = msgID 204 | return msgID 205 | } 206 | } 207 | 208 | func AuthKeyHash(key []byte) []byte { 209 | return Sha1Byte(key)[12:20] 210 | } 211 | 212 | func GenerateSessionID() int64 { 213 | source := rand.NewSource(time.Now().UnixNano()) 214 | return rand.New(source).Int63() 215 | } 216 | 217 | func FullStack() { 218 | buf := make([]byte, 1024) 219 | for { 220 | n := runtime.Stack(buf, true) 221 | if n < len(buf) { 222 | fmt.Fprintln(os.Stderr, string(buf[:n])) 223 | } 224 | buf = make([]byte, 2*len(buf)) 225 | } 226 | } 227 | 228 | func Sha1Byte(input []byte) []byte { 229 | r := sha1.Sum(input) 230 | return r[:] 231 | } 232 | 233 | func Sha1(input string) []byte { 234 | r := sha1.Sum([]byte(input)) 235 | return r[:] 236 | } 237 | 238 | func RandomBytes(size int) []byte { 239 | b := make([]byte, size) 240 | _, _ = cr.Read(b) 241 | return b 242 | } 243 | 244 | func Xor(dst, src []byte) { 245 | for i := range dst { 246 | dst[i] ^= src[i] 247 | } 248 | } 249 | 250 | func AskForConfirmation() bool { 251 | var response string 252 | _, _ = fmt.Scanln(&response) 253 | return response == "y" || response == "Y" 254 | } 255 | -------------------------------------------------------------------------------- /network.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package gogram 4 | 5 | import ( 6 | "context" 7 | "fmt" 8 | "path/filepath" 9 | "reflect" 10 | "strings" 11 | 12 | "github.com/amarnathcjd/gogram/internal/encoding/tl" 13 | "github.com/amarnathcjd/gogram/internal/mtproto/messages" 14 | "github.com/amarnathcjd/gogram/internal/mtproto/objects" 15 | "github.com/amarnathcjd/gogram/internal/session" 16 | "github.com/amarnathcjd/gogram/internal/utils" 17 | "github.com/pkg/errors" 18 | ) 19 | 20 | func (m *MTProto) sendPacket(request tl.Object, expectedTypes ...reflect.Type) (chan tl.Object, int64, error) { 21 | msg, err := tl.Marshal(request) 22 | if err != nil { 23 | return nil, 0, errors.Wrap(err, "marshaling request") 24 | } 25 | 26 | var ( 27 | data messages.Common 28 | msgID = m.genMsgID(m.timeOffset) 29 | ) 30 | 31 | // adding types for parser if required 32 | if len(expectedTypes) > 0 { 33 | m.expectedTypes.Add(int(msgID), expectedTypes) 34 | } 35 | 36 | // dealing with response channel 37 | resp := m.getRespChannel() 38 | if isNullableResponse(request) { 39 | go func() { resp <- &objects.Null{} }() // goroutine cuz we don't read from it RIGHT NOW 40 | } else { 41 | m.responseChannels.Add(int(msgID), resp) 42 | } 43 | 44 | if m.encrypted { 45 | data = &messages.Encrypted{ 46 | Msg: msg, 47 | MsgID: msgID, 48 | AuthKeyHash: m.authKeyHash, 49 | } 50 | } else { 51 | data = &messages.Unencrypted{ 52 | Msg: msg, 53 | MsgID: msgID, 54 | } 55 | } 56 | 57 | var seqNo int32 58 | if isNotContentRelated(request) { 59 | seqNo = m.GetSeqNo() 60 | } else { 61 | seqNo = m.UpdateSeqNo() 62 | } 63 | 64 | if m.transport == nil || !m.IsTcpActive() { 65 | m.CreateConnection(false) 66 | if m.transport == nil { 67 | return nil, 0, errors.New("transport is nil, please use SetTransport") 68 | } 69 | } 70 | 71 | maxRetries := 2 72 | sendPacket: 73 | errorSendPacket := m.transport.WriteMsg(data, seqNo) 74 | if errorSendPacket != nil { 75 | if maxRetries > 0 && strings.Contains(errorSendPacket.Error(), "connection was aborted") { 76 | maxRetries-- 77 | m.CreateConnection(false) 78 | goto sendPacket 79 | } 80 | return nil, msgID, fmt.Errorf("writing message: %w", errorSendPacket) 81 | } 82 | return resp, msgID, nil 83 | } 84 | 85 | func (m *MTProto) writeRPCResponse(msgID int, data tl.Object) error { 86 | v, ok := m.responseChannels.Get(msgID) 87 | if !ok { 88 | return errors.New("no response channel found for messageId " + fmt.Sprint(msgID)) 89 | } 90 | 91 | if err := safeSend(v, data); err != nil { 92 | return errors.Wrap(err, "sending response") 93 | } 94 | 95 | m.responseChannels.Delete(msgID) 96 | m.expectedTypes.Delete(msgID) 97 | return nil 98 | } 99 | 100 | func safeSend(ch chan tl.Object, obj tl.Object) (err error) { 101 | defer func() { 102 | if r := recover(); r != nil { 103 | err = fmt.Errorf("channel closed: %v", r) 104 | } 105 | }() 106 | 107 | select { 108 | case ch <- obj: 109 | return nil // Successfully sent 110 | default: 111 | return fmt.Errorf("channel is full or closed") 112 | } 113 | } 114 | 115 | func (m *MTProto) getRespChannel() chan tl.Object { 116 | if m.serviceModeActivated { 117 | return m.serviceChannel 118 | } 119 | return make(chan tl.Object) 120 | } 121 | 122 | func isNotContentRelated(t tl.Object) bool { 123 | switch t.(type) { 124 | case *objects.PingParams, 125 | *objects.MsgsAck, 126 | *objects.GzipPacked: 127 | return true 128 | default: 129 | return false 130 | } 131 | } 132 | 133 | func isNullableResponse(t tl.Object) bool { 134 | switch t.(type) { 135 | case *objects.Pong, *objects.MsgsAck: 136 | return true 137 | default: 138 | return false 139 | } 140 | } 141 | 142 | func (m *MTProto) GetSessionID() int64 { 143 | return m.sessionId 144 | } 145 | 146 | // GetSeqNo returns seqno 147 | func (m *MTProto) GetSeqNo() int32 { 148 | return m.currentSeqNo.Load() * 2 149 | } 150 | 151 | func (m *MTProto) UpdateSeqNo() int32 { 152 | // https://core.telegram.org/mtproto/description#message-sequence-number-msg-seqno 153 | return (m.currentSeqNo.Add(1)-1)*2 + 1 154 | } 155 | 156 | // GetServerSalt returns current server salt 157 | func (m *MTProto) GetServerSalt() int64 { 158 | return m.serverSalt 159 | } 160 | 161 | // GetAuthKey returns decryption key of current session salt 🧐 162 | func (m *MTProto) GetAuthKey() []byte { 163 | return m.authKey 164 | } 165 | 166 | func (m *MTProto) SetAuthKey(key []byte) { 167 | m.authKey = key 168 | m.authKeyHash = utils.AuthKeyHash(m.authKey) 169 | } 170 | 171 | func (m *MTProto) MakeRequest(msg tl.Object) (any, error) { 172 | return m.makeRequest(msg) 173 | } 174 | 175 | func (m *MTProto) MakeRequestCtx(ctx context.Context, msg tl.Object) (any, error) { 176 | return m.makeRequestCtx(ctx, msg) 177 | } 178 | 179 | func (m *MTProto) MakeRequestWithHintToDecoder(msg tl.Object, expectedTypes ...reflect.Type) (any, error) { 180 | if len(expectedTypes) == 0 { 181 | return nil, errors.New("expected a few hints. If you don't need it, use m.MakeRequest") 182 | } 183 | return m.makeRequest(msg, expectedTypes...) 184 | } 185 | 186 | func (m *MTProto) AddCustomServerRequestHandler(handler func(i any) bool) { 187 | m.serverRequestHandlers = append(m.serverRequestHandlers, handler) 188 | } 189 | 190 | func (m *MTProto) SaveSession(mem bool) (err error) { 191 | sess := &session.Session{ 192 | Key: m.authKey, 193 | Hash: m.authKeyHash, 194 | Salt: m.serverSalt, 195 | Hostname: m.Addr, 196 | AppID: m.appID, 197 | } 198 | 199 | if !mem { 200 | m.Logger.Debug("saving session to `", filepath.Base(m.sessionStorage.Path()), "`") 201 | return m.sessionStorage.Store(sess) 202 | } 203 | 204 | return nil 205 | } 206 | 207 | func (m *MTProto) DeleteSession() (err error) { 208 | return m.sessionStorage.Delete() 209 | } 210 | 211 | func (m *MTProto) _loadSession(s *session.Session) { 212 | m.authKey = s.Key 213 | m.authKeyHash = s.Hash 214 | m.serverSalt = s.Salt 215 | m.Addr = s.Hostname 216 | m.appID = s.AppID 217 | } 218 | 219 | func (m *MTProto) reqPQ(nonce *tl.Int128) (*objects.ResPQ, error) { 220 | return objects.ReqPQ(m, nonce) 221 | } 222 | 223 | func (m *MTProto) reqPQMulti(nonce *tl.Int128) (*objects.ResPQ, error) { 224 | return objects.ReqPQMulti(m, nonce) 225 | } 226 | 227 | func (m *MTProto) reqDHParams(nonce, serverNonce *tl.Int128, p, q []byte, publicKeyFingerprint int64, encryptedData []byte) (objects.ServerDHParams, error) { 228 | return objects.ReqDHParams(m, nonce, serverNonce, p, q, publicKeyFingerprint, encryptedData) 229 | } 230 | 231 | func (m *MTProto) setClientDHParams(nonce, serverNonce *tl.Int128, encryptedData []byte) (objects.SetClientDHParamsAnswer, error) { 232 | return objects.SetClientDHParams(m, nonce, serverNonce, encryptedData) 233 | } 234 | -------------------------------------------------------------------------------- /schemes/mtproto.tl: -------------------------------------------------------------------------------- 1 | int ? = Int; 2 | long ? = Long; 3 | double ? = Double; 4 | string ? = String; 5 | 6 | vector {t:Type} # [ t ] = Vector t; 7 | 8 | int128 4*[ int ] = Int128; 9 | int256 8*[ int ] = Int256; 10 | 11 | resPQ#05162463 nonce:int128 server_nonce:int128 pq:bytes server_public_key_fingerprints:Vector = ResPQ; 12 | 13 | p_q_inner_data#83c95aec pq:bytes p:bytes q:bytes nonce:int128 server_nonce:int128 new_nonce:int256 = P_Q_inner_data; 14 | 15 | 16 | server_DH_params_fail#79cb045d nonce:int128 server_nonce:int128 new_nonce_hash:int128 = Server_DH_Params; 17 | server_DH_params_ok#d0e8075c nonce:int128 server_nonce:int128 encrypted_answer:bytes = Server_DH_Params; 18 | 19 | server_DH_inner_data#b5890dba nonce:int128 server_nonce:int128 g:int dh_prime:bytes g_a:bytes server_time:int = Server_DH_inner_data; 20 | 21 | client_DH_inner_data#6643b654 nonce:int128 server_nonce:int128 retry_id:long g_b:bytes = Client_DH_Inner_Data; 22 | 23 | dh_gen_ok#3bcbf734 nonce:int128 server_nonce:int128 new_nonce_hash1:int128 = Set_client_DH_params_answer; 24 | dh_gen_retry#46dc1fb9 nonce:int128 server_nonce:int128 new_nonce_hash2:int128 = Set_client_DH_params_answer; 25 | dh_gen_fail#a69dae02 nonce:int128 server_nonce:int128 new_nonce_hash3:int128 = Set_client_DH_params_answer; 26 | 27 | rpc_result#f35c6d01 req_msg_id:long result:Object = RpcResult; 28 | rpc_error#2144ca19 error_code:int error_message:string = RpcError; 29 | 30 | rpc_answer_unknown#5e2ad36e = RpcDropAnswer; 31 | rpc_answer_dropped_running#cd78e586 = RpcDropAnswer; 32 | rpc_answer_dropped#a43ad8b7 msg_id:long seq_no:int bytes:int = RpcDropAnswer; 33 | 34 | future_salt#0949d9dc valid_since:int valid_until:int salt:long = FutureSalt; 35 | future_salts#ae500895 req_msg_id:long now:int salts:vector = FutureSalts; 36 | 37 | pong#347773c5 msg_id:long ping_id:long = Pong; 38 | 39 | destroy_session_ok#e22045fc session_id:long = DestroySessionRes; 40 | destroy_session_none#62d350c9 session_id:long = DestroySessionRes; 41 | 42 | new_session_created#9ec20908 first_msg_id:long unique_id:long server_salt:long = NewSession; 43 | 44 | msg_container#73f1f8dc messages:vector<%Message> = MessageContainer; 45 | message msg_id:long seqno:int bytes:int body:Object = Message; 46 | msg_copy#e06046b2 orig_message:Message = MessageCopy; 47 | 48 | gzip_packed#3072cfa1 packed_data:bytes = Object; 49 | 50 | msgs_ack#62d6b459 msg_ids:Vector = MsgsAck; 51 | 52 | bad_msg_notification#a7eff811 bad_msg_id:long bad_msg_seqno:int error_code:int = BadMsgNotification; 53 | bad_server_salt#edab447b bad_msg_id:long bad_msg_seqno:int error_code:int new_server_salt:long = BadMsgNotification; 54 | 55 | msg_resend_req#7d861a08 msg_ids:Vector = MsgResendReq; 56 | msgs_state_req#da69fb52 msg_ids:Vector = MsgsStateReq; 57 | msgs_state_info#04deb57d req_msg_id:long info:bytes = MsgsStateInfo; 58 | msgs_all_info#8cc0d131 msg_ids:Vector info:bytes = MsgsAllInfo; 59 | msg_detailed_info#276d3ec6 msg_id:long answer_msg_id:long bytes:int status:int = MsgDetailedInfo; 60 | msg_new_detailed_info#809db6df answer_msg_id:long bytes:int status:int = MsgDetailedInfo; 61 | 62 | ---functions--- 63 | 64 | req_pq#60469778 nonce:int128 = ResPQ; 65 | 66 | req_DH_params#d712e4be nonce:int128 server_nonce:int128 p:bytes q:bytes public_key_fingerprint:long encrypted_data:bytes = Server_DH_Params; 67 | 68 | set_client_DH_params#f5045f1f nonce:int128 server_nonce:int128 encrypted_data:bytes = Set_client_DH_params_answer; 69 | 70 | rpc_drop_answer#58e4a740 req_msg_id:long = RpcDropAnswer; 71 | get_future_salts#b921bd04 num:int = FutureSalts; 72 | ping#7abe77ec ping_id:long = Pong; 73 | ping_delay_disconnect#f3427b8c ping_id:long disconnect_delay:int = Pong; 74 | destroy_session#e7512126 session_id:long = DestroySessionRes; 75 | 76 | http_wait#9299359f max_delay:int wait_after:int max_wait:int = HttpWait; 77 | -------------------------------------------------------------------------------- /telegram/const.go: -------------------------------------------------------------------------------- 1 | package telegram 2 | 3 | import ( 4 | "regexp" 5 | 6 | "github.com/amarnathcjd/gogram/internal/utils" 7 | ) 8 | 9 | const ( 10 | ApiVersion = 204 11 | Version = "v1.5.8" 12 | 13 | LogDebug = utils.DebugLevel 14 | LogInfo = utils.InfoLevel 15 | LogWarn = utils.WarnLevel 16 | LogError = utils.ErrorLevel 17 | LogTrace = utils.TraceLevel 18 | LogDisable = utils.NoLevel 19 | 20 | ModeAbridged = "modeAbridged" 21 | ModeFull = "modeFull" 22 | ModeIntermediate = "modeIntermediate" 23 | 24 | MarkDown string = "Markdown" 25 | HTML string = "HTML" 26 | 27 | EntityUser string = "user" 28 | EntityChat string = "chat" 29 | EntityChannel string = "channel" 30 | EntityUnknown string = "unknown" 31 | 32 | OnNewMessage = "OnNewMessage" 33 | OnEditMessage = "OnEditMessage" 34 | OnChatAction = "OnChatAction" 35 | OnInlineQuery = "OnInlineQuery" 36 | OnCallbackQuery = "OnCallbackQuery" 37 | OnInlineCallbackQuery = "OnInlineCallbackQuery" 38 | OnChosenInlineResult = "OnChosenInlineResult" 39 | OnDeleteMessage = "OnDeleteMessage" 40 | ) 41 | 42 | const ( 43 | randombyteLen = 256 44 | OneTimeMedia = 2147483647 45 | ) 46 | 47 | var ( 48 | USERNAME_RE = regexp.MustCompile(`(?i)(?:@|(?:https?:\/\/)?(?:www\.)?(?:telegram\.(?:me|dog)|t\.me)\/)([\w\d_]+)`) 49 | TG_JOIN_RE = regexp.MustCompile(`^(?:https?://)?(?:www\.)?t(?:elegram)?\.(?:org|me|dog)/(?:joinchat/|\+)([\w-]+)$`) 50 | ) 51 | 52 | var ( 53 | Actions = map[string]SendMessageAction{ 54 | "typing": &SendMessageTypingAction{}, 55 | "upload_photo": &SendMessageUploadPhotoAction{}, 56 | "record_video": &SendMessageRecordVideoAction{}, 57 | "upload_video": &SendMessageUploadVideoAction{}, 58 | "record_audio": &SendMessageRecordAudioAction{}, 59 | "upload_audio": &SendMessageUploadAudioAction{}, 60 | "upload_document": &SendMessageUploadDocumentAction{}, 61 | "game": &SendMessageGamePlayAction{}, 62 | "cancel": &SendMessageCancelAction{}, 63 | "round_video": &SendMessageUploadRoundAction{}, 64 | "call": &SpeakingInGroupCallAction{}, 65 | "record_round": &SendMessageRecordRoundAction{}, 66 | "history_import": &SendMessageHistoryImportAction{}, 67 | "geo": &SendMessageGeoLocationAction{}, 68 | "choose_contact": &SendMessageChooseContactAction{}, 69 | "choose_sticker": &SendMessageChooseStickerAction{}, 70 | "emoji": &SendMessageEmojiInteraction{}, 71 | "emoji_seen": &SendMessageEmojiInteractionSeen{}, 72 | } 73 | ) 74 | -------------------------------------------------------------------------------- /telegram/methods_special.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package telegram 4 | 5 | import ( 6 | "github.com/pkg/errors" 7 | 8 | "github.com/amarnathcjd/gogram/internal/encoding/tl" 9 | ) 10 | 11 | //invokeAfterMsg#cb9f372d {X:Type} msg_id:long query:!X = X; 12 | //invokeAfterMsgs#3dc4b4f0 {X:Type} msg_ids:Vector query:!X = X; 13 | 14 | type InitConnectionParams struct { 15 | ApiID int32 // Application identifier (see. App configuration) 16 | DeviceModel string // Device model 17 | SystemVersion string // Operation system version 18 | AppVersion string // Application version 19 | SystemLangCode string // Code for the language used on the device's OS, ISO 639-1 standard 20 | LangPack string // Language pack to use 21 | LangCode string // Code for the language used on the client, ISO 639-1 standard 22 | Proxy *InputClientProxy `tl:"flag:0"` // Info about an MTProto proxy 23 | Params JsonValue `tl:"flag:1"` // Additional initConnection parameters. For now, only the tz_offset field is supported, for specifying timezone offset in seconds. 24 | Query tl.Object // The query itself 25 | } 26 | 27 | func (*InitConnectionParams) CRC() uint32 { 28 | return 0xc1cd5ea9 29 | } 30 | 31 | func (*InitConnectionParams) FlagIndex() int { 32 | return 0 33 | } 34 | 35 | func (c *Client) InitConnection(params *InitConnectionParams) (tl.Object, error) { 36 | data, err := c.MakeRequest(params) 37 | if err != nil { 38 | return nil, errors.Wrap(err, "sending InitConnection") 39 | } 40 | 41 | return data.(tl.Object), nil 42 | } 43 | 44 | type InvokeWithLayerParams struct { 45 | Layer int32 46 | Query tl.Object 47 | } 48 | 49 | func (*InvokeWithLayerParams) CRC() uint32 { 50 | return 0xda9b0d0d 51 | } 52 | 53 | func (m *Client) InvokeWithLayer(layer int, query tl.Object) (tl.Object, error) { 54 | data, err := m.MakeRequest(&InvokeWithLayerParams{ 55 | Layer: int32(layer), 56 | Query: query, 57 | }) 58 | if err != nil { 59 | return nil, errors.Wrap(err, "sending InvokeWithLayer") 60 | } 61 | 62 | return data.(tl.Object), nil 63 | } 64 | 65 | //invokeWithoutUpdates#bf9459b7 {X:Type} query:!X = X; 66 | //invokeWithMessagesRange#365275f2 {X:Type} range:MessageRange query:!X = X; 67 | 68 | type InvokeWithTakeoutParams struct { 69 | TakeoutID int64 70 | Query tl.Object 71 | } 72 | 73 | func (*InvokeWithTakeoutParams) CRC() uint32 { 74 | return 0xda9b0d0d 75 | } 76 | 77 | func (m *Client) InvokeWithTakeout(takeoutID int, query tl.Object) (tl.Object, error) { 78 | data, err := m.MakeRequest(&InvokeWithTakeoutParams{ 79 | TakeoutID: int64(takeoutID), 80 | Query: query, 81 | }) 82 | if err != nil { 83 | return nil, errors.Wrap(err, "sending InvokeWithLayer") 84 | } 85 | 86 | return data.(tl.Object), nil 87 | } 88 | -------------------------------------------------------------------------------- /telegram/participant.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package telegram 4 | 5 | import "errors" 6 | 7 | type ParticipantUpdate struct { 8 | Client *Client 9 | OriginalUpdate *UpdateChannelParticipant 10 | Channel *Channel 11 | User *UserObj 12 | Actor *UserObj 13 | Old ChannelParticipant 14 | New ChannelParticipant 15 | Invite ExportedChatInvite 16 | Date int32 17 | } 18 | 19 | func (pu *ParticipantUpdate) ChannelID() int64 { 20 | if pu.Channel != nil { 21 | return pu.Channel.ID 22 | } 23 | return 0 24 | } 25 | 26 | func (pu *ParticipantUpdate) UserID() int64 { 27 | if pu.User != nil { 28 | return pu.User.ID 29 | } 30 | return 0 31 | } 32 | 33 | func (pu *ParticipantUpdate) ActorID() int64 { 34 | if pu.Actor != nil { 35 | return pu.Actor.ID 36 | } 37 | return 0 38 | } 39 | 40 | func (pu *ParticipantUpdate) IsAdded() bool { 41 | if pu.ActorID() != 0 && pu.UserID() != 0 { 42 | if pu.ActorID() == pu.UserID() { 43 | return false 44 | } 45 | } 46 | 47 | if pu.Old != nil && pu.New != nil { 48 | if _, ok := pu.Old.(*ChannelParticipantBanned); ok { 49 | if _, ok := pu.New.(*ChannelParticipantObj); ok { 50 | return true 51 | } 52 | } 53 | if _, ok := pu.Old.(*ChannelParticipantLeft); ok { 54 | if _, ok := pu.New.(*ChannelParticipantObj); ok { 55 | return true 56 | } 57 | } 58 | } else if pu.Old == nil && pu.New != nil { 59 | if _, ok := pu.New.(*ChannelParticipantObj); ok { 60 | return true 61 | } else if _, ok := pu.New.(*ChannelParticipantAdmin); ok { 62 | return true 63 | } 64 | } 65 | return false 66 | } 67 | 68 | func (pu *ParticipantUpdate) IsLeft() bool { 69 | return pu.New == nil 70 | } 71 | 72 | func (pu *ParticipantUpdate) IsJoined() bool { 73 | if pu.ActorID() != 0 && pu.UserID() != 0 { 74 | if pu.ActorID() != pu.UserID() { 75 | return false 76 | } 77 | } 78 | 79 | if pu.Old != nil && pu.New != nil { 80 | if _, ok := pu.Old.(*ChannelParticipantLeft); ok { 81 | if _, ok := pu.New.(*ChannelParticipantObj); ok { 82 | return true 83 | } 84 | } 85 | if _, ok := pu.Old.(*ChannelParticipantBanned); ok { 86 | if _, ok := pu.New.(*ChannelParticipantObj); ok { 87 | return true 88 | } 89 | } 90 | } else if pu.Old == nil && pu.New != nil { 91 | if _, ok := pu.New.(*ChannelParticipantObj); ok { 92 | return true 93 | } 94 | } 95 | return false 96 | } 97 | 98 | func (pu *ParticipantUpdate) IsBanned() bool { 99 | if pu.Old != nil && pu.New != nil { 100 | if _, ok := pu.Old.(*ChannelParticipantObj); ok { 101 | if _, ok := pu.New.(*ChannelParticipantBanned); ok { 102 | return true 103 | } 104 | } 105 | } 106 | return false 107 | } 108 | 109 | func (pu *ParticipantUpdate) IsKicked() bool { 110 | if pu.Old != nil && pu.New != nil { 111 | if _, ok := pu.Old.(*ChannelParticipantObj); ok { 112 | if _, ok := pu.New.(*ChannelParticipantLeft); ok { 113 | return true 114 | } 115 | } 116 | } 117 | return false 118 | } 119 | 120 | func (pu *ParticipantUpdate) IsPromoted() bool { 121 | if pu.Old != nil && pu.New != nil { 122 | if _, ok := pu.Old.(*ChannelParticipantObj); ok { 123 | if _, ok := pu.New.(*ChannelParticipantAdmin); ok { 124 | return true 125 | } 126 | } 127 | if _, ok := pu.Old.(*ChannelParticipantBanned); ok { 128 | if _, ok := pu.New.(*ChannelParticipantAdmin); ok { 129 | return true 130 | } 131 | } 132 | } 133 | return false 134 | } 135 | 136 | func (pu *ParticipantUpdate) IsDemoted() bool { 137 | if pu.Old != nil && pu.New != nil { 138 | if _, ok := pu.Old.(*ChannelParticipantAdmin); ok { 139 | if _, ok := pu.New.(*ChannelParticipantObj); ok { 140 | return true 141 | } 142 | if _, ok := pu.New.(*ChannelParticipantBanned); ok { 143 | return true 144 | } 145 | } 146 | } 147 | return false 148 | } 149 | 150 | func (pu *ParticipantUpdate) Marshal(nointent ...bool) string { 151 | return pu.Client.JSON(pu.OriginalUpdate, nointent) 152 | } 153 | 154 | func (pu *ParticipantUpdate) Ban() (bool, error) { 155 | if pu.User == nil { 156 | return false, errors.New("ParticipantUpdate.Ban: User is nil") 157 | } 158 | 159 | if pu.Channel == nil { 160 | return false, errors.New("ParticipantUpdate.Ban: Channel is nil") 161 | } 162 | 163 | _, err := pu.Client.EditBanned(pu.Channel, pu.User, &BannedOptions{ 164 | Ban: true, 165 | }) 166 | 167 | return err == nil, err 168 | } 169 | 170 | func (pu *ParticipantUpdate) Unban() (bool, error) { 171 | if pu.User == nil { 172 | return false, errors.New("ParticipantUpdate.Unban: User is nil") 173 | } 174 | 175 | if pu.Channel == nil { 176 | return false, errors.New("ParticipantUpdate.Unban: Channel is nil") 177 | } 178 | 179 | _, err := pu.Client.EditBanned(pu.Channel, pu.User, &BannedOptions{ 180 | Unban: true, 181 | }) 182 | 183 | return err == nil, err 184 | } 185 | 186 | func (pu *ParticipantUpdate) Kick() (bool, error) { 187 | if pu.User == nil { 188 | return false, errors.New("ParticipantUpdate.Kick: User is nil") 189 | } 190 | 191 | if pu.Channel == nil { 192 | return false, errors.New("ParticipantUpdate.Kick: Channel is nil") 193 | } 194 | 195 | _, err := pu.Client.KickParticipant(pu.Channel, pu.User) 196 | return err == nil, err 197 | } 198 | 199 | func (pu *ParticipantUpdate) Promote() (bool, error) { 200 | if pu.User == nil { 201 | return false, errors.New("ParticipantUpdate.Promote: User is nil") 202 | } 203 | 204 | if pu.Channel == nil { 205 | return false, errors.New("ParticipantUpdate.Promote: Channel is nil") 206 | } 207 | 208 | _, err := pu.Client.EditAdmin(pu.Channel, pu.User, &AdminOptions{ 209 | IsAdmin: true, 210 | }) 211 | 212 | return err == nil, err 213 | } 214 | 215 | func (pu *ParticipantUpdate) Demote() (bool, error) { 216 | if pu.User == nil { 217 | return false, errors.New("ParticipantUpdate.Demote: User is nil") 218 | } 219 | 220 | if pu.Channel == nil { 221 | return false, errors.New("ParticipantUpdate.Demote: Channel is nil") 222 | } 223 | 224 | _, err := pu.Client.EditAdmin(pu.Channel, pu.User, &AdminOptions{ 225 | IsAdmin: false, 226 | }) 227 | 228 | return err == nil, err 229 | } 230 | -------------------------------------------------------------------------------- /telegram/tgcalls.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2024 RoseLoverX 2 | 3 | package telegram 4 | 5 | import "fmt" 6 | 7 | func (c *Client) StartGroupCallMedia(peer any) (PhoneCall, error) { 8 | peerDialog, err := c.ResolvePeer(peer) 9 | if err != nil { 10 | return nil, err 11 | } 12 | // Start the group call 13 | updates, e := c.PhoneCreateGroupCall(&PhoneCreateGroupCallParams{ 14 | Peer: peerDialog, 15 | RandomID: int32(GenRandInt()), 16 | }) 17 | if e != nil { 18 | return nil, e 19 | } 20 | 21 | switch updates.(type) { 22 | case *UpdatesObj: 23 | for _, update := range updates.(*UpdatesObj).Updates { 24 | switch update := update.(type) { 25 | case *UpdatePhoneCall: 26 | return update.PhoneCall, nil 27 | } 28 | } 29 | } 30 | 31 | return nil, fmt.Errorf("StartGroupCallMedia: failed to start group call") 32 | } 33 | 34 | func (c *Client) GetGroupCall(chatId any) (*InputGroupCall, error) { 35 | resolvedPeer, err := c.ResolvePeer(chatId) 36 | if err != nil { 37 | return nil, err 38 | } 39 | 40 | if inPeer, ok := resolvedPeer.(*InputPeerChannel); !ok { 41 | return nil, fmt.Errorf("GetGroupCall: chatId is not a channel") 42 | } else { 43 | fullChatRaw, err := c.ChannelsGetFullChannel( 44 | &InputChannelObj{ 45 | ChannelID: inPeer.ChannelID, 46 | AccessHash: inPeer.AccessHash, 47 | }, 48 | ) 49 | 50 | if err != nil { 51 | return nil, err 52 | } 53 | 54 | if fullChatRaw == nil { 55 | return nil, fmt.Errorf("GetGroupCall: fullChatRaw is nil") 56 | } 57 | 58 | fullChat, ok := fullChatRaw.FullChat.(*ChannelFull) 59 | 60 | if !ok { 61 | return nil, fmt.Errorf("GetGroupCall: fullChatRaw.FullChat is not a ChannelFull") 62 | } 63 | 64 | if fullChat.Call == nil { 65 | return nil, fmt.Errorf("GetGroupCall: No active group call") 66 | } 67 | 68 | return &fullChat.Call, nil 69 | } 70 | } 71 | 72 | type GroupCallStream struct { 73 | Channels []*GroupCallStreamChannel 74 | call *InputGroupCall 75 | currentTs int64 76 | selectedChannel int32 77 | scale int32 78 | client *Client 79 | dcId int32 80 | } 81 | 82 | func (s *GroupCallStream) SetTS(ts int64) { 83 | s.currentTs = ts 84 | } 85 | 86 | func (s *GroupCallStream) GetTS() int64 { 87 | return s.currentTs 88 | } 89 | 90 | func (s *GroupCallStream) GetScale() int32 { 91 | return s.scale 92 | } 93 | 94 | func (s *GroupCallStream) SetScale(scale int32) { 95 | s.scale = scale 96 | } 97 | 98 | func (s *GroupCallStream) GetChannel() *GroupCallStreamChannel { 99 | if s.selectedChannel < 0 || s.selectedChannel >= int32(len(s.Channels)) { 100 | return nil 101 | } 102 | return s.Channels[s.selectedChannel] 103 | } 104 | 105 | func (s *GroupCallStream) SetChannel(channel int32) { 106 | if channel < 0 || channel >= int32(len(s.Channels)) { 107 | return 108 | } 109 | s.selectedChannel = channel 110 | s.scale = s.Channels[channel].Scale 111 | s.currentTs = s.Channels[channel].LastTimestampMs 112 | } 113 | 114 | func (s *GroupCallStream) NextChunk() ([]byte, error) { 115 | if s.selectedChannel < 0 || s.selectedChannel >= int32(len(s.Channels)) { 116 | return nil, fmt.Errorf("GetGroupCallStream: selected channel is out of range") 117 | } 118 | 119 | channel := s.GetChannel() 120 | if channel == nil { 121 | return nil, fmt.Errorf("GetGroupCallStream: channel is nil") 122 | } 123 | 124 | input := &InputGroupCallStream{ 125 | Call: *s.call, 126 | TimeMs: s.currentTs, 127 | Scale: s.scale, 128 | VideoChannel: channel.Channel, 129 | VideoQuality: 2, 130 | } 131 | 132 | fi, err := s.client.UploadGetFile(&UploadGetFileParams{ 133 | Location: input, 134 | Offset: 0, 135 | Limit: 512 * 1024, 136 | }) 137 | 138 | if err != nil { 139 | fmt.Printf("GetGroupCallStream: UploadGetFile error: %v\n", err) 140 | return nil, err 141 | } 142 | 143 | if fi == nil { 144 | return nil, fmt.Errorf("GetGroupCallStream: file info is nil") 145 | } 146 | 147 | switch fi := fi.(type) { 148 | case *UploadFileObj: 149 | s.currentTs += 1000 >> s.scale 150 | return fi.Bytes, nil 151 | case *UploadFileCdnRedirect: 152 | return nil, fmt.Errorf("GetGroupCallStream: CDN redirect error") 153 | } 154 | 155 | return nil, fmt.Errorf("GetGroupCallStream: unknown file info type") 156 | } 157 | 158 | func (c *Client) GetGroupCallStream(chatId any) (*GroupCallStream, error) { 159 | call, err := c.GetGroupCall(chatId) 160 | if err != nil { 161 | return nil, err 162 | } 163 | 164 | stream, err := c.PhoneGetGroupCallStreamChannels(*call) 165 | if err != nil { 166 | return nil, err 167 | } 168 | 169 | return &GroupCallStream{ 170 | Channels: stream.Channels, 171 | scale: stream.Channels[0].Scale, 172 | call: call, 173 | client: c, 174 | dcId: int32(c.GetDC()), 175 | }, nil 176 | } 177 | --------------------------------------------------------------------------------