@hyxf/pairdrop 0.0.0-stage → 0.0.0

package/dist-server/features/rooms/room-manager.js

@@ -0,0 +1,113 @@
+/** Owns room membership and the peer notifications caused by membership changes. */
+export default class RoomManager {
+    send;
+    rooms = Object.create(null);
+    constructor(send) {
+        this.send = send;
+    }
+    hasRoom(roomId) {
+        return Boolean(this.rooms[roomId]);
+    }
+    getPeer(roomId, peerId) {
+        return this.rooms[roomId]?.[peerId];
+    }
+    getPeers(roomId) {
+        return Object.values(this.rooms[roomId] ?? {});
+    }
+    clearSecretRoom(roomSecret) {
+        for (const peer of this.getPeers(roomSecret))
+            peer.removeRoomSecret(roomSecret);
+        delete this.rooms[roomSecret];
+    }
+    joinIpRoom(peer) {
+        this.joinRoom(peer, 'ip', peer.ip);
+    }
+    joinSecretRoom(peer, roomSecret) {
+        this.joinRoom(peer, 'secret', roomSecret);
+        peer.addRoomSecret(roomSecret);
+    }
+    leaveIpRoom(peer, disconnect = false) {
+        this.leaveRoom(peer, 'ip', peer.ip, disconnect);
+    }
+    leaveSecretRoom(peer, roomSecret, disconnect = false) {
+        this.leaveRoom(peer, 'secret', roomSecret, disconnect);
+        peer.removeRoomSecret(roomSecret);
+    }
+    joinSecretRooms(peer, roomSecrets) {
+        for (const roomSecret of roomSecrets)
+            this.joinSecretRoom(peer, roomSecret);
+    }
+    leaveAllSecretRooms(peer, disconnect = false) {
+        for (const roomSecret of [...peer.roomSecrets]) {
+            this.leaveSecretRoom(peer, roomSecret, disconnect);
+        }
+    }
+    notifyDisplayNameChanged(peer) {
+        const recipients = new Set();
+        for (const roomId of [peer.ip, ...peer.roomSecrets]) {
+            const room = this.rooms[roomId];
+            if (room?.[peer.id] !== peer)
+                continue;
+            for (const otherPeer of Object.values(room)) {
+                if (otherPeer !== peer)
+                    recipients.add(otherPeer);
+            }
+        }
+        for (const recipient of recipients) {
+            this.send(recipient, {
+                type: 'display-name-changed',
+                sender: { id: peer.id },
+                displayName: peer.name.displayName,
+            });
+        }
+    }
+    joinRoom(peer, roomType, roomId) {
+        const room = this.rooms[roomId];
+        if (room?.[peer.id]) {
+            // Avoid emitting peer-left after peer-joined during a reconnect.
+            this.leaveRoom(peer, roomType, roomId);
+        }
+        const targetRoom = (this.rooms[roomId] ??= Object.create(null));
+        targetRoom[peer.id] = peer;
+        this.notifyPeers(peer, roomType, roomId);
+    }
+    leaveRoom(peer, roomType, roomId, disconnect = false) {
+        const room = this.rooms[roomId];
+        if (!room?.[peer.id])
+            return;
+        delete room[peer.id];
+        if (Object.keys(room).length === 0) {
+            delete this.rooms[roomId];
+            return;
+        }
+        for (const otherPeer of Object.values(room)) {
+            this.send(otherPeer, {
+                type: 'peer-left',
+                peerId: peer.id,
+                roomType,
+                roomId,
+                disconnect,
+            });
+        }
+    }
+    notifyPeers(peer, roomType, roomId) {
+        const room = this.rooms[roomId];
+        if (!room)
+            return;
+        const otherPeers = Object.values(room).filter((otherPeer) => otherPeer.id !== peer.id);
+        for (const otherPeer of otherPeers) {
+            this.send(otherPeer, {
+                type: 'peer-joined',
+                peer: peer.getInfo(),
+                roomType,
+                roomId,
+            });
+        }
+        this.send(peer, {
+            type: 'peers',
+            peers: otherPeers.map((otherPeer) => otherPeer.getInfo()),
+            roomType,
+            roomId,
+        });
+    }
+}

package/dist-server/features/signaling/peer.js

@@ -0,0 +1,202 @@
+import crypto from 'crypto';
+import { isIP } from 'node:net';
+import parser from 'ua-parser-js';
+import { animals, colors, uniqueNamesGenerator } from 'unique-names-generator';
+import { cyrb53, hasher } from '../../shared/helper.js';
+export default class Peer {
+    conf;
+    socket;
+    ip = '';
+    id = '';
+    rtcSupported = false;
+    directPairingSupported = false;
+    name;
+    requestRate = 0;
+    roomSecrets = [];
+    pairKey = null;
+    constructor(socket, request, conf) {
+        this.conf = conf;
+        // set socket
+        this.socket = socket;
+        // set remote ip
+        this._setIP(request);
+        // set peer id
+        this._setPeerId(request);
+        // is WebRTC supported
+        this._setRtcSupported(request);
+        this.directPairingSupported =
+            new URL(String(request.url), 'http://server').searchParams.get('direct_pairing_version') === '2';
+        // set name
+        this._setName(request);
+        this.requestRate = 0;
+        this.roomSecrets = [];
+        this.pairKey = null;
+    }
+    rateLimitReached() {
+        // rate limit implementation: max 10 attempts every 10s
+        if (this.requestRate >= 10) {
+            return true;
+        }
+        this.requestRate += 1;
+        setTimeout(() => (this.requestRate -= 1), 10000);
+        return false;
+    }
+    _setIP(request) {
+        const remoteAddress = request.socket.remoteAddress ?? '';
+        const normalizedRemote = remoteAddress.replace(/^::ffff:/, '');
+        this.ip = normalizedRemote;
+        if (this.conf.trustedProxyIps.includes(normalizedRemote)) {
+            const forwarded = request.headers['x-forwarded-for'];
+            if (typeof forwarded === 'string') {
+                const chain = forwarded
+                    .split(',')
+                    .map((address) => address.trim().replace(/^::ffff:/, ''));
+                if (chain.length && chain.every((address) => isIP(address))) {
+                    this.ip =
+                        [...chain]
+                            .reverse()
+                            .find((address) => !this.conf.trustedProxyIps.includes(address)) ?? chain[0];
+                }
+            }
+            else {
+                const cloudflareIp = request.headers['cf-connecting-ip'];
+                if (typeof cloudflareIp === 'string' && isIP(cloudflareIp))
+                    this.ip = cloudflareIp;
+            }
+        }
+        // remove the prefix used for IPv4-translated addresses
+        if (this.ip.substring(0, 7) === '::ffff:') {
+            this.ip = this.ip.substring(7);
+        }
+        let ipv6_was_localized = false;
+        if (this.conf.ipv6Localize && this.ip.includes(':')) {
+            this.ip = this.ip.split(':', this.conf.ipv6Localize).join(':');
+            ipv6_was_localized = true;
+        }
+        if (this.conf.debugMode) {
+            console.debug('\n');
+            console.debug('----DEBUGGING-PEER-IP-START----');
+            console.debug('remoteAddress:', request.connection.remoteAddress);
+            console.debug('x-forwarded-for:', request.headers['x-forwarded-for']);
+            console.debug('cf-connecting-ip:', request.headers['cf-connecting-ip']);
+            if (ipv6_was_localized) {
+                console.debug('IPv6 client IP was localized to', this.conf.ipv6Localize, Number(this.conf.ipv6Localize) > 1 ? 'segments' : 'segment');
+            }
+            console.debug('PairDrop uses:', this.ip);
+            console.debug('IP is private:', this.ipIsPrivate(this.ip));
+            console.debug("if IP is private, '127.0.0.1' is used instead");
+            console.debug('----DEBUGGING-PEER-IP-END----');
+        }
+        // IPv4 and IPv6 use different values to refer to localhost
+        // put all peers on the same network as the server into the same room as well
+        if (this.ip === '::1' || this.ipIsPrivate(this.ip)) {
+            this.ip = '127.0.0.1';
+        }
+    }
+    ipIsPrivate(ip) {
+        // if ip is IPv4
+        if (!ip.includes(':')) {
+            //         10.0.0.0 - 10.255.255.255        ||   172.16.0.0 - 172.31.255.255                          ||    192.168.0.0 - 192.168.255.255
+            return (/^(10)\.(.*)\.(.*)\.(.*)$/.test(ip) ||
+                /^(172)\.(1[6-9]|2[0-9]|3[0-1])\.(.*)\.(.*)$/.test(ip) ||
+                /^(192)\.(168)\.(.*)\.(.*)$/.test(ip));
+        }
+        // else: ip is IPv6
+        const firstWord = ip.split(':').find((el) => !!el); //get first not empty word
+        if (/^fe[c-f][0-f]$/.test(String(firstWord))) {
+            // The original IPv6 Site Local addresses (fec0::/10) are deprecated. Range: fec0 - feff
+            return true;
+        }
+        // These days Unique Local Addresses (ULA) are used in place of Site Local.
+        // Range: fc00 - fcff
+        else if (/^fc[0-f]{2}$/.test(String(firstWord))) {
+            return true;
+        }
+        // Range: fd00 - fcff
+        else if (/^fd[0-f]{2}$/.test(String(firstWord))) {
+            return true;
+        }
+        // Link local addresses (prefixed with fe80) are not routable
+        else if (firstWord === 'fe80') {
+            return true;
+        }
+        // Discard Prefix
+        else if (firstWord === '100') {
+            return true;
+        }
+        // Any other IP address is not Unique Local Address (ULA)
+        return false;
+    }
+    _setPeerId(request) {
+        const searchParams = new URL(String(request.url), 'http://server')
+            .searchParams;
+        const peerId = searchParams.get('peer_id');
+        const peerIdHash = searchParams.get('peer_id_hash');
+        if (peerId &&
+            Peer.isValidUuid(peerId) &&
+            this.isPeerIdHashValid(peerId, peerIdHash)) {
+            this.id = peerId;
+        }
+        else {
+            this.id = crypto.randomUUID();
+        }
+    }
+    _setRtcSupported(request) {
+        const searchParams = new URL(String(request.url), 'http://server')
+            .searchParams;
+        this.rtcSupported = searchParams.get('webrtc_supported') === 'true';
+    }
+    _setName(req) {
+        const ua = parser(req.headers['user-agent']);
+        let deviceName = '';
+        if (ua.os && ua.os.name) {
+            deviceName = ua.os.name.replace('Mac OS', 'Mac') + ' ';
+        }
+        if (ua.device.model) {
+            deviceName += ua.device.model;
+        }
+        else {
+            deviceName += ua.browser.name;
+        }
+        if (!deviceName) {
+            deviceName = 'Unknown Device';
+        }
+        const displayName = uniqueNamesGenerator({
+            length: 2,
+            separator: ' ',
+            dictionaries: [colors, animals],
+            style: 'capital',
+            seed: cyrb53(this.id),
+        });
+        this.name = {
+            model: ua.device.model,
+            os: ua.os.name,
+            browser: ua.browser.name,
+            type: ua.device.type,
+            deviceName,
+            displayName,
+        };
+    }
+    getInfo() {
+        return {
+            id: this.id,
+            name: this.name,
+            rtcSupported: this.rtcSupported,
+            directPairingSupported: this.directPairingSupported,
+        };
+    }
+    static isValidUuid(uuid) {
+        return /^([0-9]|[a-f]){8}-(([0-9]|[a-f]){4}-){3}([0-9]|[a-f]){12}$/.test(uuid);
+    }
+    isPeerIdHashValid(peerId, peerIdHash) {
+        return peerIdHash === hasher.hashCodeSalted(peerId);
+    }
+    addRoomSecret(roomSecret) {
+        if (!this.roomSecrets.includes(roomSecret)) {
+            this.roomSecrets.push(roomSecret);
+        }
+    }
+    removeRoomSecret(roomSecret) {
+        this.roomSecrets = this.roomSecrets.filter((secret) => secret !== roomSecret);
+    }
+}

package/dist-server/features/signaling/ws-server.js

@@ -0,0 +1,210 @@
+import { WebSocket, WebSocketServer } from 'ws';
+import Peer from './peer.js';
+import { hasher } from '../../shared/helper.js';
+import RoomManager, {} from '../rooms/room-manager.js';
+import PairingManager from '../pairing/pairing-manager.js';
+function isServerMessage(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+export default class PairDropWsServer {
+    _conf;
+    _roomManager;
+    _pairingManager;
+    _keepAliveTimers = {};
+    _wss;
+    constructor(server, conf) {
+        this._conf = conf;
+        this._roomManager = new RoomManager((peer, message) => this._send(peer, message));
+        this._pairingManager = new PairingManager(this._roomManager, (peer, message) => this._send(peer, message));
+        this._wss = new WebSocketServer({ server, maxPayload: 1024 * 1024 });
+        this._wss.on('connection', (socket, request) => {
+            const version = new URL(request.url ?? '/', 'http://localhost').searchParams.get('protocol_version');
+            if (version !== '2') {
+                socket.close(1002, 'Open the updated PairDrop page');
+                return;
+            }
+            this._onConnection(new Peer(socket, request, conf));
+        });
+    }
+    _onConnection(peer) {
+        const previous = this._keepAliveTimers[peer.id]?.peer;
+        if (previous && previous !== peer)
+            this._disconnect(previous);
+        peer.socket.on('message', (message) => this._onMessage(peer, message));
+        peer.socket.on('close', () => this._disconnect(peer));
+        peer.socket.onerror = (error) => console.error(error);
+        this._keepAlive(peer);
+        this._send(peer, {
+            type: 'ws-config',
+            wsConfig: {
+                rtcConfig: this._conf.rtcConfig,
+                wsFallback: this._conf.wsFallback,
+                protocolVersion: 2,
+                directPairingVersion: 2,
+            },
+        });
+        // send displayName
+        this._send(peer, {
+            type: 'display-name',
+            displayName: peer.name.displayName,
+            deviceName: peer.name.deviceName,
+            peerId: peer.id,
+            peerIdHash: hasher.hashCodeSalted(peer.id),
+        });
+    }
+    _onMessage(sender, raw) {
+        let message;
+        try {
+            const parsed = JSON.parse(raw.toString());
+            if (!isServerMessage(parsed))
+                return;
+            message = parsed;
+        }
+        catch {
+            console.warn('WS: Received JSON is malformed');
+            return;
+        }
+        switch (message.type) {
+            case 'disconnect':
+                this._disconnect(sender);
+                break;
+            case 'pong':
+                this._setKeepAliveTimerToNow(sender);
+                break;
+            case 'join-ip-room':
+                this._roomManager.joinIpRoom(sender);
+                break;
+            case 'room-secrets':
+                this._pairingManager.joinSecretRooms(sender, message);
+                break;
+            case 'room-secrets-deleted':
+                this._pairingManager.deleteSecretRooms(sender, message);
+                break;
+            case 'pair-device-initiate':
+                this._pairingManager.initiate(sender);
+                break;
+            case 'pair-device-join':
+                this._pairingManager.join(sender, message);
+                break;
+            case 'pair-device-cancel':
+                this._pairingManager.cancel(sender);
+                break;
+            case 'pair-request':
+                this._pairingManager.request(sender, message);
+                break;
+            case 'pair-request-respond':
+                this._pairingManager.respond(sender, message);
+                break;
+            case 'pair-request-storage':
+                this._pairingManager.confirmStorage(sender, message);
+                break;
+            case 'pair-request-cancel':
+                this._pairingManager.cancelRequest(sender, message);
+                break;
+            case 'regenerate-room-secret':
+                this._pairingManager.regenerateSecret(sender, message);
+                break;
+            case 'signal':
+                this._signalAndRelay(sender, message);
+                break;
+            case 'display-name-changed': {
+                if (typeof message.displayName !== 'string')
+                    break;
+                const displayName = message.displayName
+                    .trim()
+                    .replace(/[\r\n]+/g, ' ')
+                    .slice(0, 32);
+                if (!displayName)
+                    break;
+                sender.name.displayName = displayName;
+                this._roomManager.notifyDisplayNameChanged(sender);
+                break;
+            }
+            case 'request':
+            case 'header':
+            case 'partition':
+            case 'partition-received':
+            case 'files-transfer-response':
+            case 'files-transfer-cancel':
+            case 'file-transfer-complete':
+            case 'file-checksum':
+            case 'message-transfer-complete':
+            case 'text':
+            case 'ws-chunk':
+                // relay ws-fallback
+                if (this._conf.wsFallback) {
+                    this._signalAndRelay(sender, message);
+                }
+                else {
+                    console.log('Websocket fallback is not activated on this instance.');
+                }
+        }
+    }
+    _signalAndRelay(sender, message) {
+        if (message.roomType !== 'secret')
+            return;
+        const room = message.roomId;
+        if (typeof room !== 'string' || typeof message.to !== 'string')
+            return;
+        // relay message to recipient
+        if (Peer.isValidUuid(message.to) &&
+            this._roomManager.getPeer(room, sender.id) === sender) {
+            const recipient = this._roomManager.getPeer(room, message.to);
+            const payload = { ...message };
+            delete payload.to;
+            this._send(recipient, {
+                ...payload,
+                sender: { id: sender.id, rtcSupported: sender.rtcSupported },
+            });
+        }
+    }
+    _disconnect(sender) {
+        if (this._keepAliveTimers[sender.id]?.peer !== sender)
+            return;
+        this._pairingManager.removePeer(sender);
+        this._cancelKeepAlive(sender);
+        delete this._keepAliveTimers[sender.id];
+        this._roomManager.leaveIpRoom(sender, true);
+        this._roomManager.leaveAllSecretRooms(sender, true);
+        sender.socket.terminate();
+    }
+    _send(peer, message) {
+        if (!peer)
+            return;
+        if (peer.socket.readyState !== WebSocket.OPEN)
+            return;
+        if (peer.socket.bufferedAmount > 4 * 1024 * 1024) {
+            console.warn('WS: Disconnecting a peer with a full send buffer');
+            peer.socket.terminate();
+            return;
+        }
+        peer.socket.send(JSON.stringify(message));
+    }
+    _keepAlive(peer) {
+        this._cancelKeepAlive(peer);
+        const timeout = 1000;
+        if (!this._keepAliveTimers[peer.id]) {
+            this._keepAliveTimers[peer.id] = {
+                lastBeat: Date.now(),
+                peer,
+            };
+        }
+        if (Date.now() - this._keepAliveTimers[peer.id].lastBeat > 5 * timeout) {
+            // Disconnect peer if unresponsive for 10s
+            this._disconnect(peer);
+            return;
+        }
+        this._send(peer, { type: 'ping' });
+        this._keepAliveTimers[peer.id].timer = setTimeout(() => this._keepAlive(peer), timeout);
+    }
+    _cancelKeepAlive(peer) {
+        if (this._keepAliveTimers[peer.id]?.timer) {
+            clearTimeout(this._keepAliveTimers[peer.id].timer);
+        }
+    }
+    _setKeepAliveTimerToNow(peer) {
+        if (this._keepAliveTimers[peer.id]?.lastBeat) {
+            this._keepAliveTimers[peer.id].lastBeat = Date.now();
+        }
+    }
+}

package/dist-server/index.js

@@ -0,0 +1,81 @@
+import { spawn } from 'node:child_process';
+import { loadConfig } from './config.js';
+import PairDropServer from './server.js';
+import PairDropWsServer from './features/signaling/ws-server.js';
+let autoRestartEnabled = false;
+let fatalExitStarted = false;
+function exitAfterFatal(error) {
+    if (fatalExitStarted)
+        return;
+    fatalExitStarted = true;
+    console.error(error);
+    if (autoRestartEnabled) {
+        const args = process.argv.slice(1);
+        process.once('exit', () => {
+            const child = spawn(process.execPath, args, {
+                cwd: process.cwd(),
+                detached: true,
+                stdio: 'inherit',
+            });
+            child.unref();
+        });
+    }
+    process.exit(1);
+}
+function registerProcessHandlers() {
+    process.on('SIGINT', () => {
+        console.info('SIGINT received, exiting...');
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        console.info('SIGTERM received, exiting...');
+        process.exit(0);
+    });
+    process.on('uncaughtException', (error, origin) => {
+        console.error('Uncaught exception from', origin);
+        exitAfterFatal(error);
+    });
+    process.on('unhandledRejection', (reason) => {
+        console.error('Unhandled rejection');
+        exitAfterFatal(reason);
+    });
+}
+async function start() {
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch (error) {
+        console.error(error);
+        process.exitCode = 1;
+        return;
+    }
+    autoRestartEnabled = config.autoStart;
+    const httpServer = new PairDropServer(config);
+    if (!config.signalingServer) {
+        new PairDropWsServer(httpServer.server, config);
+    }
+    else {
+        console.log('This instance does not include a signaling server. Clients on this instance connect to:', config.signalingServer);
+    }
+    try {
+        await httpServer.start();
+    }
+    catch (error) {
+        console.error(error);
+        // TYPE-EXCEPTION: 保留原有异常属性读取 | 改为守卫会改变非对象异常的处理
+        if (error.code === 'EADDRINUSE') {
+            console.info('The port is already in use; exiting without restarting the process.');
+        }
+        process.exitCode = 1;
+        return;
+    }
+    console.log('\nPairDrop is running on port', config.port);
+    process.send?.({
+        type: 'ready',
+        port: config.port,
+        wsFallback: config.wsFallback,
+    });
+}
+registerProcessHandlers();
+void start();

package/dist-server/server.js

@@ -0,0 +1,75 @@
+import fastify, {} from 'fastify';
+import fastifyRateLimit from '@fastify/rate-limit';
+import fastifyStatic from '@fastify/static';
+import { fileURLToPath } from 'node:url';
+import { networkInterfaces } from 'node:os';
+import path, { dirname } from 'node:path';
+function getLanAddresses() {
+    const addresses = Object.values(networkInterfaces()).flatMap((interfaces) => (interfaces ?? [])
+        .filter(({ family, internal, address }) => {
+        if (internal || family !== 'IPv4')
+            return false;
+        const octets = address.split('.').map(Number);
+        return (octets.length === 4 &&
+            (octets[0] === 10 ||
+                (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31) ||
+                (octets[0] === 192 && octets[1] === 168) ||
+                (octets[0] === 100 && octets[1] >= 64 && octets[1] <= 127)));
+    })
+        .map(({ address }) => address));
+    return [...new Set(addresses)];
+}
+export default class PairDropServer {
+    app;
+    server;
+    config;
+    constructor(conf) {
+        this.config = conf;
+        this.app = fastify({
+            logger: {
+                level: process.env.LOG_LEVEL ||
+                    (process.env.NODE_ENV === 'production' ? 'warn' : 'info'),
+            },
+            trustProxy: (address) => conf.trustedProxyIps.includes(address.replace(/^::ffff:/, '')),
+        });
+        this.server = this.app.server;
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const publicPathAbs = path.resolve(__dirname, '../dist');
+        if (conf.rateLimit) {
+            this.app.register(fastifyRateLimit, {
+                max: 1000,
+                timeWindow: 5 * 60 * 1000,
+            });
+        }
+        this.app.register(fastifyStatic, { root: publicPathAbs });
+        if (conf.debugMode && conf.rateLimit) {
+            console.debug('\n');
+            console.debug('----DEBUG RATE_LIMIT----');
+            console.debug("To find out the correct value for '/ip', ensure the returned IP-address is the IP-address of your client.");
+            console.debug('See https://github.com/fastify/fastify-rate-limit#configuration for more info');
+            this.app.get('/ip', async (request) => request.ip);
+        }
+        this.app.get('/config', async () => ({
+            signalingServer: conf.signalingServer,
+            buttons: conf.buttons,
+            lanAddresses: conf.localhostOnly ? [] : getLanAddresses(),
+        }));
+        this.app.setErrorHandler((error, _request, reply) => {
+            this.app.log.error(error);
+            // TYPE-EXCEPTION: Fastify 错误在此具有 statusCode | 校验并替换异常会改变原有错误处理
+            const statusCode = error.statusCode ?? 500;
+            void reply.status(statusCode).send({ error: 'Internal Server Error' });
+        });
+    }
+    async start() {
+        await this.app.listen({
+            port: this.config.port,
+            ...(this.config.localhostOnly
+                ? { host: '127.0.0.1' }
+                : process.env.NODE_ENV === 'production'
+                    ? { host: '0.0.0.0' }
+                    : {}),
+        });
+    }
+}