package groups import ( "bytes" "context" "errors" "time" "github.com/jackc/pgx/v5" ) var ErrVersion = errors.New("group membership or device set changed") type DeviceWelcome struct { Device string `json:"device"` Wire []byte `json:"wire,omitempty"` } type Epoch struct { ID string `json:"id"` Version string `json:"membershipVersion"` Devices []DeviceWelcome `json:"devices"` } type AvailableEpoch struct { ID string `json:"id"` Version string `json:"membershipVersion"` Creator string `json:"creatorDevice"` Welcome []byte `json:"welcome,omitempty"` Current bool `json:"current"` Roster []string `json:"roster"` } type Message struct { Sequence string `json:"sequence"` Epoch string `json:"epoch"` ID string `json:"id"` Sender string `json:"senderDevice"` Wire []byte `json:"wire"` CreatedAt time.Time `json:"createdAt"` AttachmentID *string `json:"attachmentId,omitempty"` } func lockTransport(ctx context.Context, tx pgx.Tx, group, user, device string) (string, bool, error) { var version string var owner bool err := tx.QueryRow(ctx, ` SELECT g.membership_version::text,g.owner_id=$2 FROM chat_groups g JOIN group_members m ON m.group_id=g.id JOIN devices d ON d.user_id=m.user_id WHERE g.id=$1 AND m.user_id=$2 AND m.state='active' AND d.id=$3 AND d.revoked_at IS NULL FOR UPDATE OF g `, group, user, device).Scan(&version, &owner) if errors.Is(err, pgx.ErrNoRows) { err = ErrUnavailable } return version, owner, err } func (s *Store) PublishEpoch(ctx context.Context, group, user, sender string, epoch Epoch) error { tx, err := s.db.Begin(ctx) if err != nil { return err } defer tx.Rollback(ctx) version, owner, err := lockTransport(ctx, tx, group, user, sender) if err != nil { return err } if !owner { return ErrAction } if version != epoch.Version { return ErrVersion } // Lock the selected devices so a revocation cannot interleave with enrollment. devices := make([]string, 0, len(epoch.Devices)) for _, welcome := range epoch.Devices { devices = append(devices, welcome.Device) } var size, people, active int err = tx.QueryRow(ctx, ` SELECT count(*), count(DISTINCT user_id), (SELECT count(*) FROM group_members WHERE group_id=$1 AND state='active') FROM ( SELECT d.user_id FROM devices d JOIN group_members m ON m.user_id=d.user_id JOIN device_mls_credentials c ON c.device_id=d.id WHERE m.group_id=$1 AND m.state='active' AND d.revoked_at IS NULL AND d.id=ANY($2::uuid[]) ORDER BY d.id FOR UPDATE OF d ) AS locked `, group, devices).Scan(&size, &people, &active) if err != nil { return err } if size != len(devices) || people != active || people != size { return ErrVersion } if _, err = tx.Exec(ctx, ` UPDATE group_epochs g SET retired_at=now() WHERE g.group_id=$1 AND g.membership_version=$2::bigint AND g.retired_at IS NULL AND EXISTS ( SELECT 1 FROM group_epoch_devices e JOIN devices d ON d.id=e.device_id WHERE e.group_id=g.group_id AND e.epoch_id=g.id AND d.revoked_at IS NOT NULL ) `, group, version); err != nil { return err } result, err := tx.Exec(ctx, ` INSERT INTO group_epochs(group_id,id,membership_version,creator_device) VALUES($1,$2,$3::bigint,$4) ON CONFLICT DO NOTHING `, group, epoch.ID, version, sender) if err != nil { return err } if result.RowsAffected() == 0 { return retryEpoch(ctx, tx, group, sender, epoch) } for _, welcome := range epoch.Devices { if _, err = tx.Exec(ctx, "INSERT INTO group_epoch_devices VALUES($1,$2,$3,$4)", group, epoch.ID, welcome.Device, welcome.Wire); err != nil { return err } } return tx.Commit(ctx) } func retryEpoch(ctx context.Context, tx pgx.Tx, group, sender string, input Epoch) error { var matches bool err := tx.QueryRow(ctx, ` SELECT EXISTS ( SELECT 1 FROM group_epochs WHERE group_id=$1 AND id=$2 AND membership_version=$3::bigint AND creator_device=$4 AND retired_at IS NULL ) AND (SELECT count(*) FROM group_epoch_devices WHERE group_id=$1 AND epoch_id=$2)=$5 `, group, input.ID, input.Version, sender, len(input.Devices)).Scan(&matches) if err != nil { return err } if !matches { return ErrVersion } for _, item := range input.Devices { var wire []byte err = tx.QueryRow(ctx, "SELECT welcome FROM group_epoch_devices WHERE group_id=$1 AND epoch_id=$2 AND device_id=$3", group, input.ID, item.Device).Scan(&wire) if errors.Is(err, pgx.ErrNoRows) || err == nil && !bytes.Equal(wire, item.Wire) { return ErrVersion } if err != nil { return err } } return tx.Commit(ctx) } func lockSendingEpoch(ctx context.Context, tx pgx.Tx, group, user, device, epoch string) error { version, _, err := lockTransport(ctx, tx, group, user, device) if err != nil { return err } var enrolled bool err = tx.QueryRow(ctx, ` SELECT EXISTS(SELECT 1 FROM group_epoch_devices e JOIN group_epochs g ON g.group_id=e.group_id AND g.id=e.epoch_id WHERE e.group_id=$1 AND e.epoch_id=$2 AND e.device_id=$3 AND g.membership_version=$4::bigint AND g.retired_at IS NULL) `, group, epoch, device, version).Scan(&enrolled) if err != nil { return err } if !enrolled { return ErrVersion } // Match the device revocation transaction's row lock. Once a bound device is // revoked the generation cannot accept any further application ciphertext. rows, err := tx.Query(ctx, ` SELECT d.revoked_at IS NULL FROM group_epoch_devices e JOIN devices d ON d.id=e.device_id WHERE e.group_id=$1 AND e.epoch_id=$2 ORDER BY d.id FOR UPDATE OF d `, group, epoch) if err != nil { return err } defer rows.Close() for rows.Next() { var active bool if err = rows.Scan(&active); err != nil { return err } if !active { return ErrVersion } } return rows.Err() } func (s *Store) Send(ctx context.Context, group, user, device string, message Message) (string, error) { tx, err := s.db.Begin(ctx) if err != nil { return "", err } defer tx.Rollback(ctx) if err = lockSendingEpoch(ctx, tx, group, user, device, message.Epoch); err != nil { return "", err } if message.AttachmentID != nil { var found string err = tx.QueryRow(ctx, ` SELECT id FROM group_attachments WHERE group_id=$1 AND epoch_id=$2 AND sender_device=$3 AND id=$4 FOR KEY SHARE `, group, message.Epoch, device, message.AttachmentID).Scan(&found) if errors.Is(err, pgx.ErrNoRows) { return "", ErrAttachment } if err != nil { return "", err } } var sequence string err = tx.QueryRow(ctx, ` INSERT INTO group_messages(group_id,epoch_id,sender_device,message_id,ciphertext,attachment_id) VALUES($1,$2,$3,$4,$5,$6) ON CONFLICT DO NOTHING RETURNING sequence::text `, group, message.Epoch, device, message.ID, message.Wire, message.AttachmentID).Scan(&sequence) if errors.Is(err, pgx.ErrNoRows) { var same bool err = tx.QueryRow(ctx, ` SELECT sequence::text,ciphertext=$5 AND attachment_id IS NOT DISTINCT FROM $6::uuid FROM group_messages WHERE group_id=$1 AND epoch_id=$2 AND sender_device=$3 AND message_id=$4 `, group, message.Epoch, device, message.ID, message.Wire, message.AttachmentID).Scan(&sequence, &same) if errors.Is(err, pgx.ErrNoRows) || err == nil && !same { return "", ErrVersion } } if err != nil { return "", err } return sequence, tx.Commit(ctx) } func (s *Store) Inbox(ctx context.Context, group, user, device string, after int64) ([]Message, error) { tx, err := s.db.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.RepeatableRead, AccessMode: pgx.ReadOnly}) if err != nil { return nil, err } defer tx.Rollback(ctx) if err = readAccess(ctx, tx, group, user, device); err != nil { return nil, err } rows, err := tx.Query(ctx, ` SELECT x.sequence::text,x.epoch_id,x.message_id,x.sender_device,x.ciphertext,x.created_at,x.attachment_id FROM group_messages x JOIN group_epochs g ON g.group_id=x.group_id AND g.id=x.epoch_id JOIN group_epoch_devices e ON e.group_id=g.group_id AND e.epoch_id=g.id AND e.device_id=$3 JOIN group_members m ON m.group_id=x.group_id AND m.user_id=$2 AND m.state='active' JOIN devices d ON d.id=$3 AND d.user_id=m.user_id AND d.revoked_at IS NULL WHERE x.group_id=$1 AND x.sequence>$4 AND g.membership_version>=m.joined_version ORDER BY x.sequence LIMIT 64 `, group, user, device, after) if err != nil { return nil, err } defer rows.Close() result := make([]Message, 0) for rows.Next() { var m Message if err := rows.Scan(&m.Sequence, &m.Epoch, &m.ID, &m.Sender, &m.Wire, &m.CreatedAt, &m.AttachmentID); err != nil { return nil, err } result = append(result, m) } if err = rows.Err(); err != nil { return nil, err } return result, tx.Commit(ctx) } func readAccess(ctx context.Context, tx pgx.Tx, group, user, device string) error { var ok bool err := tx.QueryRow(ctx, ` SELECT EXISTS(SELECT 1 FROM group_members m JOIN devices d ON d.user_id=m.user_id WHERE m.group_id=$1 AND m.user_id=$2 AND m.state='active' AND d.id=$3 AND d.revoked_at IS NULL) `, group, user, device).Scan(&ok) if err == nil && !ok { return ErrUnavailable } return err } func (s *Store) Epochs(ctx context.Context, group, user, device string) ([]AvailableEpoch, error) { tx, err := s.db.BeginTx(ctx, pgx.TxOptions{IsoLevel: pgx.RepeatableRead, AccessMode: pgx.ReadOnly}) if err != nil { return nil, err } defer tx.Rollback(ctx) if err = readAccess(ctx, tx, group, user, device); err != nil { return nil, err } rows, err := tx.Query(ctx, ` SELECT e.id,e.membership_version::text,e.creator_device,d.welcome, phase.current, ARRAY(SELECT x.device_id::text FROM group_epoch_devices x WHERE x.group_id=e.group_id AND x.epoch_id=e.id ORDER BY x.device_id) FROM group_epochs e JOIN chat_groups g ON g.id=e.group_id LEFT JOIN group_epoch_devices d ON d.group_id=e.group_id AND d.epoch_id=e.id AND d.device_id=$3 JOIN group_members m ON m.group_id=e.group_id AND m.user_id=$2 CROSS JOIN LATERAL ( SELECT e.membership_version=g.membership_version AND e.retired_at IS NULL AND NOT EXISTS ( SELECT 1 FROM group_epoch_devices x JOIN devices bound ON bound.id=x.device_id WHERE x.group_id=e.group_id AND x.epoch_id=e.id AND bound.revoked_at IS NOT NULL ) AS current ) phase WHERE e.group_id=$1 AND e.membership_version>=m.joined_version AND (d.device_id IS NOT NULL OR phase.current) ORDER BY e.created_at DESC,e.id LIMIT 200 `, group, user, device) if err != nil { return nil, err } defer rows.Close() result := make([]AvailableEpoch, 0) for rows.Next() { var e AvailableEpoch if err = rows.Scan(&e.ID, &e.Version, &e.Creator, &e.Welcome, &e.Current, &e.Roster); err != nil { return nil, err } result = append(result, e) } if err = rows.Err(); err != nil { return nil, err } return result, tx.Commit(ctx) } func (s *Store) Cleanup(ctx context.Context, retention time.Duration) error { cutoff := time.Now().Add(-retention) tx, err := s.db.Begin(ctx) if err != nil { return err } defer tx.Rollback(ctx) if _, err = tx.Exec(ctx, "DELETE FROM group_messages WHERE created_at<$1", cutoff); err != nil { return err } if _, err = tx.Exec(ctx, ` DELETE FROM group_attachments a WHERE created_at<$1 AND NOT EXISTS ( SELECT 1 FROM group_messages m WHERE m.group_id=a.group_id AND m.attachment_id=a.id ) `, cutoff); err != nil { return err } // Keep the current epoch and any old epoch with retained application messages. _, err = tx.Exec(ctx, ` DELETE FROM group_epochs e USING chat_groups g WHERE e.group_id=g.id AND (e.membership_version