eufy-security-client 3.8.0 → 4.0.0-dev.31

package/build/p2p/session.js

@@ -18,6 +18,7 @@ const ble_1 = require("./ble");
 const http_1 = require("../http");
 const utils_3 = require("../utils");
 const logging_1 = require("../logging");
+const adts_1 = require("./adts");
 class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
     MAX_RETRIES = 10;
     MAX_COMMAND_RESULT_WAIT = 30 * 1000;
@@ -37,6 +38,11 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
     ESD_DISCONNECT_TIMEOUT = 30 * 1000;
     MAX_STREAM_DATA_WAIT = 5 * 1000;
     RESEND_NOT_ACKNOWLEDGED_COMMAND = 100;
+    streamTimeouts = {
+        streamDataWait: this.MAX_STREAM_DATA_WAIT,
+        audioCodecAnalyze: this.AUDIO_CODEC_ANALYZE_TIMEOUT,
+        expectedSeqNoWait: this.MAX_EXPECTED_SEQNO_WAIT,
+    };
     UDP_RECVBUFFERSIZE_BYTES = 1048576;
     MAX_PAYLOAD_BYTES = 1028;
     MAX_PACKET_BYTES = 1024;
@@ -1240,7 +1246,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                         this.currentMessageState[dataType].waitForSeqNoTimeout = setTimeout(() => {
                             this.endStream(dataType, true);
                             this.currentMessageState[dataType].waitForSeqNoTimeout = undefined;
-                        }, this.MAX_EXPECTED_SEQNO_WAIT);
+                        }, this.streamTimeouts.expectedSeqNoWait);
                     if (!this.currentMessageState[dataType].queuedData.get(message.seqNo)) {
                         this.currentMessageState[dataType].queuedData.set(message.seqNo, message);
                         logging_1.rootP2PLogger.trace(`Received message - DATA ${types_1.P2PDataType[message.type]} - Received not expected sequence, added to the queue for future processing`, {
@@ -1514,24 +1520,36 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                 let return_code = 0;
                 let resultData;
                 if (message.bytesToRead > 0) {
-                    if (message.signCode > 0) {
-                        try {
-                            message.data = (0, utils_1.decryptP2PData)(message.data, this.p2pKey);
+                    if (message.signCode > 0 && message.data.length > 0) {
+                        if (message.data.length % 16 === 0) {
+                            try {
+                                message.data = (0, utils_1.decryptP2PData)(message.data, this.p2pKey);
+                            }
+                            catch (err) {
+                                const error = (0, error_1.ensureError)(err);
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Decrypt Error`, {
+                                    error: (0, utils_3.getError)(error),
+                                    stationSN: this.rawStation.station_sn,
+                                    message: {
+                                        seqNo: message.seqNo,
+                                        channel: message.channel,
+                                        commandType: types_1.CommandType[message.commandId],
+                                        signCode: message.signCode,
+                                        type: message.type,
+                                        dataType: types_1.P2PDataType[message.dataType],
+                                        data: message.data.toString("hex"),
+                                    },
+                                });
+                            }
                         }
-                        catch (err) {
-                            const error = (0, error_1.ensureError)(err);
-                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Decrypt Error`, {
-                                error: (0, utils_3.getError)(error),
+                        else {
+                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Skipping decryption, data not block-aligned`, {
                                 stationSN: this.rawStation.station_sn,
-                                message: {
-                                    seqNo: message.seqNo,
-                                    channel: message.channel,
-                                    commandType: types_1.CommandType[message.commandId],
-                                    signCode: message.signCode,
-                                    type: message.type,
-                                    dataType: types_1.P2PDataType[message.dataType],
-                                    data: message.data.toString("hex"),
-                                },
+                                seqNo: message.seqNo,
+                                commandType: types_1.CommandType[message.commandId],
+                                signCode: message.signCode,
+                                dataLength: message.data.length,
+                                mod16: message.data.length % 16,
                             });
                         }
                     }
@@ -1770,6 +1788,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
     }
     isIFrame(data, isKeyFrame) {
         if (this.rawStation.station_sn.startsWith("T8410") ||
+            this.rawStation.station_sn.startsWith("T8417") ||
             this.rawStation.station_sn.startsWith("T8400") ||
             this.rawStation.station_sn.startsWith("T8401") ||
             this.rawStation.station_sn.startsWith("T8411") ||
@@ -1801,9 +1820,9 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
             clearTimeout(this.currentMessageState[dataType].p2pStreamingTimeout);
         }
         this.currentMessageState[dataType].p2pStreamingTimeout = setTimeout(() => {
-            logging_1.rootP2PLogger.info(`Stopping the station stream for the device ${this.deviceSNs[this.currentMessageState[dataType].p2pStreamChannel]?.sn}, because we haven't received any data for ${this.MAX_STREAM_DATA_WAIT / 1000} seconds`);
+            logging_1.rootP2PLogger.info(`Stopping the station stream for the device ${this.deviceSNs[this.currentMessageState[dataType].p2pStreamChannel]?.sn}, because we haven't received any data for ${this.streamTimeouts.streamDataWait / 1000} seconds`);
             this.endStream(dataType, sendStopCommand);
-        }, this.MAX_STREAM_DATA_WAIT);
+        }, this.streamTimeouts.streamDataWait);
     }
     handleDataBinaryAndVideo(message) {
         if (!this.currentMessageState[message.dataType].invalidStream) {
@@ -1883,6 +1902,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                     this.currentMessageState[message.dataType].p2pStreamMetadata.videoWidth = videoMetaData.videoWidth;
                     if (!this.currentMessageState[message.dataType].p2pStreamFirstVideoDataReceived) {
                         if (this.rawStation.station_sn.startsWith("T8410") ||
+                            this.rawStation.station_sn.startsWith("T8417") ||
                             this.rawStation.station_sn.startsWith("T8400") ||
                             this.rawStation.station_sn.startsWith("T8401") ||
                             this.rawStation.station_sn.startsWith("T8411") ||
@@ -1972,7 +1992,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                     this.currentMessageState[message.dataType].p2pStreamNotStarted) {
                                     this.emitStreamStartEvent(message.dataType);
                                 }
-                            }, this.AUDIO_CODEC_ANALYZE_TIMEOUT);
+                            }, this.streamTimeouts.audioCodecAnalyze);
                         }
                     }
                     if (this.currentMessageState[message.dataType].p2pStreamNotStarted) {
@@ -2059,7 +2079,18 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                             this.emitStreamStartEvent(message.dataType);
                         }
                     }
-                    this.currentMessageState[message.dataType].audioStream?.push(audio_data);
+                    {
+                        const codec = this.currentMessageState[message.dataType].p2pStreamMetadata.audioCodec;
+                        const stream = this.currentMessageState[message.dataType].audioStream;
+                        if (stream && (codec === types_1.AudioCodec.AAC || codec === types_1.AudioCodec.AAC_LC)) {
+                            for (const frame of (0, adts_1.normalizeAdtsFrames)(audio_data)) {
+                                stream.push(frame);
+                            }
+                        }
+                        else {
+                            stream?.push(audio_data);
+                        }
+                    }
                     break;
                 default:
                     logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - Not implemented message`, {
@@ -2376,8 +2407,17 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                     this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_QUERY_BATTERY_LEVEL, payload.slBattery);
                                     this.emit("parameter", message.channel, types_1.CommandType.CMD_SMARTLOCK_QUERY_STATUS, payload.slState);
                                 }
+                                else if (json.cmd === types_1.CommandType.CMD_HUB_NOTIFY_UPDATE) {
+                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Homebase notify update`, {
+                                        stationSN: this.rawStation.station_sn,
+                                        commandIdName: types_1.CommandType[json.cmd],
+                                        commandId: json.cmd,
+                                        message: data.toString(),
+                                    });
+                                    this.emit("hub notify update");
+                                }
                                 else {
-                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Not implemented`, {
+                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Not implemented 1`, {
                                         stationSN: this.rawStation.station_sn,
                                         commandIdName: types_1.CommandType[json.cmd],
                                         commandId: json.cmd,
@@ -2424,9 +2464,10 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                             device_1.Device.isLockWifiT8502(this.rawStation.devices[0]?.device_type) ||
                                             device_1.Device.isLockWifiT8510P(this.rawStation.devices[0]?.device_type, this.rawStation.devices[0]?.device_sn) ||
                                             device_1.Device.isLockWifiT8520P(this.rawStation.devices[0]?.device_type, this.rawStation.devices[0]?.device_sn) ||
-                                            device_1.Device.isLockWifiT85V0(this.rawStation.devices[0]?.device_type, this.rawStation.devices[0]?.device_sn) ||
+                                            device_1.Device.isLockWifiT85V0(this.rawStation.devices[0]?.device_type) ||
                                             device_1.Device.isLockWifiT8531(this.rawStation.devices[0]?.device_type) ||
-                                            device_1.Device.isLockWifiT85L0(this.rawStation.devices[0]?.device_type)) {
+                                            device_1.Device.isLockWifiT85L0(this.rawStation.devices[0]?.device_type) ||
+                                            device_1.Device.isLockWifiT85P0(this.rawStation.devices[0]?.device_type)) {
                                             this.emit("sequence error", message.channel, types_1.SmartLockCommand[payload.bus_type == types_1.SmartLockFunctionType.TYPE_2
                                                 ? types_1.SmartLockBleCommandFunctionType2[payload.lock_cmd]
                                                 : types_1.SmartLockBleCommandFunctionType1[payload.lock_cmd]], payload.seq_num, payload.dev_sn);
@@ -2842,8 +2883,29 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                                     this.emit("storage info hb3", message.channel, payload.body);
                                 }
                             }
+                            else if (json.cmd === 6246) {
+                                const payload = json.payload;
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD Livestream status`, { stationSN: this.rawStation.station_sn, payload: payload });
+                                if (payload?.num !== undefined) {
+                                    if (payload.num > 0) {
+                                        this.emit("rtsp livestream started", message.channel);
+                                    }
+                                    else {
+                                        this.emit("rtsp livestream stopped", message.channel);
+                                    }
+                                }
+                            }
+                            else if (json.cmd === types_1.CommandType.CMD_HUB_NOTIFY_UPDATE) {
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Homebase notify update`, {
+                                    stationSN: this.rawStation.station_sn,
+                                    commandIdName: types_1.CommandType[json.cmd],
+                                    commandId: json.cmd,
+                                    message: data.toString(),
+                                });
+                                this.emit("hub notify update");
+                            }
                             else {
-                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Not implemented`, {
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_NOTIFY_PAYLOAD - Not implemented 2`, {
                                     stationSN: this.rawStation.station_sn,
                                     commandIdName: types_1.CommandType[json.cmd],
                                     commandId: json.cmd,
@@ -3212,7 +3274,10 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                         data: data.toString("hex"),
                         cipherID: cipherID,
                     });
-                    const encryptedKey = (0, utils_1.readNullTerminatedBuffer)(data.subarray(4));
+                    // Keep full raw buffer for ECDH — readNullTerminatedBuffer truncates binary ECIES envelopes at 0x00 bytes
+                    const rawEncryptedKey = data.subarray(4);
+                    const encryptedKey = (0, utils_1.readNullTerminatedBuffer)(rawEncryptedKey);
+                    const isECDHDevice = this.rawStation.station_sn.startsWith("T8214") || this.rawStation.station_sn.startsWith("T8425");
                     this.api
                         .getCipher(/*this.rawStation.station_sn, */ cipherID, this.rawStation.member.admin_user_id)
                         .then((cipher) => {
@@ -3224,10 +3289,49 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
                             cipher: JSON.stringify(cipher),
                         });
                         if (cipher !== undefined) {
-                            this.encryption = types_1.EncryptionType.LEVEL_2;
-                            const rsa = (0, utils_1.getRSAPrivateKey)(cipher.private_key, this.enableEmbeddedPKCS1Support);
-                            this.p2pKey = rsa.decrypt(encryptedKey);
-                            logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - set encryption level 2`, { stationSN: this.rawStation.station_sn, key: this.p2pKey.toString("hex") });
+                            // Try RSA first
+                            try {
+                                this.encryption = types_1.EncryptionType.LEVEL_2;
+                                const rsa = (0, utils_1.getRSAPrivateKey)(cipher.private_key, this.enableEmbeddedPKCS1Support);
+                                this.p2pKey = rsa.decrypt(encryptedKey);
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - RSA success - set encryption level 2`, { stationSN: this.rawStation.station_sn, key: this.p2pKey.toString("hex") });
+                            }
+                            catch (rsaErr) {
+                                const rsaError = (0, error_1.ensureError)(rsaErr);
+                                logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - RSA decrypt failed`, {
+                                    error: (0, utils_3.getError)(rsaError),
+                                    stationSN: this.rawStation.station_sn,
+                                    isECDHDevice: isECDHDevice,
+                                    hasEccKey: !!cipher.ecc_private_key,
+                                });
+                                // Try ECDH only for known ECDH devices (T8214/T8425)
+                                if (isECDHDevice && cipher.ecc_private_key) {
+                                    try {
+                                        this.encryption = types_1.EncryptionType.LEVEL_2;
+                                        this.p2pKey = (0, utils_1.decryptP2PKeyECDH)(rawEncryptedKey, cipher.ecc_private_key);
+                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - ECDH success - set encryption level 2`, {
+                                            stationSN: this.rawStation.station_sn,
+                                            key: this.p2pKey.toString("hex"),
+                                            keyLength: this.p2pKey.length,
+                                        });
+                                    }
+                                    catch (ecdhErr) {
+                                        const ecdhError = (0, error_1.ensureError)(ecdhErr);
+                                        logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - ECDH also failed, falling back to Level 1`, {
+                                            error: (0, utils_3.getError)(ecdhError),
+                                            stationSN: this.rawStation.station_sn,
+                                        });
+                                        this.encryption = types_1.EncryptionType.LEVEL_1;
+                                        this.p2pKey = Buffer.from((0, utils_1.getP2PCommandEncryptionKey)(this.rawStation.station_sn, this.rawStation.p2p_did));
+                                    }
+                                }
+                                else {
+                                    // Non-ECDH device or no ECC key — fall back to Level 1
+                                    this.encryption = types_1.EncryptionType.LEVEL_1;
+                                    this.p2pKey = Buffer.from((0, utils_1.getP2PCommandEncryptionKey)(this.rawStation.station_sn, this.rawStation.p2p_did));
+                                    logging_1.rootP2PLogger.debug(`Handle DATA ${types_1.P2PDataType[message.dataType]} - CMD_GATEWAYINFO - RSA failed, set encryption level 1`, { stationSN: this.rawStation.station_sn, key: this.p2pKey.toString("hex") });
+                                }
+                            }
                         }
                         else {
                             this.encryption = types_1.EncryptionType.LEVEL_1;
@@ -3519,6 +3623,9 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
     isLiveStreaming(channel) {
         return this.isStreaming(channel, types_1.P2PDataType.VIDEO);
     }
+    setStreamTimeouts(options) {
+        this.streamTimeouts = { ...this.streamTimeouts, ...options };
+    }
     isCurrentlyStreaming() {
         for (const element of Object.values(this.currentMessageState)) {
             if (element.p2pStreaming || element.p2pTalkback)
@@ -3710,6 +3817,7 @@ class P2PClientProtocol extends tiny_typed_emitter_1.TypedEmitter {
         return false;
     }
     startTalkback(channel = 0) {
+        (0, utils_1.resetTalkbackCounters)();
         this.currentMessageState[types_1.P2PDataType.VIDEO].p2pTalkback = true;
         this.currentMessageState[types_1.P2PDataType.VIDEO].p2pTalkbackChannel = channel;
         this.initializeTalkbackStream(channel);