实现 MLS 设备封包投递与离线同步

This commit is contained in:
xhgit committed 2026-11-13 18:21:09 +08:00
1 parent 53164d0fa8
commit f30f01b699
15 files changed
+366 -16

No files matched your search

+14 -5
View File
@@ -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
+13
View File
@@ -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);
+4 -1
View File
@@ -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 {
+131
View File
@@ -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
}
+11 -3
View File
@@ -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", "请求格式错误")
+70
View File
@@ -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)
}
+8 -3
View File
@@ -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