gmessages/provisioning.go

380 lines
12 KiB
Go
Raw Normal View History

2023-07-16 22:13:46 +00:00
// mautrix-gmessages - A Matrix-Google Messages puppeting bridge.
// Copyright (C) 2023 Tulir Asokan
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
package main
import (
"context"
"encoding/json"
"errors"
"net/http"
"strings"
"time"
"github.com/rs/zerolog"
2023-07-16 22:52:13 +00:00
"google.golang.org/protobuf/proto"
2023-07-16 22:13:46 +00:00
log "maunium.net/go/maulogger/v2"
"maunium.net/go/mautrix/bridge/status"
"maunium.net/go/mautrix/id"
2023-07-16 22:52:13 +00:00
2023-07-17 13:51:31 +00:00
"go.mau.fi/mautrix-gmessages/libgm/gmproto"
2023-07-16 22:13:46 +00:00
)
type ProvisioningAPI struct {
bridge *GMBridge
log log.Logger
zlog zerolog.Logger
}
func (prov *ProvisioningAPI) Init() {
prov.log = prov.bridge.Log.Sub("Provisioning")
prov.zlog = prov.bridge.ZLog.With().Str("component", "provisioning").Logger()
prov.log.Debugln("Enabling provisioning API at", prov.bridge.Config.Bridge.Provisioning.Prefix)
r := prov.bridge.AS.Router.PathPrefix(prov.bridge.Config.Bridge.Provisioning.Prefix).Subrouter()
r.Use(prov.AuthMiddleware)
r.HandleFunc("/v1/ping", prov.Ping).Methods(http.MethodGet)
r.HandleFunc("/v1/login", prov.Login).Methods(http.MethodPost)
r.HandleFunc("/v1/logout", prov.Logout).Methods(http.MethodPost)
r.HandleFunc("/v1/delete_session", prov.DeleteSession).Methods(http.MethodPost)
r.HandleFunc("/v1/disconnect", prov.Disconnect).Methods(http.MethodPost)
r.HandleFunc("/v1/reconnect", prov.Reconnect).Methods(http.MethodPost)
r.HandleFunc("/v1/contacts", prov.ListContacts).Methods(http.MethodGet)
r.HandleFunc("/v1/start_chat", prov.StartChat).Methods(http.MethodPost)
prov.bridge.AS.Router.HandleFunc("/_matrix/app/com.beeper.asmux/ping", prov.BridgeStatePing).Methods(http.MethodPost)
prov.bridge.AS.Router.HandleFunc("/_matrix/app/com.beeper.bridge_state", prov.BridgeStatePing).Methods(http.MethodPost)
// Deprecated, just use /disconnect
r.HandleFunc("/v1/delete_connection", prov.Disconnect).Methods(http.MethodPost)
}
type responseWrap struct {
http.ResponseWriter
statusCode int
}
func (rw *responseWrap) WriteHeader(statusCode int) {
rw.ResponseWriter.WriteHeader(statusCode)
rw.statusCode = statusCode
}
func (prov *ProvisioningAPI) AuthMiddleware(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
auth := r.Header.Get("Authorization")
if strings.HasPrefix(auth, "Bearer ") {
auth = auth[len("Bearer "):]
}
if auth != prov.bridge.Config.Bridge.Provisioning.SharedSecret {
prov.log.Infof("Authentication token does not match shared secret")
jsonResponse(w, http.StatusForbidden, map[string]interface{}{
"error": "Authentication token does not match shared secret",
"errcode": "M_FORBIDDEN",
})
return
}
userID := r.URL.Query().Get("user_id")
user := prov.bridge.GetUserByMXID(id.UserID(userID))
start := time.Now()
wWrap := &responseWrap{w, 200}
h.ServeHTTP(wWrap, r.WithContext(context.WithValue(r.Context(), "user", user)))
duration := time.Now().Sub(start).Seconds()
prov.log.Infofln("%s %s from %s took %.2f seconds and returned status %d", r.Method, r.URL.Path, user.MXID, duration, wWrap.statusCode)
})
}
type Error struct {
Success bool `json:"success"`
Error string `json:"error"`
ErrCode string `json:"errcode"`
}
type Response struct {
Success bool `json:"success"`
Status string `json:"status"`
}
func (prov *ProvisioningAPI) DeleteSession(w http.ResponseWriter, r *http.Request) {
user := r.Context().Value("user").(*User)
if user.Session == nil && user.Client == nil {
jsonResponse(w, http.StatusNotFound, Error{
Error: "Nothing to purge: no session information stored and no active connection.",
ErrCode: "no session",
})
return
}
user.Logout(status.BridgeState{StateEvent: status.StateLoggedOut}, false)
jsonResponse(w, http.StatusOK, Response{true, "Session information purged"})
}
func (prov *ProvisioningAPI) Disconnect(w http.ResponseWriter, r *http.Request) {
user := r.Context().Value("user").(*User)
if user.Client == nil {
jsonResponse(w, http.StatusNotFound, Error{
Error: "You don't have a Google Messages connection.",
ErrCode: "no connection",
})
return
}
user.DeleteConnection()
jsonResponse(w, http.StatusOK, Response{true, "Disconnected from Google Messages"})
user.BridgeState.Send(status.BridgeState{StateEvent: status.StateTransientDisconnect, Error: GMNotConnected})
}
func (prov *ProvisioningAPI) Reconnect(w http.ResponseWriter, r *http.Request) {
user := r.Context().Value("user").(*User)
if user.Client == nil {
if user.Session == nil {
jsonResponse(w, http.StatusForbidden, Error{
Error: "No existing connection and no session. Please log in first.",
ErrCode: "no session",
})
} else {
user.Connect()
jsonResponse(w, http.StatusAccepted, Response{true, "Created connection to Google Messages."})
}
} else {
user.DeleteConnection()
user.BridgeState.Send(status.BridgeState{StateEvent: status.StateTransientDisconnect, Error: GMNotConnected})
user.Connect()
jsonResponse(w, http.StatusAccepted, Response{true, "Restarted connection to Google Messages"})
}
}
func (prov *ProvisioningAPI) ListContacts(w http.ResponseWriter, r *http.Request) {
if user := r.Context().Value("user").(*User); user.Client == nil {
jsonResponse(w, http.StatusBadRequest, Error{
Error: "User is not connected to Google Messages",
ErrCode: "no session",
})
} else if contacts, err := user.Client.ListContacts(); err != nil {
prov.log.Errorfln("Failed to fetch %s's contacts: %v", user.MXID, err)
jsonResponse(w, http.StatusInternalServerError, Error{
Error: "Internal server error while fetching contact list",
ErrCode: "failed to get contacts",
})
} else {
jsonResponse(w, http.StatusOK, contacts)
}
}
2023-07-16 22:52:13 +00:00
type StartChatRequest struct {
Numbers []string `json:"numbers"`
}
type StartChatResponse struct {
RoomID id.RoomID `json:"room_id"`
}
2023-07-16 22:13:46 +00:00
func (prov *ProvisioningAPI) StartChat(w http.ResponseWriter, r *http.Request) {
2023-07-16 22:52:13 +00:00
user := r.Context().Value("user").(*User)
if user.Client == nil {
2023-07-16 22:13:46 +00:00
jsonResponse(w, http.StatusBadRequest, Error{
Error: "User is not connected to Google Messages",
ErrCode: "no session",
})
}
2023-07-16 22:52:13 +00:00
var req StartChatRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
jsonResponse(w, http.StatusBadRequest, Error{
Error: "Failed to parse request JSON",
ErrCode: "bad json",
})
}
2023-07-17 23:57:20 +00:00
var reqData gmproto.GetOrCreateConversationRequest
2023-07-17 13:51:31 +00:00
reqData.Numbers = make([]*gmproto.ContactNumber, 0, len(req.Numbers))
2023-07-16 22:52:13 +00:00
for _, number := range req.Numbers {
2023-07-17 13:51:31 +00:00
reqData.Numbers = append(reqData.Numbers, &gmproto.ContactNumber{
2023-07-16 22:52:13 +00:00
// This should maybe sometimes be 7
MysteriousInt: 2,
Number: number,
Number2: number,
})
}
resp, err := user.Client.GetOrCreateConversation(&reqData)
if err != nil {
prov.zlog.Err(err).Msg("Failed to start chat")
jsonResponse(w, http.StatusInternalServerError, Error{
Error: "Failed to start chat",
ErrCode: "unknown error",
})
return
2023-07-17 13:51:31 +00:00
} else if resp.GetStatus() == gmproto.GetOrCreateConversationResponse_CREATE_RCS {
2023-07-16 22:52:13 +00:00
prov.zlog.Debug().Msg("Creating RCS group")
// TODO this will always create a new group and won't deduplicate
reqData.CreateRCSGroup = proto.Bool(true)
resp, err = user.Client.GetOrCreateConversation(&reqData)
if err != nil {
prov.zlog.Err(err).Msg("Failed to start RCS chat")
jsonResponse(w, http.StatusInternalServerError, Error{
Error: "Failed to start chat",
ErrCode: "unknown error",
})
return
}
}
if resp.GetConversation() == nil {
prov.zlog.Warn().Str("status", resp.GetStatus().String()).Msg("No conversation in chat create response")
jsonResponse(w, http.StatusInternalServerError, Error{
Error: "Failed to start chat",
ErrCode: "unknown error",
})
return
}
portal := user.GetPortalByID(resp.Conversation.ConversationID)
err = portal.CreateMatrixRoom(user, resp.Conversation)
if err != nil {
prov.zlog.Err(err).Msg("Failed to create matrix room")
jsonResponse(w, http.StatusInternalServerError, Error{
Error: "Failed to create matrix room",
ErrCode: "unknown error",
})
return
}
jsonResponse(w, http.StatusOK, StartChatResponse{portal.MXID})
2023-07-16 22:13:46 +00:00
}
func (prov *ProvisioningAPI) Ping(w http.ResponseWriter, r *http.Request) {
user := r.Context().Value("user").(*User)
gm := map[string]interface{}{
"has_session": user.Session != nil,
"conn": nil,
}
if user.Session != nil {
gm["phone_id"] = user.Session.Mobile.SourceID
gm["browser_id"] = user.Session.Browser.SourceID
}
if user.Client != nil {
gm["conn"] = map[string]interface{}{
"is_connected": user.Client.IsConnected(),
"is_logged_in": user.Client.IsLoggedIn(),
}
}
resp := map[string]interface{}{
"mxid": user.MXID,
"admin": user.Admin,
"whitelisted": user.Whitelisted,
"management_room": user.ManagementRoom,
"space_room": user.SpaceRoom,
"gmessages": gm,
}
jsonResponse(w, http.StatusOK, resp)
}
func jsonResponse(w http.ResponseWriter, status int, response interface{}) {
w.Header().Add("Content-Type", "application/json")
w.WriteHeader(status)
_ = json.NewEncoder(w).Encode(response)
}
func (prov *ProvisioningAPI) Logout(w http.ResponseWriter, r *http.Request) {
user := r.Context().Value("user").(*User)
if user.Session == nil {
jsonResponse(w, http.StatusOK, Error{
Error: "You're not logged in",
ErrCode: "not logged in",
})
return
}
user.Logout(status.BridgeState{StateEvent: status.StateLoggedOut}, true)
jsonResponse(w, http.StatusOK, Response{true, "Logged out successfully."})
}
type LoginResponse struct {
Status string `json:"status"`
Code string `json:"code,omitempty"`
ErrCode string `json:"errcode,omitempty"`
Error string `json:"error,omitempty"`
}
func (prov *ProvisioningAPI) Login(w http.ResponseWriter, r *http.Request) {
userID := r.URL.Query().Get("user_id")
user := prov.bridge.GetUserByMXID(id.UserID(userID))
log := prov.zlog.With().Str("user_id", user.MXID.String()).Str("endpoint", "login").Logger()
if user.IsLoggedIn() {
jsonResponse(w, http.StatusOK, LoginResponse{Status: "success", ErrCode: "already logged in"})
return
}
ch, err := user.Login(5)
2023-07-16 22:13:46 +00:00
if err != nil && !errors.Is(err, ErrLoginInProgress) {
log.Err(err).Msg("Failed to start login via provisioning API")
jsonResponse(w, http.StatusInternalServerError, Error{
Error: "Failed to start login",
ErrCode: "start login fail",
})
return
}
var item, prevItem qrChannelItem
var hasItem bool
Loop:
for {
prevItem = item
select {
case item = <-ch:
hasItem = true
default:
break Loop
}
}
if !hasItem && r.URL.Query().Get("return_immediately") == "true" && user.lastQRCode != "" {
log.Debug().Msg("Nothing in QR channel, returning last code immediately")
item.qr = user.lastQRCode
} else if !hasItem {
2023-07-16 22:13:46 +00:00
log.Debug().Msg("Nothing in QR channel, waiting for next item")
select {
case item = <-ch:
case <-r.Context().Done():
log.Warn().Err(r.Context().Err()).Msg("Client left while waiting for QR code")
return
}
} else if item.IsEmpty() && !prevItem.IsEmpty() {
item = prevItem
}
switch {
case item.qr != "":
log.Debug().Msg("Got code in QR channel")
Segment.Track(user.MXID, "$qrcode_retrieved")
jsonResponse(w, http.StatusOK, LoginResponse{Status: "qr", Code: item.qr})
case item.err != nil:
log.Err(item.err).Msg("Got error in QR channel")
Segment.Track(user.MXID, "$login_failure")
var resp LoginResponse
switch {
case errors.Is(item.err, ErrLoginTimeout):
resp = LoginResponse{ErrCode: "timeout", Error: "Scanning QR code timed out"}
default:
resp = LoginResponse{ErrCode: "unknown", Error: "Login failed"}
}
resp.Status = "fail"
jsonResponse(w, http.StatusOK, resp)
case item.success:
log.Debug().Msg("Got pair success in QR channel")
Segment.Track(user.MXID, "$login_success")
jsonResponse(w, http.StatusOK, LoginResponse{Status: "success"})
default:
log.Error().Any("item_data", item).Msg("Unknown item in QR channel")
resp := LoginResponse{Status: "fail", ErrCode: "internal-error", Error: "Unknown item in login channel"}
jsonResponse(w, http.StatusInternalServerError, resp)
}
}