PasteFerry (隔空贴): clipboard and file sync across macOS, Windows and Linux. Direct-first, end-to-end encrypted. Optional official access: no server to host. Independent self-hosting remains available.
Dart airdrop-alternativeclipboardclipboard-sharingclipboard-synccopy-pastecross-platformend-to-end-encryptionfile-syncfile-transferfluttergolanglinuxmacosnat-traversalp2pself-hostedtailscaleuniversal-clipboardwebrtcwindows
package signal
import (
"context"
"crypto/ed25519"
"crypto/rand"
"errors"
"fmt"
"log/slog"
"net/http"
"time"
"github.com/coder/websocket"
"google.golang.org/protobuf/proto"
"github.com/baiyuze/pasteferry/proto/deviceid"
pb "github.com/baiyuze/pasteferry/proto/gen/pasteferry/v1"
"github.com/baiyuze/pasteferry/server/pairing"
)
const (
// 信令消息都很小(最大的是 SDP,通常几 KB)
maxMessageBytes = 256 << 10
handshakeTimeout = 15 * time.Second
writeTimeout = 10 * time.Second
// 心跳:及时发现半开连接,否则对端会一直显示"在线"
pingInterval = 30 * time.Second
pongTimeout = 60 * time.Second
)
type Server struct {
hub *Hub
broker *pairing.Broker
iceFunc func(deviceID string) []*pb.IceServer
log *slog.Logger
}
type Options struct {
// ICEServers 为每个设备签发 STUN/TURN 配置(含短期 TURN 凭证)
ICEServers func(deviceID string) []*pb.IceServer
Logger *slog.Logger
}
func NewServer(opts Options) *Server {
log := opts.Logger
if log == nil {
log = slog.Default()
}
ice := opts.ICEServers
if ice == nil {
ice = func(string) []*pb.IceServer { return nil }
}
return &Server{
hub: NewHub(),
broker: pairing.NewBroker(),
iceFunc: ice,
log: log,
}
}
func (s *Server) Hub() *Hub { return s.hub }
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
ws, err := websocket.Accept(w, r, &websocket.AcceptOptions{
// 客户端是桌面应用而非浏览器,不存在跨站请求伪造的场景
InsecureSkipVerify: true,
})
if err != nil {
s.log.Warn("websocket 握手失败", "err", err, "remote", r.RemoteAddr)
return
}
// HTTP hijacking transfers socket ownership to us. Release it even when
// the peer disappears without completing a WebSocket close handshake.
defer ws.CloseNow()
ws.SetReadLimit(maxMessageBytes)
ctx, cancel := context.WithCancel(r.Context())
defer cancel()
conn, err := s.handshake(ctx, ws)
if err != nil {
s.log.Warn("设备认证失败", "err", err, "remote", r.RemoteAddr)
ws.Close(websocket.StatusPolicyViolation, "认证失败")
return
}
s.log.Info("设备已连接",
"device", conn.DeviceID, "name", conn.DeviceName,
"platform", conn.Platform, "在线数", s.hub.Count())
defer func() {
if s.hub.Unregister(conn) {
s.broadcastPresence(ctx, conn.DeviceID, false)
s.log.Info("设备已断开", "device", conn.DeviceID, "在线数", s.hub.Count())
}
}()
// 出站泵:所有写操作集中在这一个 goroutine,websocket 不支持并发写
go s.writePump(ctx, ws, conn)
s.readLoop(ctx, ws, conn)
}
// handshake 完成「证明你持有这把私钥」的挑战应答。
//
// 服务器不维护用户表,所以认证是自证式的:设备提交公钥和对 challenge 的签名,
// 服务器验签并校验 device_id 确由该公钥派生。这挡住了冒用他人 device_id 的连接。
func (s *Server) handshake(ctx context.Context, ws *websocket.Conn) (*Conn, error) {
ctx, cancel := context.WithTimeout(ctx, handshakeTimeout)
defer cancel()
challenge := make([]byte, 32)
if _, err := rand.Read(challenge); err != nil {
return nil, err
}
hello := &pb.ServerEnvelope{
Payload: &pb.ServerEnvelope_Hello{Hello: &pb.ServerHello{
Challenge: challenge,
ServerTimeUnix: time.Now().Unix(),
}},
}
if err := writeProto(ctx, ws, hello); err != nil {
return nil, fmt.Errorf("发送 ServerHello: %w", err)
}
var env pb.ClientEnvelope
if err := readProto(ctx, ws, &env); err != nil {
return nil, fmt.Errorf("读取 ClientHello: %w", err)
}
ch := env.GetHello()
if ch == nil {
return nil, errors.New("首条消息必须是 ClientHello")
}
pub := ed25519.PublicKey(ch.GetPublicKey())
if len(pub) != ed25519.PublicKeySize {
return nil, errors.New("公钥长度不合法")
}
if !ed25519.Verify(pub, challenge, ch.GetSignature()) {
return nil, errors.New("challenge 签名验证失败")
}
if !deviceid.Valid(ch.GetDeviceId(), pub) {
return nil, errors.New("device_id 与公钥不匹配")
}
conn := &Conn{
DeviceID: ch.GetDeviceId(),
DeviceName: ch.GetDeviceName(),
Platform: ch.GetPlatform(),
PublicKey: pub,
send: make(chan []byte, 32),
watching: make(map[string]struct{}, len(ch.GetPairedDeviceIds())),
}
for _, p := range ch.GetPairedDeviceIds() {
conn.watching[p] = struct{}{}
}
if replaced := s.hub.Register(conn); replaced != nil {
s.log.Info("顶替同设备的旧连接", "device", conn.DeviceID)
close(replaced.send)
}
// ICE 配置含按设备签发的短期 TURN 凭证,必须等认证通过后才能下发
if servers := s.iceFunc(conn.DeviceID); len(servers) > 0 {
conn.Send(mustMarshal(&pb.ServerEnvelope{
Payload: &pb.ServerEnvelope_IceConfig{
IceConfig: &pb.IceConfig{IceServers: servers},
},
}))
}
// 先告诉新连接:它关心的对端里谁在线
s.sendCurrentPresence(conn)
// 再告诉关心它的对端:我上线了
s.broadcastPresence(ctx, conn.DeviceID, true)
return conn, nil
}
// sendCurrentPresence 把「该连接所关注的对端中当前在线的那些」推给它。
func (s *Server) sendCurrentPresence(conn *Conn) {
for _, peer := range s.hub.PresenceFor(conn.DeviceID) {
conn.Send(mustMarshal(&pb.ServerEnvelope{
Payload: &pb.ServerEnvelope_Presence{Presence: &pb.PeerPresence{
DeviceId: peer, Online: true,
}},
}))
}
}
func (s *Server) readLoop(ctx context.Context, ws *websocket.Conn, conn *Conn) {
for {
var env pb.ClientEnvelope
if err := readProto(ctx, ws, &env); err != nil {
if ctx.Err() == nil && websocket.CloseStatus(err) == -1 {
s.log.Debug("读取中断", "device", conn.DeviceID, "err", err)
}
return
}
switch p := env.GetPayload().(type) {
case *pb.ClientEnvelope_Forward:
s.forward(conn, p.Forward)
case *pb.ClientEnvelope_PairingCreate:
s.handlePairingCreate(ctx, conn, p.PairingCreate)
case *pb.ClientEnvelope_PairingRedeem:
s.handlePairingRedeem(conn, p.PairingRedeem)
case *pb.ClientEnvelope_Hello:
// 重复的 Hello 用来刷新关注列表(刚完成配对时会发)
s.hub.SetWatching(conn.DeviceID, p.Hello.GetPairedDeviceIds())
// 必须补发一次当前在线状态:presence 只在设备上下线的瞬间广播,
// 新加入关注列表的对端此刻可能早已在线,不补发的话本端会一直显示它离线。
s.sendCurrentPresence(conn)
// 同理,对端也可能正关注着本设备却错过了上线广播
s.broadcastPresence(ctx, conn.DeviceID, true)
default:
s.sendError(conn, "unknown_message", "未知的消息类型")
}
}
}
// forward 把带签名的信令原样转发。
//
// 服务器不验签也不解析内容——验签是接收方的事(它有对端公钥,服务器没有)。
// 服务器只确保 from_device_id 不能伪造:强制改写为连接自身的身份。
func (s *Server) forward(from *Conn, signed *pb.Signed) {
if signed == nil {
return
}
// 防止 A 冒充 B 向 C 发消息
signed.FromDeviceId = from.DeviceID
var inner pb.SignalMessage
if err := proto.Unmarshal(signed.GetPayload(), &inner); err != nil {
s.sendError(from, "bad_payload", "signal payload 无法解析")
return
}
to := inner.GetToDeviceId()
if to == "" {
s.sendError(from, "missing_target", "缺少 to_device_id")
return
}
target, ok := s.hub.Get(to)
if !ok {
s.sendError(from, "peer_offline", fmt.Sprintf("对端 %s 不在线", to))
return
}
if !target.Send(mustMarshal(&pb.ServerEnvelope{
Payload: &pb.ServerEnvelope_Forwarded{Forwarded: signed},
})) {
s.log.Warn("转发丢弃:对端出站队列已满", "from", from.DeviceID, "to", to)
}
}
func (s *Server) handlePairingCreate(ctx context.Context, conn *Conn, req *pb.PairingCreateRequest) {
code, expires, redeemed, err := s.broker.Create(pairing.Peer{
DeviceID: conn.DeviceID,
DeviceName: req.GetDeviceName(),
Platform: conn.Platform,
PublicKey: req.GetPublicKey(),
})
if err != nil {
s.sendError(conn, "pairing_create_failed", err.Error())
return
}
conn.Send(mustMarshal(&pb.ServerEnvelope{
Payload: &pb.ServerEnvelope_PairingCreated{PairingCreated: &pb.PairingCreateResponse{
Code: code,
ExpiresAtUnix: expires.Unix(),
}},
}))
// 等待有人兑换。兑换方的信息要回传给发起方,
// 否则发起方拿不到对端公钥,配对只能单向完成。
go func() {
select {
case peer, ok := <-redeemed:
if !ok {
return // 已过期或被取消
}
conn.Send(mustMarshal(&pb.ServerEnvelope{
Payload: &pb.ServerEnvelope_PairingRedeemed{PairingRedeemed: &pb.PairingRedeemed{
PeerDeviceId: peer.DeviceID,
PeerDeviceName: peer.DeviceName,
PeerPlatform: peer.Platform,
PeerPublicKey: peer.PublicKey,
}},
}))
s.log.Info("配对完成", "initiator", conn.DeviceID, "peer", peer.DeviceID)
case <-ctx.Done():
s.broker.Cancel(code)
}
}()
}
func (s *Server) handlePairingRedeem(conn *Conn, req *pb.PairingRedeemRequest) {
initiator, err := s.broker.Redeem(req.GetCode(), pairing.Peer{
DeviceID: conn.DeviceID,
DeviceName: req.GetDeviceName(),
Platform: conn.Platform,
PublicKey: req.GetPublicKey(),
})
if err != nil {
s.sendError(conn, "pairing_redeem_failed", err.Error())
return
}
conn.Send(mustMarshal(&pb.ServerEnvelope{
Payload: &pb.ServerEnvelope_PairingRedeemedResult{
PairingRedeemedResult: &pb.PairingRedeemResponse{
PeerDeviceId: initiator.DeviceID,
PeerDeviceName: initiator.DeviceName,
PeerPlatform: initiator.Platform,
PeerPublicKey: initiator.PublicKey,
},
},
}))
}
func (s *Server) broadcastPresence(_ context.Context, deviceID string, online bool) {
data := mustMarshal(&pb.ServerEnvelope{
Payload: &pb.ServerEnvelope_Presence{Presence: &pb.PeerPresence{
DeviceId: deviceID, Online: online,
}},
})
for _, w := range s.hub.WatchersOf(deviceID) {
w.Send(data)
}
}
func (s *Server) sendError(conn *Conn, code, msg string) {
conn.Send(mustMarshal(&pb.ServerEnvelope{
Payload: &pb.ServerEnvelope_Error{Error: &pb.ServerError{Code: code, Message: msg}},
}))
}
// writePump 独占写端。websocket 连接不允许并发写,所有出站消息都经此串行化。
func (s *Server) writePump(ctx context.Context, ws *websocket.Conn, conn *Conn) {
ping := time.NewTicker(pingInterval)
defer ping.Stop()
for {
select {
case <-ctx.Done():
return
case data, ok := <-conn.send:
if !ok {
ws.Close(websocket.StatusNormalClosure, "连接被顶替")
return
}
wctx, cancel := context.WithTimeout(ctx, writeTimeout)
err := ws.Write(wctx, websocket.MessageBinary, data)
cancel()
if err != nil {
return
}
case <-ping.C:
pctx, cancel := context.WithTimeout(ctx, pongTimeout)
err := ws.Ping(pctx)
cancel()
if err != nil {
s.log.Debug("心跳失败,断开", "device", conn.DeviceID, "err", err)
ws.Close(websocket.StatusGoingAway, "心跳超时")
return
}
}
}
}
// ─────────────────────── proto over websocket ───────────────────────
func readProto(ctx context.Context, ws *websocket.Conn, m proto.Message) error {
typ, data, err := ws.Read(ctx)
if err != nil {
return err
}
if typ != websocket.MessageBinary {
return fmt.Errorf("期望二进制消息,收到 %v", typ)
}
return proto.Unmarshal(data, m)
}
func writeProto(ctx context.Context, ws *websocket.Conn, m proto.Message) error {
data, err := proto.Marshal(m)
if err != nil {
return err
}
return ws.Write(ctx, websocket.MessageBinary, data)
}
// mustMarshal 用于出站信封:这些消息都是本地构造的,
// 序列化失败意味着程序有 bug,不该被静默吞掉。
func mustMarshal(m proto.Message) []byte {
data, err := proto.Marshal(m)
if err != nil {
panic(fmt.Sprintf("序列化出站消息失败: %v", err))
}
return data
}