// Package web serves telesrv's read-only public link landing pages.
package web
import (
"context"
"errors"
"fmt"
"html/template"
"net"
"net/http"
"net/url"
"strconv"
"strings"
"time"
"unicode/utf8"
"go.uber.org/zap"
"telesrv/internal/domain"
"telesrv/internal/links"
)
type Config struct {
Addr string
PublicBaseURL string
AppScheme string
WebBaseURL string
AppName string
StickerSets StickerSetResolver
Users UsernameResolver
Channels PublicChannelResolver
Privacy AnonymousPrivacyResolver
Photos ProfilePhotoResolver
UniqueGifts UniqueStarGiftResolver
GiftWithdrawals StarGiftWithdrawalResolver
// TelegramLogin is the optional OIDC/Login HTTP adapter. Public Web owns
// the listener so discovery/auth/token and public links share the exact
// externally registered origin behind one reverse proxy.
TelegramLogin http.Handler
}
type StickerSetResolver interface {
ResolveStickerSet(ctx context.Context, ref domain.StickerSetRef) (domain.StickerSet, []domain.Document, bool, error)
}
type UsernameResolver interface {
ByUsername(ctx context.Context, username string) (domain.User, bool, error)
}
// PublicChannelResolver exposes only the viewer-independent public username
// projection. viewerUserID is always zero for this anonymous Web endpoint.
type PublicChannelResolver interface {
ResolvePublicChannelUsername(ctx context.Context, viewerUserID int64, username string) (domain.Channel, bool, error)
}
type AnonymousPrivacyResolver interface {
CanSeeAnonymous(ctx context.Context, ownerUserID int64, key domain.PrivacyKey) (bool, error)
}
type ProfilePhotoResolver interface {
CurrentProfilePhotoKind(ctx context.Context, ownerType domain.PeerType, ownerID int64, kind domain.ProfilePhotoKind) (domain.Photo, bool, error)
GetPhoto(ctx context.Context, id int64) (domain.Photo, bool, error)
GetFile(ctx context.Context, req domain.FileDownloadRequest) (domain.FileChunk, bool, error)
}
type UniqueStarGiftResolver interface {
UniqueBySlug(ctx context.Context, slug string) (domain.UniqueStarGift, bool, error)
}
type StarGiftWithdrawalResolver interface {
ResolveWithdrawal(ctx context.Context, providerRequestID string) (domain.StarGiftWithdrawal, bool, error)
CompleteWithdrawal(ctx context.Context, providerRequestID string, date int) (domain.StarGiftWithdrawal, error)
}
func Start(ctx context.Context, cfg Config, logger *zap.Logger) (*http.Server, error) {
addr := strings.TrimSpace(cfg.Addr)
if addr == "" {
return nil, nil
}
if logger == nil {
logger = zap.NewNop()
}
handler, err := newHandler(cfg, logger)
if err != nil {
return nil, err
}
srv := &http.Server{
Addr: addr,
Handler: handler,
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 10 * time.Second,
WriteTimeout: 15 * time.Second,
IdleTimeout: 60 * time.Second,
MaxHeaderBytes: 16 << 10,
}
ln, err := net.Listen("tcp", addr)
if err != nil {
return nil, err
}
go func() {
logger.Info("Public link Web endpoint enabled",
zap.String("addr", addr),
zap.String("public_base_url", cfg.PublicBaseURL),
zap.String("app_scheme", cfg.AppScheme),
zap.String("web_base_url", cfg.WebBaseURL))
if err := srv.Serve(ln); err != nil && !errors.Is(err, http.ErrServerClosed) {
logger.Warn("Public link Web endpoint exited", zap.Error(err))
}
}()
go func() {
<-ctx.Done()
shutdownCtx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
_ = srv.Shutdown(shutdownCtx)
}()
return srv, nil
}
func NewHandler(cfg Config) (http.Handler, error) {
return newHandler(cfg, zap.NewNop())
}
func newHandler(cfg Config, logger *zap.Logger) (http.Handler, error) {
var err error
if cfg.StickerSets == nil {
return nil, fmt.Errorf("public Web sticker set resolver is nil")
}
if strings.TrimSpace(cfg.WebBaseURL) == "" {
cfg.WebBaseURL = links.DefaultWebBaseURL
}
if strings.TrimSpace(cfg.AppName) == "" {
cfg.AppName = links.DefaultAppName
}
if cfg.PublicBaseURL, err = links.ValidateBaseURL(cfg.PublicBaseURL); err != nil {
return nil, fmt.Errorf("public base URL: %w", err)
}
if cfg.AppScheme, err = links.ValidateAppScheme(cfg.AppScheme); err != nil {
return nil, fmt.Errorf("app scheme: %w", err)
}
if cfg.WebBaseURL, err = links.ValidateBaseURL(cfg.WebBaseURL); err != nil {
return nil, fmt.Errorf("Web base URL: %w", err)
}
if cfg.AppName, err = links.ValidateAppName(cfg.AppName); err != nil {
return nil, fmt.Errorf("app name: %w", err)
}
if logger == nil {
logger = zap.NewNop()
}
h := &handler{
stickerSets: cfg.StickerSets,
users: cfg.Users,
channels: cfg.Channels,
privacy: cfg.Privacy,
photos: cfg.Photos,
uniqueGifts: cfg.UniqueGifts,
giftWithdrawals: cfg.GiftWithdrawals,
publicBaseURL: cfg.PublicBaseURL,
appScheme: cfg.AppScheme,
webBaseURL: cfg.WebBaseURL,
appName: cfg.AppName,
logger: logger,
}
mux := http.NewServeMux()
mux.HandleFunc("GET /healthz", h.healthz)
mux.HandleFunc("GET /_public/avatar/{username}/{photoID}", h.publicAvatar)
mux.HandleFunc("GET /addstickers/{shortName}", h.addStickers)
mux.HandleFunc("GET /addemoji/{shortName}", h.addEmoji)
mux.HandleFunc("GET /addlist/{slug}", h.addList)
mux.HandleFunc("GET /nft/{slug}", h.uniqueGift)
mux.HandleFunc("GET /nft/{slug}/{$}", h.uniqueGift)
mux.HandleFunc("GET /gift-withdrawal/{requestID}", h.starGiftWithdrawal)
mux.HandleFunc("POST /gift-withdrawal/{requestID}", h.completeStarGiftWithdrawal)
if cfg.TelegramLogin != nil {
mux.Handle("GET /.well-known/openid-configuration", cfg.TelegramLogin)
mux.Handle("GET /.well-known/jwks.json", cfg.TelegramLogin)
mux.Handle("GET /auth", cfg.TelegramLogin)
mux.Handle("GET /crossapp", cfg.TelegramLogin)
mux.Handle("GET /inapp", cfg.TelegramLogin)
mux.Handle("POST /auth/status", cfg.TelegramLogin)
mux.Handle("POST /token", cfg.TelegramLogin)
mux.Handle("GET /telegram-login.js", cfg.TelegramLogin)
mux.Handle("GET /js/telegram-login.js", cfg.TelegramLogin)
}
mux.HandleFunc("GET /{username}", h.usernameLink)
mux.HandleFunc("GET /{username}/{$}", h.usernameLink)
return publicSecurityHeaders(mux), nil
}
type handler struct {
stickerSets StickerSetResolver
users UsernameResolver
channels PublicChannelResolver
privacy AnonymousPrivacyResolver
photos ProfilePhotoResolver
uniqueGifts UniqueStarGiftResolver
giftWithdrawals StarGiftWithdrawalResolver
publicBaseURL string
appScheme string
webBaseURL string
appName string
logger *zap.Logger
}
type starGiftWithdrawalPage struct {
AppName string
Title string
Slug string
Status string
OwnerAddress string
GiftAddress string
ExpiresAt string
CanComplete bool
}
var starGiftWithdrawalTemplate = template.Must(template.New("star-gift-withdrawal").Parse(`
{{.Title}} · {{.AppName}}{{.Title}}
Collectible: {{.Slug}}
{{if .CanComplete}}This export is handled only by {{.AppName}}'s internal ledger. No external blockchain or wallet is contacted.
Expires: {{.ExpiresAt}}
{{else}}Status: {{.Status}}
{{if .OwnerAddress}}Owner address: {{.OwnerAddress}}
Gift address: {{.GiftAddress}}
{{end}}{{end}}
`))
func (h *handler) starGiftWithdrawal(w http.ResponseWriter, r *http.Request) {
h.renderStarGiftWithdrawal(w, r, false)
}
func (h *handler) completeStarGiftWithdrawal(w http.ResponseWriter, r *http.Request) {
h.renderStarGiftWithdrawal(w, r, true)
}
func (h *handler) renderStarGiftWithdrawal(w http.ResponseWriter, r *http.Request, complete bool) {
requestID := strings.TrimSpace(r.PathValue("requestID"))
if h.giftWithdrawals == nil || requestID == "" || len(requestID) > 256 {
http.NotFound(w, r)
return
}
var withdrawal domain.StarGiftWithdrawal
var found bool
var err error
if complete {
withdrawal, err = h.giftWithdrawals.CompleteWithdrawal(r.Context(), requestID, int(time.Now().Unix()))
found = err == nil
} else {
withdrawal, found, err = h.giftWithdrawals.ResolveWithdrawal(r.Context(), requestID)
}
if err != nil || !found {
http.NotFound(w, r)
return
}
page := starGiftWithdrawalPage{AppName: h.appName, Title: withdrawal.Gift.Title, Slug: withdrawal.Gift.Slug,
Status: withdrawal.Status, OwnerAddress: withdrawal.Gift.OwnerAddress, GiftAddress: withdrawal.Gift.GiftAddress,
ExpiresAt: time.Unix(int64(withdrawal.ExpiresAt), 0).UTC().Format(time.RFC3339),
CanComplete: withdrawal.Status == "pending" && withdrawal.ExpiresAt > int(time.Now().Unix())}
if page.Title == "" {
page.Title = "Collectible gift export"
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
if err := starGiftWithdrawalTemplate.Execute(w, page); err != nil {
h.logger.Warn("render star gift withdrawal", zap.Error(err))
}
}
func (h *handler) healthz(w http.ResponseWriter, _ *http.Request) {
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
_, _ = w.Write([]byte("ok\n"))
}
func (h *handler) addStickers(w http.ResponseWriter, r *http.Request) {
h.serveSet(w, r, "addstickers")
}
func (h *handler) addEmoji(w http.ResponseWriter, r *http.Request) {
h.serveSet(w, r, "addemoji")
}
func (h *handler) addList(w http.ResponseWriter, r *http.Request) {
slug := strings.TrimSpace(r.PathValue("slug"))
if !validSlugPath(slug) {
http.NotFound(w, r)
return
}
app := h.appURL("addlist", "slug", slug)
data := pageData{
AppName: h.appName,
Title: "Shared Folder",
KindLabel: "shared folder",
Subtitle: slug,
Description: "This page opens the app so you can preview and add this shared folder.",
CanonicalURL: h.publicURL("addlist", slug),
AppURL: template.URL(app),
LegacyTgURL: template.URL(legacyTgURL("addlist", "slug", slug)),
}
data.AppURLJS = template.JS(strconv.Quote(app))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Header().Set("Cache-Control", "public, max-age=60")
if err := landingTemplate.Execute(w, data); err != nil {
http.Error(w, "render shared folder page failed", http.StatusInternalServerError)
}
}
func (h *handler) uniqueGift(w http.ResponseWriter, r *http.Request) {
slug := r.PathValue("slug")
if h.uniqueGifts == nil || !validStarGiftSlugPath(slug) {
http.NotFound(w, r)
return
}
unique, found, err := h.uniqueGifts.UniqueBySlug(r.Context(), slug)
if err != nil {
h.logger.Error("Public unique star gift lookup failed", zap.String("slug", slug), zap.Error(err))
http.Error(w, "collectible gift lookup failed", http.StatusInternalServerError)
return
}
if !found {
http.NotFound(w, r)
return
}
canonicalSlug := unique.Slug
if unique.ID <= 0 || unique.GiftID <= 0 || unique.Num <= 0 ||
!validStarGiftSlugPath(canonicalSlug) || !strings.EqualFold(slug, canonicalSlug) ||
!utf8.ValidString(unique.Title) || utf8.RuneCountInString(unique.Title) > domain.MaxStarGiftTitleRunes {
h.logger.Error("Public unique star gift resolver returned invalid aggregate",
zap.String("requested_slug", slug), zap.String("resolved_slug", canonicalSlug),
zap.Int64("unique_id", unique.ID), zap.Int64("gift_id", unique.GiftID), zap.Int("num", unique.Num))
http.Error(w, "collectible gift lookup failed", http.StatusInternalServerError)
return
}
if slug != canonicalSlug || strings.HasSuffix(r.URL.Path, "/") {
http.Redirect(w, r, h.publicURL("nft", canonicalSlug), http.StatusPermanentRedirect)
return
}
title := strings.TrimSpace(unique.Title)
if title == "" {
title = "Collectible gift"
}
subtitle := fmt.Sprintf("Collectible #%d", unique.Num)
if unique.AvailabilityIssued > 0 && unique.AvailabilityTotal >= unique.AvailabilityIssued {
subtitle += fmt.Sprintf(" · %s/%s issued", groupedDecimal(unique.AvailabilityIssued), groupedDecimal(unique.AvailabilityTotal))
}
app := h.appURL("nft", "slug", canonicalSlug)
data := pageData{
AppName: h.appName,
Title: title,
KindLabel: "collectible gift",
Subtitle: subtitle,
Description: "This collectible was created from a gift on " + h.appName + ". Open it in the app to view its current details.",
CanonicalURL: h.publicURL("nft", canonicalSlug),
AppURL: template.URL(app),
LegacyTgURL: template.URL(legacyTgURL("nft", "slug", canonicalSlug)),
}
data.AppURLJS = template.JS(strconv.Quote(app))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Header().Set("Cache-Control", "public, max-age=60, must-revalidate")
if err := landingTemplate.Execute(w, data); err != nil {
h.logger.Error("Render public unique star gift page failed", zap.String("slug", canonicalSlug), zap.Error(err))
}
}
func (h *handler) usernameLink(w http.ResponseWriter, r *http.Request) {
username := strings.TrimSpace(r.PathValue("username"))
if !validUsernamePath(username) {
h.serveUsernameNotFound(w, username)
return
}
params, ok := publicResolveQuery(r.URL.RawQuery)
if !ok {
http.Error(w, "public link query is too large or invalid", http.StatusRequestURITooLong)
return
}
peer, found, err := h.resolvePublicPeer(r.Context(), username)
if err != nil {
h.logger.Error("Public username lookup failed", zap.String("username", username), zap.Error(err))
http.Error(w, "username lookup failed", http.StatusInternalServerError)
return
}
if !found {
h.serveUsernameNotFound(w, username)
return
}
params.Set("domain", peer.username)
app := schemeURLValues(h.appScheme, "resolve", params)
legacy := schemeURLValues("tg", "resolve", params)
description := peer.about
if description == "" {
description = peer.fallbackDescription(h.appName)
}
data := usernamePageData{
AppName: h.appName,
AppInitial: appInitial(h.appName),
Title: peer.title,
Username: peer.username,
Verified: peer.verified,
Extra: peer.extra(),
Description: description,
CanonicalURL: h.publicUsernameURL(peer.username),
HomeURL: h.publicBaseURL + "/",
AppURL: template.URL(app),
LegacyTgURL: template.URL(legacy),
WebURL: template.URL(publicWebAppURL(h.webBaseURL, legacy)),
ButtonLabel: peer.buttonLabel(),
Initials: peer.initials(),
}
if peer.hasPhoto {
data.PhotoURL = h.publicAvatarURL(peer.username, peer.photo.ID)
}
data.AppURLJS = template.JS(strconv.Quote(app))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Header().Set("Cache-Control", "public, max-age=60, must-revalidate")
if err := usernameLandingTemplate.Execute(w, data); err != nil {
h.logger.Error("Render public username page failed", zap.String("username", peer.username), zap.Error(err))
}
}
const maxPublicAvatarBytes = 4 << 20
func (h *handler) publicAvatar(w http.ResponseWriter, r *http.Request) {
username := strings.TrimSpace(r.PathValue("username"))
photoID, err := strconv.ParseInt(r.PathValue("photoID"), 10, 64)
if err != nil || photoID <= 0 || !validUsernamePath(username) || h.photos == nil {
http.NotFound(w, r)
return
}
peer, found, err := h.resolvePublicPeer(r.Context(), username)
if err != nil {
h.logger.Error("Public avatar peer lookup failed", zap.String("username", username), zap.Error(err))
http.Error(w, "avatar lookup failed", http.StatusInternalServerError)
return
}
if !found || !peer.hasPhoto || peer.photo.ID != photoID {
http.NotFound(w, r)
return
}
size, inline, ok := bestPublicPhotoSize(peer.photo.Sizes)
if !ok {
http.NotFound(w, r)
return
}
etag := fmt.Sprintf("\"public-avatar-%d-%s-%d\"", peer.photo.ID, size.Type, size.Size)
w.Header().Set("ETag", etag)
w.Header().Set("Cache-Control", "public, max-age=300, must-revalidate")
if r.Header.Get("If-None-Match") == etag {
w.WriteHeader(http.StatusNotModified)
return
}
data := inline
mimeType := ""
if len(data) == 0 {
chunk, found, err := h.photos.GetFile(r.Context(), domain.FileDownloadRequest{
LocationKey: fmt.Sprintf("photo:%d:%s", peer.photo.ID, size.Type),
Limit: maxPublicAvatarBytes + 1,
})
if err != nil {
h.logger.Error("Read public avatar blob failed", zap.String("username", username), zap.Int64("photo_id", photoID), zap.Error(err))
http.Error(w, "avatar read failed", http.StatusInternalServerError)
return
}
if !found || chunk.Total <= 0 || chunk.Total > maxPublicAvatarBytes || int64(len(chunk.Bytes)) != chunk.Total {
h.logger.Warn("Public avatar blob is missing or outside bounds", zap.String("username", username), zap.Int64("photo_id", photoID), zap.Int64("total", chunk.Total), zap.Int("bytes", len(chunk.Bytes)))
http.NotFound(w, r)
return
}
data = chunk.Bytes
mimeType = chunk.MimeType
}
if len(data) == 0 || len(data) > maxPublicAvatarBytes {
http.NotFound(w, r)
return
}
detected := http.DetectContentType(data)
if !safePublicImageType(detected) {
h.logger.Warn("Public avatar blob is not a safe raster image", zap.String("username", username), zap.Int64("photo_id", photoID), zap.String("detected_type", detected), zap.String("stored_type", mimeType))
http.NotFound(w, r)
return
}
w.Header().Set("Content-Type", detected)
w.Header().Set("Content-Length", strconv.Itoa(len(data)))
if peer.photo.Date > 0 {
w.Header().Set("Last-Modified", time.Unix(int64(peer.photo.Date), 0).UTC().Format(http.TimeFormat))
}
w.WriteHeader(http.StatusOK)
_, _ = w.Write(data)
}
func (h *handler) serveSet(w http.ResponseWriter, r *http.Request, pathKind string) {
shortName := strings.TrimSpace(r.PathValue("shortName"))
if !validShortNamePath(shortName) {
http.NotFound(w, r)
return
}
set, docs, found, err := h.stickerSets.ResolveStickerSet(r.Context(), domain.StickerSetRef{
Kind: domain.StickerSetRefByShortName,
ShortName: shortName,
})
if err != nil {
http.Error(w, "sticker set lookup failed", http.StatusInternalServerError)
return
}
if !found || set.Deleted {
http.NotFound(w, r)
return
}
canonicalKind := linkKind(set)
if canonicalKind != pathKind {
http.Redirect(w, r, h.publicURL(canonicalKind, set.ShortName), http.StatusPermanentRedirect)
return
}
count := set.Count
if count == 0 {
count = len(docs)
}
app := h.appURL(canonicalKind, "set", set.ShortName)
data := pageData{
AppName: h.appName,
Title: fallbackTitle(set),
KindLabel: kindLabel(set),
Subtitle: fmt.Sprintf("@%s · %d %s", set.ShortName, count, itemNoun(set, count)),
Description: "This page opens the app so you can preview and install the set. Files are still fetched by the app through MTProto.",
CanonicalURL: h.publicURL(canonicalKind, set.ShortName),
AppURL: template.URL(app),
LegacyTgURL: template.URL(legacyTgURL(canonicalKind, "set", set.ShortName)),
}
data.AppURLJS = template.JS(strconv.Quote(app))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Header().Set("Cache-Control", "public, max-age=60")
if err := landingTemplate.Execute(w, data); err != nil {
http.Error(w, "render sticker set page failed", http.StatusInternalServerError)
}
}
func (h *handler) publicURL(kind, value string) string {
return h.publicBaseURL + "/" + kind + "/" + url.PathEscape(value)
}
func (h *handler) publicUsernameURL(username string) string {
return h.publicBaseURL + "/" + url.PathEscape(username)
}
func (h *handler) publicAvatarURL(username string, photoID int64) string {
return h.publicBaseURL + "/_public/avatar/" + url.PathEscape(username) + "/" + strconv.FormatInt(photoID, 10)
}
type publicPeerKind string
const (
publicPeerUser publicPeerKind = "user"
publicPeerBot publicPeerKind = "bot"
publicPeerChannel publicPeerKind = "channel"
publicPeerSupergroup publicPeerKind = "supergroup"
)
type publicPeer struct {
kind publicPeerKind
username string
title string
about string
verified bool
memberCount int
photo domain.Photo
hasPhoto bool
}
func (h *handler) resolvePublicPeer(ctx context.Context, username string) (publicPeer, bool, error) {
var (
u domain.User
userOK bool
ch domain.Channel
chOK bool
err error
)
if h.users != nil {
u, userOK, err = h.users.ByUsername(ctx, username)
if err != nil {
return publicPeer{}, false, err
}
}
if h.channels != nil {
ch, chOK, err = h.channels.ResolvePublicChannelUsername(ctx, 0, username)
if err != nil {
return publicPeer{}, false, err
}
}
if userOK && chOK {
return publicPeer{}, false, fmt.Errorf("public username %q has multiple owners", username)
}
if userOK {
return h.publicUserPeer(ctx, username, u)
}
if chOK {
return h.publicChannelPeer(ctx, username, ch)
}
return publicPeer{}, false, nil
}
func (h *handler) publicUserPeer(ctx context.Context, requested string, u domain.User) (publicPeer, bool, error) {
if u.ID == 0 || !strings.EqualFold(strings.TrimSpace(u.Username), requested) || !validUsernamePath(u.Username) {
return publicPeer{}, false, fmt.Errorf("user username lookup returned invalid owner for %q", requested)
}
title := strings.TrimSpace(u.FirstName + " " + u.LastName)
if title == "" {
title = u.Username
}
if err := validatePublicPeerText(title, u.About); err != nil {
return publicPeer{}, false, fmt.Errorf("invalid public user %q: %w", u.Username, err)
}
about := strings.TrimSpace(u.About)
photoKind := domain.ProfilePhotoKindProfile
if !u.Bot && h.privacy != nil {
visible, err := h.privacy.CanSeeAnonymous(ctx, u.ID, domain.PrivacyKeyAbout)
if err != nil {
return publicPeer{}, false, fmt.Errorf("evaluate public about privacy: %w", err)
}
if !visible {
about = ""
}
visible, err = h.privacy.CanSeeAnonymous(ctx, u.ID, domain.PrivacyKeyProfilePhoto)
if err != nil {
return publicPeer{}, false, fmt.Errorf("evaluate public profile photo privacy: %w", err)
}
if !visible {
photoKind = domain.ProfilePhotoKindFallback
}
}
peer := publicPeer{
kind: publicPeerUser,
username: u.Username,
title: title,
about: about,
verified: u.Verified,
}
if u.Bot {
peer.kind = publicPeerBot
}
if h.photos != nil {
photo, found, err := h.photos.CurrentProfilePhotoKind(ctx, domain.PeerTypeUser, u.ID, photoKind)
if err != nil {
return publicPeer{}, false, fmt.Errorf("load public user photo: %w", err)
}
if found && photo.ID != 0 {
if _, _, renderable := bestPublicPhotoSize(photo.Sizes); renderable {
peer.photo, peer.hasPhoto = photo, true
}
}
}
return peer, true, nil
}
func (h *handler) publicChannelPeer(ctx context.Context, requested string, ch domain.Channel) (publicPeer, bool, error) {
if ch.ID == 0 || ch.Deleted || ch.ParticipantsCount < 0 || (!ch.Broadcast && !ch.Megagroup) || !strings.EqualFold(strings.TrimSpace(ch.Username), requested) || !validUsernamePath(ch.Username) {
return publicPeer{}, false, fmt.Errorf("channel username lookup returned invalid owner for %q", requested)
}
if err := validatePublicPeerText(ch.Title, ch.About); err != nil {
return publicPeer{}, false, fmt.Errorf("invalid public channel %q: %w", ch.Username, err)
}
peer := publicPeer{
kind: publicPeerChannel,
username: ch.Username,
title: strings.TrimSpace(ch.Title),
about: strings.TrimSpace(ch.About),
verified: ch.Verified,
memberCount: ch.ParticipantsCount,
}
if ch.Megagroup {
peer.kind = publicPeerSupergroup
}
if h.photos != nil && ch.PhotoID != 0 {
photo, found, err := h.photos.GetPhoto(ctx, ch.PhotoID)
if err != nil {
return publicPeer{}, false, fmt.Errorf("load public channel photo: %w", err)
}
if !found {
return publicPeer{}, false, fmt.Errorf("channel %q current photo %d is missing", ch.Username, ch.PhotoID)
}
if photo.ID == ch.PhotoID {
if _, _, renderable := bestPublicPhotoSize(photo.Sizes); renderable {
peer.photo, peer.hasPhoto = photo, true
}
} else {
return publicPeer{}, false, fmt.Errorf("channel %q photo lookup returned id %d, want %d", ch.Username, photo.ID, ch.PhotoID)
}
}
return peer, true, nil
}
func validatePublicPeerText(title, about string) error {
if strings.TrimSpace(title) == "" || utf8.RuneCountInString(title) > 256 {
return fmt.Errorf("title is empty or too long")
}
if utf8.RuneCountInString(about) > 4096 {
return fmt.Errorf("about is too long")
}
return nil
}
func (p publicPeer) buttonLabel() string {
switch p.kind {
case publicPeerBot:
return "Start Bot"
case publicPeerChannel:
return "View Channel"
case publicPeerSupergroup:
return "View Group"
default:
return "Send Message"
}
}
func (p publicPeer) extra() string {
switch p.kind {
case publicPeerBot:
return "bot"
case publicPeerChannel:
return groupedDecimal(p.memberCount) + " " + plural(p.memberCount, "subscriber", "subscribers")
case publicPeerSupergroup:
return groupedDecimal(p.memberCount) + " " + plural(p.memberCount, "member", "members")
default:
return ""
}
}
func (p publicPeer) fallbackDescription(appName string) string {
switch p.kind {
case publicPeerBot:
return "Open " + appName + " to start a chat with this bot."
case publicPeerChannel:
return "Open " + appName + " to view and join this channel."
case publicPeerSupergroup:
return "Open " + appName + " to view and join this group."
default:
return "Open " + appName + " to send a message to @" + p.username + "."
}
}
func (p publicPeer) initials() string {
words := strings.Fields(p.title)
if len(words) == 0 {
words = []string{p.username}
}
first := []rune(words[0])
if len(first) == 0 {
return "T"
}
out := []rune{first[0]}
if len(words) > 1 {
last := []rune(words[len(words)-1])
if len(last) > 0 {
out = append(out, last[0])
}
}
return strings.ToUpper(string(out))
}
func groupedDecimal(n int) string {
if n < 0 {
n = 0
}
s := strconv.Itoa(n)
for i := len(s) - 3; i > 0; i -= 3 {
s = s[:i] + " " + s[i:]
}
return s
}
func plural(n int, one, many string) string {
if n == 1 {
return one
}
return many
}
func appInitial(name string) string {
for _, r := range name {
return strings.ToUpper(string(r))
}
return "T"
}
const (
maxPublicLinkRawQuery = 2048
maxPublicLinkParams = 16
maxPublicLinkValues = 2
maxPublicLinkValueLen = 512
)
func publicResolveQuery(raw string) (url.Values, bool) {
if len(raw) > maxPublicLinkRawQuery {
return nil, false
}
values, err := url.ParseQuery(raw)
if err != nil || len(values) > maxPublicLinkParams {
return nil, false
}
out := make(url.Values, len(values)+1)
for key, items := range values {
if strings.EqualFold(key, "domain") {
continue
}
if !validPublicQueryKey(key) || len(items) > maxPublicLinkValues {
return nil, false
}
for _, value := range items {
if len(value) > maxPublicLinkValueLen || !utf8.ValidString(value) {
return nil, false
}
out.Add(key, value)
}
}
return out, true
}
func validPublicQueryKey(key string) bool {
if key == "" || len(key) > 32 {
return false
}
for _, r := range key {
if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '_' {
continue
}
return false
}
return true
}
func bestPublicPhotoSize(sizes []domain.PhotoSize) (domain.PhotoSize, []byte, bool) {
var (
best domain.PhotoSize
bestBytes []byte
bestScore int64 = -1
)
for _, size := range sizes {
if !validPhotoSizeType(size.Type) {
continue
}
var inline []byte
switch size.Kind {
case domain.PhotoSizeKindCached:
if len(size.Bytes) == 0 || len(size.Bytes) > maxPublicAvatarBytes {
continue
}
inline = size.Bytes
case domain.PhotoSizeKindDefault, domain.PhotoSizeKindProgressive:
// Downloadable static raster size.
default:
continue
}
score := int64(size.W) * int64(size.H)
if score <= 0 {
score = int64(size.Size)
}
if score > bestScore {
best, bestBytes, bestScore = size, inline, score
}
}
return best, bestBytes, bestScore >= 0
}
func validPhotoSizeType(value string) bool {
if value == "" || len(value) > 8 {
return false
}
for _, r := range value {
if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '_' {
continue
}
return false
}
return true
}
func safePublicImageType(value string) bool {
switch value {
case "image/jpeg", "image/png", "image/gif", "image/webp":
return true
default:
return false
}
}
func schemeURLValues(scheme, kind string, values url.Values) string {
return (&url.URL{Scheme: scheme, Host: kind, RawQuery: values.Encode()}).String()
}
func publicWebAppURL(webBaseURL, legacyURL string) string {
return strings.TrimRight(webBaseURL, "/") + "/#?tgaddr=" + url.QueryEscape(legacyURL)
}
func publicSecurityHeaders(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Security-Policy", "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; script-src 'unsafe-inline'; base-uri 'none'; form-action 'self'; frame-ancestors 'none'")
w.Header().Set("Permissions-Policy", "camera=(), microphone=(), geolocation=(), payment=(), usb=()")
w.Header().Set("Referrer-Policy", "no-referrer")
w.Header().Set("X-Content-Type-Options", "nosniff")
w.Header().Set("X-Frame-Options", "DENY")
next.ServeHTTP(w, r)
})
}
func validShortNamePath(shortName string) bool {
if shortName == "" || len(shortName) > 64 {
return false
}
for _, r := range shortName {
switch {
case r >= 'a' && r <= 'z':
case r >= 'A' && r <= 'Z':
case r >= '0' && r <= '9':
case r == '_' || r == '.':
default:
return false
}
}
return true
}
func validSlugPath(slug string) bool {
return links.ValidChatlistSlug(slug)
}
func validStarGiftSlugPath(slug string) bool {
if slug == "" || len(slug) > domain.MaxStarGiftSlugBytes {
return false
}
for _, r := range slug {
switch {
case r >= 'a' && r <= 'z':
case r >= 'A' && r <= 'Z':
case r >= '0' && r <= '9':
case r == '.' || r == '_' || r == '-':
default:
return false
}
}
return true
}
func validUsernamePath(username string) bool {
if username == "" || len(username) < 5 || len(username) > 32 {
return false
}
for i, r := range username {
switch {
case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z':
case r >= '0' && r <= '9', r == '_':
if i == 0 {
return false
}
default:
return false
}
}
return true
}
func linkKind(set domain.StickerSet) string {
if set.Kind == domain.StickerSetKindEmoji || set.Emojis {
return "addemoji"
}
return "addstickers"
}
func fallbackTitle(set domain.StickerSet) string {
if title := strings.TrimSpace(set.Title); title != "" {
return title
}
return set.ShortName
}
func kindLabel(set domain.StickerSet) string {
switch {
case set.Kind == domain.StickerSetKindEmoji || set.Emojis:
return "custom emoji set"
case set.Kind == domain.StickerSetKindMasks || set.Masks:
return "mask set"
default:
return "sticker set"
}
}
func itemNoun(set domain.StickerSet, count int) string {
if set.Kind == domain.StickerSetKindEmoji || set.Emojis {
if count == 1 {
return "custom emoji"
}
return "custom emoji"
}
if count == 1 {
return "sticker"
}
return "stickers"
}
func (h *handler) appURL(kind, key, value string) string {
return schemeURL(h.appScheme, kind, key, value)
}
func legacyTgURL(kind, key, value string) string {
return schemeURL("tg", kind, key, value)
}
func schemeURL(scheme, kind, key, value string) string {
return scheme + "://" + kind + "?" + key + "=" + url.QueryEscape(value)
}
type pageData struct {
AppName string
Title string
KindLabel string
Subtitle string
Description string
CanonicalURL string
AppURL template.URL
LegacyTgURL template.URL
AppURLJS template.JS
}
type usernamePageData struct {
AppName string
AppInitial string
Title string
Username string
Verified bool
Extra string
Description string
CanonicalURL string
HomeURL string
PhotoURL string
Initials string
ButtonLabel string
AppURL template.URL
LegacyTgURL template.URL
WebURL template.URL
AppURLJS template.JS
}
func (h *handler) serveUsernameNotFound(w http.ResponseWriter, username string) {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Header().Set("Cache-Control", "public, max-age=30, must-revalidate")
w.WriteHeader(http.StatusNotFound)
if err := usernameNotFoundTemplate.Execute(w, struct {
Username string
HomeURL string
AppName string
}{Username: username, HomeURL: h.publicBaseURL + "/", AppName: h.appName}); err != nil {
h.logger.Error("Render public username not-found page failed", zap.String("username", username), zap.Error(err))
}
}
var usernameLandingTemplate = template.Must(template.New("username-landing").Parse(`
{{.Title}} (@{{.Username}}) - {{.AppName}}
{{if .PhotoURL}}{{end}}
{{if .PhotoURL}}{{end}}
{{.AppInitial}}{{.AppName}}
{{if .PhotoURL}}
{{else}}
{{.Initials}}{{end}}
{{.Title}}{{if .Verified}}✓{{end}}
@{{.Username}}
{{if .Extra}}{{end}}
{{.Description}}
Old test clients only: open with tg://
`))
var usernameNotFoundTemplate = template.Must(template.New("username-not-found").Parse(`
Username not found - {{.AppName}}
Username not found
{{if .Username}}@{{.Username}} is not an active public {{.AppName}} username.{{else}}This is not a valid public {{.AppName}} username.{{end}}
Back to {{.AppName}}`))
var landingTemplate = template.Must(template.New("landing").Parse(`
{{.Title}} - {{.AppName}}
{{.KindLabel}}
{{.Title}}
{{.Subtitle}}
Open in {{.AppName}}
{{.Description}}
Old test clients only: open with tg://
{{.CanonicalURL}}
`))