Add initial files
This commit is contained in:
parent
a733e15eb0
commit
c0b0301cb4
3 changed files with 658 additions and 0 deletions
507
bot.go
Normal file
507
bot.go
Normal file
|
|
@ -0,0 +1,507 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"fmt"
|
||||
"log"
|
||||
"math"
|
||||
"net/http"
|
||||
"os"
|
||||
"regexp"
|
||||
"strings"
|
||||
|
||||
"github.com/gotd/td/session"
|
||||
"github.com/gotd/td/telegram"
|
||||
"github.com/gotd/td/telegram/auth"
|
||||
"github.com/gotd/td/telegram/updates"
|
||||
"github.com/gotd/td/tg"
|
||||
"golang.org/x/term"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
type YAMLScamPattern struct {
|
||||
Name string `yaml:"name"`
|
||||
Pattern string `yaml:"pattern"`
|
||||
Weight float64 `yaml:"weight"`
|
||||
}
|
||||
|
||||
type Config struct {
|
||||
APIId int `yaml:"api_id"`
|
||||
APIHash string `yaml:"api_hash"`
|
||||
MonitoredChat int64 `yaml:"monitored_chat"`
|
||||
AlertChat int64 `yaml:"alert_chat"`
|
||||
NtfyToken string `yaml:"ntfy_token"`
|
||||
NtfyTopic string `yaml:"ntfy_topic"`
|
||||
SessionPath string `yaml:"session_path"`
|
||||
YAMLPatterns []YAMLScamPattern `yaml:"scam_patterns"`
|
||||
Patterns []scamPattern `yaml:"-"` // Compiled patterns, not from YAML
|
||||
}
|
||||
|
||||
func loadConfig(path string) (*Config, error) {
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
if os.IsNotExist(err) {
|
||||
// Create default config file
|
||||
defaultConfig := `api_id: 0
|
||||
api_hash: ""
|
||||
monitored_chat: 0
|
||||
alert_chat: 0
|
||||
ntfy_token: ""
|
||||
ntfy_topic: ""
|
||||
session_path: "antiscam.session"
|
||||
scam_patterns: []
|
||||
`
|
||||
if err := os.WriteFile(path, []byte(defaultConfig), 0644); err != nil {
|
||||
return nil, fmt.Errorf("creating default config file: %w", err)
|
||||
}
|
||||
log.Printf("Created default config file at %s. Please fill in the required values.", path)
|
||||
data = []byte(defaultConfig)
|
||||
} else {
|
||||
return nil, fmt.Errorf("reading config file: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
var cfg Config
|
||||
if err := yaml.Unmarshal(data, &cfg); err != nil {
|
||||
return nil, fmt.Errorf("parsing config: %w", err)
|
||||
}
|
||||
|
||||
// Validate required fields
|
||||
if cfg.APIId == 0 {
|
||||
return nil, fmt.Errorf("api_id is not set in config")
|
||||
}
|
||||
if cfg.APIHash == "" {
|
||||
return nil, fmt.Errorf("api_hash is not set in config")
|
||||
}
|
||||
if cfg.MonitoredChat == 0 {
|
||||
return nil, fmt.Errorf("monitored_chat is not set in config")
|
||||
}
|
||||
if cfg.SessionPath == "" {
|
||||
return nil, fmt.Errorf("session_path is not set in config")
|
||||
}
|
||||
|
||||
// Compile patterns from YAML
|
||||
if len(cfg.YAMLPatterns) > 0 {
|
||||
cfg.Patterns = make([]scamPattern, len(cfg.YAMLPatterns))
|
||||
for i, p := range cfg.YAMLPatterns {
|
||||
re, err := regexp.Compile(p.Pattern)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("compiling pattern %q: %w", p.Name, err)
|
||||
}
|
||||
cfg.Patterns[i] = scamPattern{
|
||||
name: p.Name,
|
||||
re: re,
|
||||
weight: p.Weight,
|
||||
}
|
||||
}
|
||||
log.Printf("✓ Loaded %d scam patterns from YAML config:", len(cfg.Patterns))
|
||||
for _, p := range cfg.Patterns {
|
||||
log.Printf(" - %s (%s) (weight: %.1f)", p.name, p.re, p.weight)
|
||||
}
|
||||
}
|
||||
|
||||
return &cfg, nil
|
||||
}
|
||||
|
||||
type scamPattern struct {
|
||||
name string
|
||||
re *regexp.Regexp
|
||||
weight float64
|
||||
}
|
||||
|
||||
type matchResult struct {
|
||||
score float64
|
||||
matchedKeywords map[string][]string
|
||||
}
|
||||
|
||||
var scamPatterns = []scamPattern{
|
||||
{
|
||||
name: "seeking",
|
||||
re: regexp.MustCompile(`(?i)(?:(?:several\s+people|seeking|looking\s+for)\s+(?:partner|(\d+\s*[-–]\s*\d+|\d+)|two)?)|(new\s+project)`),
|
||||
weight: 0.5,
|
||||
},
|
||||
{
|
||||
name: "job_opportunity",
|
||||
re: regexp.MustCompile(`(?i)(?:remote|earning|in\s+a)\s+(?:collaboration|growing\s+field|opportunity|work)`),
|
||||
weight: 0.4,
|
||||
},
|
||||
{
|
||||
name: "money",
|
||||
re: regexp.MustCompile(`(?i)(?:\d+[\s,]*(?:\$|€|₹|£)|(?:\$|€|₹|£)\s*\d+,?\d+)(\s+per\s+(week|day))?`),
|
||||
weight: 0.6,
|
||||
},
|
||||
{
|
||||
name: "contact",
|
||||
re: regexp.MustCompile(`(?i)(?:\bdm\b|(send|write).*(?:private)?\s+.?\+.?|get\s+in\s+touch)|@\w+`),
|
||||
weight: 0.5,
|
||||
},
|
||||
{
|
||||
name: "links",
|
||||
re: regexp.MustCompile(`https://t\.me/\+\S+|https://t\.me/[a-z0-9_]+`),
|
||||
weight: 0.5,
|
||||
},
|
||||
{
|
||||
name: "call_to_action",
|
||||
re: regexp.MustCompile(`(?i)[⬇👇👆⬆💬🪂🎯⤵⤴📍]+|(?:click|tap|join|link|check)\s+(?:here|now|below|out)`),
|
||||
weight: 0.5,
|
||||
},
|
||||
{
|
||||
name: "extended_latin",
|
||||
re: regexp.MustCompile(`(?i)[äöüß]+`),
|
||||
weight: 0.2,
|
||||
},
|
||||
}
|
||||
|
||||
func keywordMatchScore(input string, patterns []scamPattern) matchResult {
|
||||
matched := make(map[string][]string)
|
||||
totalScore := 0.0
|
||||
|
||||
for _, p := range patterns {
|
||||
var matches []string
|
||||
for _, m := range p.re.FindAllString(input, -1) {
|
||||
m = strings.TrimSpace(m)
|
||||
if m != "" {
|
||||
matches = append(matches, m)
|
||||
}
|
||||
}
|
||||
if len(matches) > 0 {
|
||||
matched[p.name] = matches
|
||||
totalScore += p.weight
|
||||
}
|
||||
}
|
||||
|
||||
score := math.Min(totalScore, 1.0)
|
||||
// Round to 2 decimal places
|
||||
score = math.Round(score*100) / 100
|
||||
|
||||
return matchResult{score: score, matchedKeywords: matched}
|
||||
}
|
||||
|
||||
func escapeMarkdown(text string) string {
|
||||
escapeChars := `\_*[]()~` + "`" + `>#+-=|{}.!`
|
||||
var result strings.Builder
|
||||
for _, r := range text {
|
||||
if strings.ContainsRune(escapeChars, r) {
|
||||
result.WriteRune('\\')
|
||||
}
|
||||
result.WriteRune(r)
|
||||
}
|
||||
return result.String()
|
||||
}
|
||||
|
||||
func notify(message, topic, title string, priority int, token string) {
|
||||
url := "https://ntfy.zio.sh/" + topic
|
||||
req, err := http.NewRequest("POST", url, bytes.NewBufferString(message))
|
||||
if err != nil {
|
||||
log.Printf("notify: creating request: %v", err)
|
||||
return
|
||||
}
|
||||
if title != "" {
|
||||
req.Header.Set("Title", title)
|
||||
}
|
||||
req.Header.Set("Priority", fmt.Sprintf("%d", priority))
|
||||
req.Header.Set("Markdown", "yes")
|
||||
if token != "" {
|
||||
// ntfy uses basic auth with empty username and token as password
|
||||
encoded := base64.StdEncoding.EncodeToString([]byte(":" + token))
|
||||
req.Header.Set("Authorization", "Basic "+encoded)
|
||||
}
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
log.Printf("notify: sending request: %v", err)
|
||||
return
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
}
|
||||
|
||||
func resolveAlertPeer(ctx context.Context, api *tg.Client, cfg *Config) (*tg.InputPeerChannel, error) {
|
||||
result, err := api.MessagesGetDialogs(ctx, &tg.MessagesGetDialogsRequest{
|
||||
OffsetPeer: &tg.InputPeerEmpty{},
|
||||
Limit: 100,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var chats []tg.ChatClass
|
||||
|
||||
switch v := result.(type) {
|
||||
case *tg.MessagesDialogs:
|
||||
chats = v.Chats
|
||||
case *tg.MessagesDialogsSlice:
|
||||
chats = v.Chats
|
||||
case *tg.MessagesDialogsNotModified:
|
||||
return nil, fmt.Errorf("dialogs not modified")
|
||||
default:
|
||||
return nil, fmt.Errorf("unexpected dialogs type: %T", result)
|
||||
}
|
||||
|
||||
for _, chat := range chats {
|
||||
if channel, ok := chat.(*tg.Channel); ok {
|
||||
if channel.ID == cfg.AlertChat {
|
||||
return &tg.InputPeerChannel{
|
||||
ChannelID: channel.ID,
|
||||
AccessHash: channel.AccessHash,
|
||||
}, nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("alert channel %d not found", cfg.AlertChat)
|
||||
}
|
||||
|
||||
func handleNewMessage(ctx context.Context, api *tg.Client, alertPeer *tg.InputPeerChannel, cfg *Config, entities tg.Entities, update any) error {
|
||||
// Extract message from either UpdateNewMessage or UpdateNewChannelMessage
|
||||
var msg *tg.Message
|
||||
switch u := update.(type) {
|
||||
case *tg.UpdateNewMessage:
|
||||
m, ok := u.Message.(*tg.Message)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
msg = m
|
||||
case *tg.UpdateNewChannelMessage:
|
||||
m, ok := u.Message.(*tg.Message)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
msg = m
|
||||
default:
|
||||
log.Printf("DEBUG: unknown update type %T", update)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Only process messages sent by the bot (Out=true)
|
||||
if msg.Out {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Check if from monitored supergroup (channels in gotd terminology)
|
||||
peerChannel, ok := msg.PeerID.(*tg.PeerChannel)
|
||||
if !ok || int64(peerChannel.ChannelID) != cfg.MonitoredChat {
|
||||
return nil
|
||||
}
|
||||
log.Printf("✓ Processing message in chat %v: %s", msg.PeerID, msg.Message)
|
||||
chatID := int64(peerChannel.ChannelID)
|
||||
|
||||
// Use YAML patterns if available, otherwise use defaults
|
||||
patterns := cfg.Patterns
|
||||
if len(patterns) == 0 {
|
||||
patterns = scamPatterns
|
||||
log.Printf("Using hardcoded scam patterns (%d patterns)", len(patterns))
|
||||
} else {
|
||||
log.Printf("Using YAML-loaded scam patterns (%d patterns)", len(patterns))
|
||||
}
|
||||
|
||||
// Score the message
|
||||
result := keywordMatchScore(msg.Message, patterns)
|
||||
|
||||
if extended_latin, ok := result.matchedKeywords["extended_latin"]; ok {
|
||||
for range extended_latin {
|
||||
result.score += 0.1
|
||||
if result.score >= 1.0 {
|
||||
result.score = 1.0
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if result.score < 1.0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
log.Printf("Matched message with score %.2f", result.score)
|
||||
for key, values := range result.matchedKeywords {
|
||||
for _, value := range values {
|
||||
log.Printf(" %s: %s", key, value)
|
||||
}
|
||||
}
|
||||
|
||||
// Delete the message from supergroup
|
||||
channel, ok := entities.Channels[chatID]
|
||||
if !ok {
|
||||
return fmt.Errorf("channel %d not found in entities", chatID)
|
||||
}
|
||||
_, err := api.ChannelsDeleteMessages(ctx, &tg.ChannelsDeleteMessagesRequest{
|
||||
Channel: &tg.InputChannel{
|
||||
ChannelID: chatID,
|
||||
AccessHash: channel.AccessHash,
|
||||
},
|
||||
ID: []int{msg.ID},
|
||||
})
|
||||
if err != nil {
|
||||
log.Printf("Failed to delete message: %v", err)
|
||||
}
|
||||
|
||||
// Get sender info
|
||||
var senderID int64
|
||||
if fromID, ok := msg.FromID.(*tg.PeerUser); ok {
|
||||
senderID = int64(fromID.UserID)
|
||||
} else {
|
||||
return fmt.Errorf("could not determine sender")
|
||||
}
|
||||
|
||||
user, ok := entities.Users[senderID]
|
||||
if !ok {
|
||||
return fmt.Errorf("user %d not found in entities", senderID)
|
||||
}
|
||||
|
||||
displayName := user.FirstName
|
||||
if user.LastName != "" {
|
||||
displayName += " " + user.LastName
|
||||
}
|
||||
displayName = strings.TrimSpace(displayName)
|
||||
|
||||
username := "no username"
|
||||
if user.Username != "" {
|
||||
username = "@" + user.Username
|
||||
}
|
||||
|
||||
// Restrict sender in supergroup
|
||||
_, err = api.ChannelsEditBanned(ctx, &tg.ChannelsEditBannedRequest{
|
||||
Channel: &tg.InputChannel{
|
||||
ChannelID: chatID,
|
||||
AccessHash: channel.AccessHash,
|
||||
},
|
||||
Participant: &tg.InputPeerUser{
|
||||
UserID: senderID,
|
||||
AccessHash: user.AccessHash,
|
||||
},
|
||||
BannedRights: tg.ChatBannedRights{
|
||||
SendMessages: true,
|
||||
SendMedia: true,
|
||||
SendStickers: true,
|
||||
SendGifs: true,
|
||||
UntilDate: 0,
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
log.Printf("Failed to restrict user %d: %v", senderID, err)
|
||||
}
|
||||
|
||||
// Get supergroup name
|
||||
chatName := channel.Title
|
||||
|
||||
// Build and send alert message
|
||||
matchMessage := fmt.Sprintf("🚨 Matched\n**Score**: %.2f\n**Chat**: %s (ID: %d)\n**User**: %s (%s) (ID: %d)\n",
|
||||
result.score, escapeMarkdown(chatName), chatID, escapeMarkdown(displayName+" ("+username+")"), username, senderID)
|
||||
|
||||
// Send ntfy notification if config set
|
||||
if cfg.NtfyToken != "" || cfg.NtfyTopic != "" {
|
||||
notify(matchMessage, cfg.NtfyTopic, fmt.Sprintf("Scam Alert: %s", chatName), 5, cfg.NtfyToken)
|
||||
}
|
||||
|
||||
// Send alert message to alert chat
|
||||
_, err = api.MessagesSendMessage(ctx, &tg.MessagesSendMessageRequest{
|
||||
Peer: alertPeer,
|
||||
Message: matchMessage,
|
||||
})
|
||||
if err != nil {
|
||||
log.Printf("Failed to send alert message: %v", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func main() {
|
||||
ctx := context.Background()
|
||||
|
||||
// Load configuration
|
||||
configPath := "config.yaml"
|
||||
if len(os.Args) > 1 {
|
||||
configPath = os.Args[1]
|
||||
}
|
||||
|
||||
cfg, err := loadConfig(configPath)
|
||||
if err != nil {
|
||||
log.Fatalf("Failed to load config: %v", err)
|
||||
}
|
||||
|
||||
dispatcher := tg.NewUpdateDispatcher()
|
||||
gapManager := updates.New(updates.Config{Handler: dispatcher})
|
||||
|
||||
client := telegram.NewClient(cfg.APIId, cfg.APIHash, telegram.Options{
|
||||
UpdateHandler: gapManager,
|
||||
SessionStorage: &session.FileStorage{Path: cfg.SessionPath},
|
||||
})
|
||||
|
||||
err = client.Run(ctx, func(ctx context.Context) error {
|
||||
// Check if session exists; if not, authenticate
|
||||
_, err := os.Stat(cfg.SessionPath)
|
||||
if err != nil {
|
||||
// Session doesn't exist, prompt for credentials
|
||||
fmt.Print("Enter phone number: ")
|
||||
var phone string
|
||||
fmt.Scanln(&phone)
|
||||
|
||||
fmt.Print("Enter 2FA password: ")
|
||||
pwBytes, err := term.ReadPassword(0)
|
||||
if err != nil {
|
||||
return fmt.Errorf("reading password: %w", err)
|
||||
}
|
||||
fmt.Println()
|
||||
password := string(pwBytes)
|
||||
|
||||
flow := auth.NewFlow(
|
||||
auth.Constant(
|
||||
phone,
|
||||
password,
|
||||
auth.CodeAuthenticatorFunc(func(ctx context.Context, sentCode *tg.AuthSentCode) (string, error) {
|
||||
fmt.Print("Enter code: ")
|
||||
var code string
|
||||
fmt.Scanln(&code)
|
||||
return code, nil
|
||||
}),
|
||||
),
|
||||
auth.SendCodeOptions{},
|
||||
)
|
||||
|
||||
if err := client.Auth().IfNecessary(ctx, flow); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
api := client.API()
|
||||
|
||||
// Resolve alert channel peer at startup
|
||||
alertPeer, err := resolveAlertPeer(ctx, api, cfg)
|
||||
if err != nil {
|
||||
return fmt.Errorf("resolving alert peer: %w", err)
|
||||
}
|
||||
|
||||
// Register message handler for private/group messages
|
||||
dispatcher.OnNewMessage(func(ctx context.Context, entities tg.Entities, update *tg.UpdateNewMessage) error {
|
||||
return handleNewMessage(ctx, api, alertPeer, cfg, entities, update)
|
||||
})
|
||||
|
||||
// Register handler for channel messages (supergroups)
|
||||
dispatcher.OnNewChannelMessage(func(ctx context.Context, entities tg.Entities, update *tg.UpdateNewChannelMessage) error {
|
||||
return handleNewMessage(ctx, api, alertPeer, cfg, entities, update)
|
||||
})
|
||||
|
||||
// Get self ID for updates manager
|
||||
status, err := client.Auth().Status(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
user := status.User
|
||||
username := ""
|
||||
if user.Username != "" {
|
||||
username = " (@" + user.Username + ")"
|
||||
}
|
||||
displayName := user.FirstName
|
||||
if user.LastName != "" {
|
||||
displayName += " " + user.LastName
|
||||
}
|
||||
log.Printf("✓ Logged in as: %s%s (ID: %d)", displayName, username, user.ID)
|
||||
log.Printf("✓ Bot running, monitoring chat %d", cfg.MonitoredChat)
|
||||
return gapManager.Run(ctx, api, status.User.ID, updates.AuthOptions{})
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue