实现 MLS 设备封包投递与离线同步
This commit is contained in:
1 parent
53164d0fa8
commit
f30f01b699
15 files changed
+366
-16
No files matched your search
@@ -16,6 +16,7 @@ import (
|
||||
"xhchat/server/internal/config"
|
||||
"xhchat/server/internal/contacts"
|
||||
"xhchat/server/internal/database"
|
||||
"xhchat/server/internal/delivery"
|
||||
"xhchat/server/internal/httpapi"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
@@ -63,6 +64,7 @@ func run() error {
|
||||
}
|
||||
cancel()
|
||||
accounts := account.New(db, cfg.SessionTTL)
|
||||
envelopes := delivery.New(db)
|
||||
go func() {
|
||||
ticker := time.NewTicker(15 * time.Minute)
|
||||
defer ticker.Stop()
|
||||
@@ -75,12 +77,15 @@ func run() error {
|
||||
if err := accounts.Cleanup(cleanup); err != nil {
|
||||
slog.Warn("session cleanup failed")
|
||||
}
|
||||
if err := envelopes.Cleanup(cleanup, cfg.EnvelopeRetention); err != nil {
|
||||
slog.Warn("delivery cleanup failed")
|
||||
}
|
||||
cancel()
|
||||
}
|
||||
}
|
||||
}()
|
||||
server := &http.Server{
|
||||
Addr: cfg.Addr, Handler: httpapi.New(accounts, contacts.New(db), cache, cfg.Origins, ready),
|
||||
Addr: cfg.Addr, Handler: httpapi.New(accounts, contacts.New(db), envelopes, cache, cfg.Origins, ready),
|
||||
ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 10 * time.Second,
|
||||
WriteTimeout: 15 * time.Second, IdleTimeout: 60 * time.Second, MaxHeaderBytes: 16 << 10,
|
||||
BaseContext: func(net.Listener) context.Context { return ctx },
|
||||
|
||||
@@ -11,19 +11,28 @@ type Config struct {
|
||||
Addr, DatabaseURL, RedisURL string
|
||||
Origins map[string]bool
|
||||
SessionTTL time.Duration
|
||||
EnvelopeRetention time.Duration
|
||||
}
|
||||
|
||||
func Load() (Config, error) {
|
||||
c := Config{
|
||||
Addr: os.Getenv("XHCHAT_ADDR"),
|
||||
DatabaseURL: os.Getenv("DATABASE_URL"),
|
||||
RedisURL: os.Getenv("REDIS_URL"),
|
||||
Origins: make(map[string]bool),
|
||||
SessionTTL: 12 * time.Hour,
|
||||
Addr: os.Getenv("XHCHAT_ADDR"),
|
||||
DatabaseURL: os.Getenv("DATABASE_URL"),
|
||||
RedisURL: os.Getenv("REDIS_URL"),
|
||||
Origins: make(map[string]bool),
|
||||
SessionTTL: 12 * time.Hour,
|
||||
EnvelopeRetention: 30 * 24 * time.Hour,
|
||||
}
|
||||
if c.Addr == "" {
|
||||
c.Addr = "127.0.0.1:8080"
|
||||
}
|
||||
if raw := os.Getenv("XHCHAT_ENVELOPE_RETENTION"); raw != "" {
|
||||
retention, err := time.ParseDuration(raw)
|
||||
if err != nil || retention < time.Hour || retention > 365*24*time.Hour {
|
||||
return Config{}, errors.New("XHCHAT_ENVELOPE_RETENTION must be between 1h and 8760h")
|
||||
}
|
||||
c.EnvelopeRetention = retention
|
||||
}
|
||||
for _, origin := range strings.Split(os.Getenv("XHCHAT_ORIGINS"), ",") {
|
||||
if origin = strings.TrimSpace(origin); origin != "" {
|
||||
c.Origins[origin] = true
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
CREATE TABLE device_envelopes (
|
||||
sequence bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
|
||||
message_id uuid NOT NULL,
|
||||
sender_device uuid NOT NULL REFERENCES devices(id) ON DELETE CASCADE,
|
||||
recipient_device uuid NOT NULL REFERENCES devices(id) ON DELETE CASCADE,
|
||||
ciphertext bytea NOT NULL CHECK (octet_length(ciphertext) BETWEEN 16 AND 65536),
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
UNIQUE (sender_device, recipient_device, message_id),
|
||||
CHECK (sender_device <> recipient_device)
|
||||
);
|
||||
|
||||
CREATE INDEX device_envelopes_inbox ON device_envelopes(recipient_device, sequence);
|
||||
CREATE INDEX device_envelopes_expiry ON device_envelopes(created_at);
|
||||
@@ -13,6 +13,9 @@ var identityMigration string
|
||||
//go:embed 002_contacts.sql
|
||||
var contactsMigration string
|
||||
|
||||
//go:embed 003_delivery.sql
|
||||
var deliveryMigration string
|
||||
|
||||
func Migrate(ctx context.Context, pool *pgxpool.Pool) error {
|
||||
tx, err := pool.Begin(ctx)
|
||||
if err != nil {
|
||||
@@ -25,7 +28,7 @@ func Migrate(ctx context.Context, pool *pgxpool.Pool) error {
|
||||
if _, err = tx.Exec(ctx, "CREATE TABLE IF NOT EXISTS schema_migrations (version integer PRIMARY KEY)"); err != nil {
|
||||
return err
|
||||
}
|
||||
for index, migration := range []string{identityMigration, contactsMigration} {
|
||||
for index, migration := range []string{identityMigration, contactsMigration, deliveryMigration} {
|
||||
version := index + 1
|
||||
var applied bool
|
||||
if err = tx.QueryRow(ctx, "SELECT EXISTS (SELECT 1 FROM schema_migrations WHERE version=$1)", version).Scan(&applied); err != nil {
|
||||
|
||||
@@ -0,0 +1,131 @@
|
||||
package delivery
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrUnavailable = errors.New("delivery unavailable")
|
||||
ErrConflict = errors.New("message identifier already used for different bytes")
|
||||
)
|
||||
|
||||
type Envelope struct {
|
||||
Sequence string `json:"sequence"`
|
||||
MessageID string `json:"messageId"`
|
||||
SenderDevice string `json:"senderDevice"`
|
||||
Ciphertext []byte `json:"ciphertext"`
|
||||
CreatedAt time.Time `json:"createdAt"`
|
||||
}
|
||||
|
||||
type Store struct{ db *pgxpool.Pool }
|
||||
|
||||
func New(db *pgxpool.Pool) *Store { return &Store{db: db} }
|
||||
|
||||
func (s *Store) Send(ctx context.Context, sender, recipient, message string, ciphertext []byte) (string, error) {
|
||||
tx, err := s.db.Begin(ctx)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
defer tx.Rollback(ctx)
|
||||
|
||||
var senderUser, recipientUser string
|
||||
err = tx.QueryRow(ctx, `
|
||||
SELECT sender.user_id, recipient.user_id FROM devices sender CROSS JOIN devices recipient
|
||||
WHERE sender.id=$1 AND recipient.id=$2 AND sender.id<>recipient.id
|
||||
`, sender, recipient).Scan(&senderUser, &recipientUser)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return "", ErrUnavailable
|
||||
}
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
// Use the same account lock order as contact changes. Locking both devices also
|
||||
// serializes writes for each recipient and prevents a cursor passing an uncommitted write.
|
||||
if _, err = tx.Exec(ctx, "SELECT id FROM users WHERE id IN ($1,$2) ORDER BY id FOR UPDATE", senderUser, recipientUser); err != nil {
|
||||
return "", err
|
||||
}
|
||||
var active int
|
||||
err = tx.QueryRow(ctx, `
|
||||
SELECT count(*) FROM (
|
||||
SELECT id FROM devices WHERE id IN ($1,$2) AND revoked_at IS NULL ORDER BY id FOR UPDATE
|
||||
) AS active_devices
|
||||
`, sender, recipient).Scan(&active)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if active != 2 {
|
||||
return "", ErrUnavailable
|
||||
}
|
||||
|
||||
// This direct-message endpoint only connects accepted contacts.
|
||||
// A separate authorization flow is needed for same-account device transfers.
|
||||
var friends bool
|
||||
err = tx.QueryRow(ctx, `
|
||||
SELECT EXISTS (SELECT 1 FROM contact_relationships
|
||||
WHERE first_user=LEAST($1::uuid,$2::uuid) AND second_user=GREATEST($1::uuid,$2::uuid)
|
||||
AND status='accepted')
|
||||
`, senderUser, recipientUser).Scan(&friends)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if !friends {
|
||||
return "", ErrUnavailable
|
||||
}
|
||||
|
||||
var seq string
|
||||
err = tx.QueryRow(ctx, `
|
||||
INSERT INTO device_envelopes(message_id, sender_device, recipient_device, ciphertext)
|
||||
VALUES ($1,$2,$3,$4)
|
||||
ON CONFLICT (sender_device, recipient_device, message_id) DO NOTHING
|
||||
RETURNING sequence::text
|
||||
`, message, sender, recipient, ciphertext).Scan(&seq)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
var previous []byte
|
||||
err = tx.QueryRow(ctx, `
|
||||
SELECT sequence::text,ciphertext FROM device_envelopes
|
||||
WHERE message_id=$1 AND sender_device=$2 AND recipient_device=$3
|
||||
`, message, sender, recipient).Scan(&seq, &previous)
|
||||
if err == nil && !bytes.Equal(previous, ciphertext) {
|
||||
return "", ErrConflict
|
||||
}
|
||||
}
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return seq, tx.Commit(ctx)
|
||||
}
|
||||
|
||||
func (s *Store) Inbox(ctx context.Context, recipient string, after int64) ([]Envelope, error) {
|
||||
rows, err := s.db.Query(ctx, `
|
||||
SELECT e.sequence::text,e.message_id,e.sender_device,e.ciphertext,e.created_at
|
||||
FROM device_envelopes e JOIN devices d ON e.recipient_device=d.id
|
||||
WHERE d.id=$1 AND d.revoked_at IS NULL AND e.sequence>$2
|
||||
ORDER BY e.sequence LIMIT 64
|
||||
`, recipient, after)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
envelopes := make([]Envelope, 0)
|
||||
for rows.Next() {
|
||||
var envelope Envelope
|
||||
if err := rows.Scan(&envelope.Sequence, &envelope.MessageID, &envelope.SenderDevice,
|
||||
&envelope.Ciphertext, &envelope.CreatedAt); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
envelopes = append(envelopes, envelope)
|
||||
}
|
||||
return envelopes, rows.Err()
|
||||
}
|
||||
|
||||
func (s *Store) Cleanup(ctx context.Context, retention time.Duration) error {
|
||||
_, err := s.db.Exec(ctx, "DELETE FROM device_envelopes WHERE created_at < $1", time.Now().Add(-retention))
|
||||
return err
|
||||
}
|
||||
@@ -15,6 +15,7 @@ import (
|
||||
|
||||
"xhchat/server/internal/account"
|
||||
"xhchat/server/internal/contacts"
|
||||
"xhchat/server/internal/delivery"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/redis/go-redis/v9"
|
||||
@@ -23,14 +24,15 @@ import (
|
||||
type API struct {
|
||||
accounts *account.Store
|
||||
contacts *contacts.Store
|
||||
delivery *delivery.Store
|
||||
redis *redis.Client
|
||||
origins map[string]bool
|
||||
hashSlots chan struct{}
|
||||
ready func(context.Context) error
|
||||
}
|
||||
|
||||
func New(accounts *account.Store, contactStore *contacts.Store, cache *redis.Client, origins map[string]bool, ready func(context.Context) error) http.Handler {
|
||||
a := &API{accounts: accounts, contacts: contactStore, redis: cache, origins: origins, hashSlots: make(chan struct{}, 4), ready: ready}
|
||||
func New(accounts *account.Store, contactStore *contacts.Store, envelopeStore *delivery.Store, cache *redis.Client, origins map[string]bool, ready func(context.Context) error) http.Handler {
|
||||
a := &API{accounts: accounts, contacts: contactStore, delivery: envelopeStore, redis: cache, origins: origins, hashSlots: make(chan struct{}, 4), ready: ready}
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, _ *http.Request) { respond(w, 200, map[string]string{"status": "ok"}) })
|
||||
mux.HandleFunc("GET /readyz", a.readiness)
|
||||
@@ -46,6 +48,8 @@ func New(accounts *account.Store, contactStore *contacts.Store, cache *redis.Cli
|
||||
mux.HandleFunc("GET /api/v1/contacts", a.authorized(a.listContacts))
|
||||
mux.HandleFunc("GET /api/v1/contacts/search", a.authorized(a.searchContact))
|
||||
mux.HandleFunc("POST /api/v1/contacts/{id}", a.authorized(a.changeContact))
|
||||
mux.HandleFunc("GET /api/v1/inbox", a.authorized(a.inbox))
|
||||
mux.HandleFunc("POST /api/v1/inbox", a.authorized(a.sendEnvelope))
|
||||
return a.boundary(mux)
|
||||
}
|
||||
|
||||
@@ -236,7 +240,11 @@ func (a *API) limit(w http.ResponseWriter, r *http.Request, key string, max int)
|
||||
}
|
||||
|
||||
func parse(w http.ResponseWriter, r *http.Request, value any) bool {
|
||||
decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 4096))
|
||||
return parseLimit(w, r, value, 4096)
|
||||
}
|
||||
|
||||
func parseLimit(w http.ResponseWriter, r *http.Request, value any, maximum int64) bool {
|
||||
decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, maximum))
|
||||
decoder.DisallowUnknownFields()
|
||||
if err := decoder.Decode(value); err != nil || decoder.Decode(new(any)) != io.EOF {
|
||||
problem(w, 400, "invalid_json", "请求格式错误")
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
package httpapi
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"xhchat/server/internal/account"
|
||||
"xhchat/server/internal/delivery"
|
||||
)
|
||||
|
||||
func (a *API) sendEnvelope(w http.ResponseWriter, r *http.Request, _ string, identity account.Identity) {
|
||||
var input struct {
|
||||
MessageID string `json:"messageId"`
|
||||
RecipientDevice string `json:"recipientDevice"`
|
||||
Ciphertext []byte `json:"ciphertext"`
|
||||
}
|
||||
if !parseLimit(w, r, &input, 96<<10) {
|
||||
return
|
||||
}
|
||||
if !uuidPattern.MatchString(input.MessageID) || !uuidPattern.MatchString(input.RecipientDevice) || !mlsFrame(input.Ciphertext) {
|
||||
problem(w, 400, "invalid_envelope", "请输入有效的 MLS 密文封包")
|
||||
return
|
||||
}
|
||||
if !a.limit(w, r, "envelope-send:"+identity.Device.ID, 180) {
|
||||
return
|
||||
}
|
||||
recipient := strings.ToLower(input.RecipientDevice)
|
||||
seq, err := a.delivery.Send(r.Context(), identity.Device.ID, recipient, input.MessageID, input.Ciphertext)
|
||||
switch {
|
||||
case errors.Is(err, delivery.ErrUnavailable):
|
||||
problem(w, 404, "delivery_unavailable", "无法向指定设备投递")
|
||||
case errors.Is(err, delivery.ErrConflict):
|
||||
problem(w, 409, "message_id_conflict", "消息 ID 已关联其他密文")
|
||||
case err != nil:
|
||||
unavailable(w, err)
|
||||
default:
|
||||
_ = a.redis.Publish(r.Context(), "xhchat:inbox:"+recipient, "changed").Err()
|
||||
respond(w, 200, map[string]string{"sequence": seq})
|
||||
}
|
||||
}
|
||||
|
||||
func mlsFrame(wire []byte) bool {
|
||||
// RFC 9420 MLSMessage header. The delivery service routes PrivateMessage and
|
||||
// Welcome. Recipients validate the complete message and authenticate its contents.
|
||||
return len(wire) >= 16 && len(wire) <= 65536 && wire[0] == 0 && wire[1] == 1 &&
|
||||
wire[2] == 0 && (wire[3] == 2 || wire[3] == 3)
|
||||
}
|
||||
|
||||
func (a *API) inbox(w http.ResponseWriter, r *http.Request, _ string, identity account.Identity) {
|
||||
var after int64
|
||||
if raw := r.URL.Query().Get("after"); raw != "" {
|
||||
var err error
|
||||
after, err = strconv.ParseInt(raw, 10, 64)
|
||||
if err != nil || after < 0 {
|
||||
problem(w, 400, "invalid_cursor", "无效的投递游标")
|
||||
return
|
||||
}
|
||||
}
|
||||
if !a.limit(w, r, "inbox:"+identity.Device.ID, 180) {
|
||||
return
|
||||
}
|
||||
items, err := a.delivery.Inbox(r.Context(), identity.Device.ID, after)
|
||||
if err != nil {
|
||||
unavailable(w, err)
|
||||
return
|
||||
}
|
||||
respond(w, 200, items)
|
||||
}
|
||||
@@ -63,7 +63,8 @@ func (a *API) realtime(w http.ResponseWriter, r *http.Request) {
|
||||
unavailable(w, err)
|
||||
return
|
||||
}
|
||||
subscription := a.redis.Subscribe(r.Context(), "xhchat:contacts:"+identity.User.ID)
|
||||
inboxChannel := "xhchat:inbox:" + identity.Device.ID
|
||||
subscription := a.redis.Subscribe(r.Context(), "xhchat:contacts:"+identity.User.ID, inboxChannel)
|
||||
defer subscription.Close()
|
||||
if _, err = subscription.Receive(r.Context()); err != nil {
|
||||
unavailable(w, err)
|
||||
@@ -94,12 +95,16 @@ func (a *API) realtime(w http.ResponseWriter, r *http.Request) {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case _, ok := <-changes:
|
||||
case change, ok := <-changes:
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
writeCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
|
||||
err := wsjson.Write(writeCtx, conn, map[string]string{"type": "contacts_changed"})
|
||||
event := "contacts_changed"
|
||||
if change.Channel == inboxChannel {
|
||||
event = "inbox_changed"
|
||||
}
|
||||
err := wsjson.Write(writeCtx, conn, map[string]string{"type": event})
|
||||
cancel()
|
||||
if err != nil {
|
||||
return
|
||||
|
||||
Reference in new issue
Block a user