@nubisco/homebridge-tuya-local-platform 1.0.0

package/dist/protocol/TuyaAccessory.js

@@ -0,0 +1,646 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const net_1 = __importDefault(require("net"));
+const async_1 = __importDefault(require("async"));
+const crypto_1 = __importDefault(require("crypto"));
+const events_1 = require("events");
+const isNonEmptyPlainObject = (o) => {
+    if (!o || typeof o !== 'object')
+        return false;
+    for (const _i in o)
+        return true;
+    return false;
+};
+class TuyaAccessory extends events_1.EventEmitter {
+    log;
+    context;
+    state = {};
+    connected = false;
+    _cachedBuffer = Buffer.allocUnsafe(0);
+    _msgQueue;
+    _socket;
+    _connectionAttempts = 0;
+    _sendCounter = 0;
+    _tmpLocalKey = null;
+    _tmpRemoteKey = null;
+    session_key = null;
+    constructor(props) {
+        super();
+        if (!(props.id && props.key && props.ip) && !props.fake) {
+            if (props.log)
+                props.log.info('Insufficient details to initialize:', JSON.stringify(props));
+            return;
+        }
+        this.log = props.log;
+        this.context = { version: '3.1', port: 6668, ...props };
+        this.state = {};
+        this._cachedBuffer = Buffer.allocUnsafe(0);
+        const version = parseFloat(this.context.version || '3.1');
+        const handlerName = version < 3.2 ? '_msgHandler_3_1' : this.context.version === '3.4' ? '_msgHandler_3_4' : '_msgHandler_3_3';
+        this._msgQueue = async_1.default.queue(this[handlerName].bind(this), 1);
+        if (version >= 3.2) {
+            this.context.pingGap = Math.min(this.context.pingGap || 9, 9);
+        }
+        this.connected = false;
+        if (props.connect !== false)
+            this._connect();
+        this._connectionAttempts = 0;
+        this._sendCounter = 0;
+        this._tmpLocalKey = null;
+        this._tmpRemoteKey = null;
+        this.session_key = null;
+    }
+    _connect() {
+        if (this.context.fake) {
+            this.connected = true;
+            return void setTimeout(() => {
+                this.emit('change', {}, this.state);
+            }, 1000);
+        }
+        this._socket = new net_1.default.Socket();
+        this._incrementAttemptCounter();
+        (this._socket.reconnect = () => {
+            if (this._socket._pinger) {
+                clearTimeout(this._socket._pinger);
+                this._socket._pinger = null;
+            }
+            if (this._socket._connTimeout) {
+                clearTimeout(this._socket._connTimeout);
+                this._socket._connTimeout = null;
+            }
+            if (this._socket._errorReconnect) {
+                clearTimeout(this._socket._errorReconnect);
+                this._socket._errorReconnect = null;
+            }
+            this._socket.setKeepAlive(true);
+            this._socket.setNoDelay(true);
+            this._socket._connTimeout = setTimeout(() => {
+                this._socket.emit('error', new Error('ERR_CONNECTION_TIMED_OUT'));
+            }, (this.context.connectTimeout || 30) * 1000);
+            this._incrementAttemptCounter();
+            this._socket.connect(this.context.port, this.context.ip);
+        })();
+        this._socket._ping = () => {
+            if (this._socket._pinger)
+                clearTimeout(this._socket._pinger);
+            this._socket._pinger = setTimeout(() => {
+                this._socket._pinger = setTimeout(() => {
+                    this._socket.emit('error', new Error('ERR_PING_TIMED_OUT'));
+                }, 5000);
+                this._send({ cmd: 9 });
+            }, (this.context.pingTimeout || 30) * 1000);
+            this._send({ cmd: 9 });
+        };
+        this._socket.on('connect', () => {
+            if (this.context.version !== '3.4') {
+                clearTimeout(this._socket._connTimeout);
+                this.connected = true;
+                this.emit('connect');
+                if (this._socket._pinger)
+                    clearTimeout(this._socket._pinger);
+                this._socket._pinger = setTimeout(() => this._socket._ping(), 1000);
+                if (this.context.intro === false) {
+                    this.emit('change', {}, this.state);
+                    process.nextTick(this.update.bind(this));
+                }
+            }
+        });
+        this._socket.on('ready', () => {
+            if (this.context.intro === false)
+                return;
+            this.connected = true;
+            if (this.context.version === '3.4') {
+                this._tmpLocalKey = crypto_1.default.randomBytes(16);
+                const payload = {
+                    data: this._tmpLocalKey,
+                    encrypted: true,
+                    cmd: 3,
+                };
+                this._send(payload);
+            }
+            else {
+                this.update();
+            }
+        });
+        this._socket.on('data', (msg) => {
+            this._cachedBuffer = Buffer.concat([this._cachedBuffer, msg]);
+            do {
+                const startingIndex = this._cachedBuffer.indexOf('000055aa', 'hex');
+                if (startingIndex === -1) {
+                    this._cachedBuffer = Buffer.allocUnsafe(0);
+                    break;
+                }
+                if (startingIndex !== 0)
+                    this._cachedBuffer = this._cachedBuffer.slice(startingIndex);
+                let endingIndex = this._cachedBuffer.indexOf('0000aa55', 'hex');
+                if (endingIndex === -1)
+                    break;
+                endingIndex += 4;
+                this._msgQueue.push({ msg: this._cachedBuffer.slice(0, endingIndex) });
+                this._cachedBuffer = this._cachedBuffer.slice(endingIndex);
+            } while (this._cachedBuffer.length);
+        });
+        this._socket.on('error', (err) => {
+            this.connected = false;
+            this.log.info(`Socket had a problem and will reconnect to ${this.context.name} (${(err && err.code) || err})`);
+            if (err && (err.code === 'ECONNRESET' || err.code === 'EPIPE') && this._connectionAttempts < 10) {
+                this.log.debug(`Reconnecting with connection attempts =  ${this._connectionAttempts}`);
+                return process.nextTick(this._socket.reconnect.bind(this));
+            }
+            this._socket.destroy();
+            let delay = 5000;
+            if (err) {
+                if (err.code === 'ENOBUFS') {
+                    this.log.warn('Operating system complained of resource exhaustion; did I open too many sockets?');
+                    this.log.info('Slowing down retry attempts; if you see this happening often, it could mean some sort of incompatibility.');
+                    delay = 60000;
+                }
+                else if (this._connectionAttempts > 10) {
+                    this.log.info('Slowing down retry attempts; if you see this happening often, it could mean some sort of incompatibility.');
+                    delay = 60000;
+                }
+            }
+            if (!this._socket._errorReconnect) {
+                this.log.debug(`after error setting _connect in ${delay}ms`);
+                this._socket._errorReconnect = setTimeout(() => {
+                    this.log.debug(`executing _connect after ${delay}ms delay`);
+                    process.nextTick(this._connect.bind(this));
+                }, delay);
+            }
+        });
+        this._socket.on('close', () => {
+            this.connected = false;
+            this.session_key = null;
+        });
+        this._socket.on('end', () => {
+            this.connected = false;
+            this.session_key = null;
+            this.log.info('Disconnected from', this.context.name);
+        });
+    }
+    _incrementAttemptCounter() {
+        this._connectionAttempts++;
+        setTimeout(() => {
+            this.log.debug(`decrementing this._connectionAttempts, currently ${this._connectionAttempts}`);
+            this._connectionAttempts--;
+        }, 10000);
+    }
+    _msgHandler_3_1(task, callback) {
+        if (!(task.msg instanceof Buffer))
+            return callback();
+        const len = task.msg.length;
+        if (len < 16 || task.msg.readUInt32BE(0) !== 0x000055aa || task.msg.readUInt32BE(len - 4) !== 0x0000aa55)
+            return callback();
+        const size = task.msg.readUInt32BE(12);
+        if (len - 8 < size)
+            return callback();
+        const cmd = task.msg.readUInt32BE(8);
+        let data = task.msg
+            .slice(len - size, len - 8)
+            .toString('utf8')
+            .trim()
+            .replace(/\0/g, '');
+        if (this.context.intro === false && cmd !== 9)
+            this.log.info('Message from', this.context.name + ':', data);
+        switch (cmd) {
+            case 7:
+                break;
+            case 9:
+                if (this._socket._pinger)
+                    clearTimeout(this._socket._pinger);
+                this._socket._pinger = setTimeout(() => {
+                    this._socket._ping();
+                }, (this.context.pingGap || 20) * 1000);
+                break;
+            case 8: {
+                let decryptedMsg;
+                try {
+                    const decipher = crypto_1.default.createDecipheriv('aes-128-ecb', this.context.key, '');
+                    decryptedMsg = decipher.update(data.substr(19), 'base64', 'utf8');
+                    decryptedMsg += decipher.final('utf8');
+                }
+                catch (_ex) {
+                    decryptedMsg = data.substr(19).toString();
+                }
+                try {
+                    data = JSON.parse(decryptedMsg);
+                }
+                catch (_ex) {
+                    data = decryptedMsg;
+                    this.log.info(`Odd message from ${this.context.name} with command ${cmd}:`, data);
+                    this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+                    break;
+                }
+                if (data && typeof data === 'object' && data.dps) {
+                    this._change(data.dps);
+                }
+                break;
+            }
+            case 10:
+                if (data) {
+                    if (data === 'json obj data unvalid') {
+                        this.log.info(`${this.context.name} (${this.context.version}) didn't respond with its current state.`);
+                        this.emit('change', {}, this.state);
+                        break;
+                    }
+                    try {
+                        data = JSON.parse(data);
+                    }
+                    catch (_ex) {
+                        this.log.info(`Malformed update from ${this.context.name} with command ${cmd}:`, data);
+                        this.log.info(`Raw update from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+                        break;
+                    }
+                    if (data && typeof data === 'object' && data.dps)
+                        this._change(data.dps);
+                }
+                break;
+            default:
+                this.log.info(`Odd message from ${this.context.name} with command ${cmd}:`, data);
+                this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+        }
+        callback();
+    }
+    _msgHandler_3_3(task, callback) {
+        if (!(task.msg instanceof Buffer))
+            return callback();
+        const len = task.msg.length;
+        if (len < 16 || task.msg.readUInt32BE(0) !== 0x000055aa || task.msg.readUInt32BE(len - 4) !== 0x0000aa55)
+            return callback();
+        const size = task.msg.readUInt32BE(12);
+        if (len - 8 < size)
+            return callback();
+        const cmd = task.msg.readUInt32BE(8);
+        if (cmd === 7)
+            return callback();
+        if (cmd === 9) {
+            if (this._socket._pinger)
+                clearTimeout(this._socket._pinger);
+            this._socket._pinger = setTimeout(() => {
+                this._socket._ping();
+            }, (this.context.pingGap || 20) * 1000);
+            return callback();
+        }
+        let versionPos = task.msg.indexOf('3.3');
+        if (versionPos === -1)
+            versionPos = task.msg.indexOf('3.2');
+        const cleanMsg = task.msg.slice(versionPos === -1 ? len - size + (task.msg.readUInt32BE(16) & 0xffffff00 ? 0 : 4) : 15 + versionPos, len - 8);
+        let decryptedMsg;
+        try {
+            const decipher = crypto_1.default.createDecipheriv('aes-128-ecb', this.context.key, '');
+            decryptedMsg = decipher.update(cleanMsg, undefined, 'utf8');
+            decryptedMsg += decipher.final('utf8');
+        }
+        catch (_ex) {
+            decryptedMsg = cleanMsg.toString('utf8');
+        }
+        if (cmd === 10 && decryptedMsg === 'json obj data unvalid') {
+            this.log.info(`${this.context.name} (${this.context.version}) didn't respond with its current state.`);
+            this.emit('change', {}, this.state);
+            return callback();
+        }
+        let data;
+        try {
+            data = JSON.parse(decryptedMsg);
+        }
+        catch (_ex) {
+            this.log.info(`Odd message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
+            this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+            return callback();
+        }
+        switch (cmd) {
+            case 8:
+            case 10:
+                if (data) {
+                    if (data.dps) {
+                        this._change(data.dps);
+                    }
+                    else {
+                        this.log.info(`Malformed message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
+                        this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+                    }
+                }
+                break;
+            default:
+                this.log.info(`Odd message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
+                this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+        }
+        callback();
+    }
+    _msgHandler_3_4(task, callback) {
+        if (!(task.msg instanceof Buffer))
+            return callback();
+        const len = task.msg.length;
+        if (len < 16 || task.msg.readUInt32BE(0) !== 0x000055aa || task.msg.readUInt32BE(len - 4) !== 0x0000aa55)
+            return callback();
+        const size = task.msg.readUInt32BE(12);
+        if (len - 8 < size)
+            return callback();
+        const cmd = task.msg.readUInt32BE(8);
+        if (cmd === 7 || cmd === 13)
+            return callback();
+        if (cmd === 9) {
+            if (this._socket._pinger)
+                clearTimeout(this._socket._pinger);
+            this._socket._pinger = setTimeout(() => {
+                this._socket._ping();
+            }, (this.context.pingGap || 20) * 1000);
+            return callback();
+        }
+        const versionPos = task.msg.indexOf('3.4');
+        const cleanMsg = task.msg.slice(versionPos === -1 ? len - size + (task.msg.readUInt32BE(16) & 0xffffff00 ? 0 : 4) : 15 + versionPos, len - 0x24);
+        const expectedCrc = task.msg.slice(len - 0x24, task.msg.length - 4).toString('hex');
+        const computedCrc = hmac(task.msg.slice(0, len - 0x24), this.session_key ?? this.context.key).toString('hex');
+        if (expectedCrc !== computedCrc) {
+            throw new Error(`HMAC mismatch: expected ${expectedCrc}, was ${computedCrc}. ${task.msg.toString('hex')}`);
+        }
+        const decipher = crypto_1.default.createDecipheriv('aes-128-ecb', this.session_key ?? this.context.key, null);
+        decipher.setAutoPadding(false);
+        let decryptedMsg = decipher.update(cleanMsg);
+        decipher.final();
+        decryptedMsg = decryptedMsg.slice(0, decryptedMsg.length - decryptedMsg[decryptedMsg.length - 1]);
+        let parsedPayload;
+        try {
+            let sliced = decryptedMsg;
+            if (decryptedMsg.indexOf(this.context.version) === 0) {
+                sliced = decryptedMsg.slice(15);
+            }
+            const res = JSON.parse(sliced.toString());
+            if ('data' in res) {
+                const resdata = res.data;
+                resdata.t = res.t;
+                parsedPayload = resdata;
+            }
+            else {
+                parsedPayload = res;
+            }
+        }
+        catch (_) {
+            parsedPayload = decryptedMsg;
+        }
+        if (cmd === 4) {
+            this._tmpRemoteKey = parsedPayload.subarray(0, 16);
+            const calcLocalHmac = hmac(this._tmpLocalKey, this.session_key ?? this.context.key).toString('hex');
+            const expLocalHmac = parsedPayload.slice(16, 16 + 32).toString('hex');
+            if (expLocalHmac !== calcLocalHmac) {
+                throw new Error(`HMAC mismatch(keys): expected ${expLocalHmac}, was ${calcLocalHmac}. ${parsedPayload.toString('hex')}`);
+            }
+            const payload = {
+                data: hmac(this._tmpRemoteKey, this.context.key),
+                encrypted: true,
+                cmd: 5,
+            };
+            this._send(payload);
+            clearTimeout(this._socket._connTimeout);
+            this.session_key = Buffer.from(this._tmpLocalKey);
+            for (let i = 0; i < this._tmpLocalKey.length; i++) {
+                this.session_key[i] = this._tmpLocalKey[i] ^ this._tmpRemoteKey[i];
+            }
+            this.session_key = encrypt34(this.session_key, this.context.key);
+            clearTimeout(this._socket._connTimeout);
+            this.connected = true;
+            this.update();
+            this.emit('connect');
+            if (this._socket._pinger)
+                clearTimeout(this._socket._pinger);
+            this._socket._pinger = setTimeout(() => this._socket._ping(), 1000);
+            return callback();
+        }
+        if (cmd === 10 && parsedPayload === 'json obj data unvalid') {
+            this.log.info(`${this.context.name} (${this.context.version}) didn't respond with its current state.`);
+            this.emit('change', {}, this.state);
+            return callback();
+        }
+        switch (cmd) {
+            case 8:
+            case 10:
+            case 16:
+                if (parsedPayload) {
+                    if (parsedPayload.dps) {
+                        this._change(parsedPayload.dps);
+                    }
+                    else {
+                        this.log.info(`Malformed message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
+                        this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+                    }
+                }
+                break;
+            default:
+                this.log.info(`Odd message from ${this.context.name} with command ${cmd}:`, decryptedMsg);
+                this.log.info(`Raw message from ${this.context.name} (${this.context.version}) with command ${cmd}:`, task.msg.toString('hex'));
+        }
+        callback();
+    }
+    update(o) {
+        const dps = {};
+        let hasDataPoint = false;
+        if (o) {
+            Object.keys(o).forEach((key) => {
+                if (!isNaN(Number(key))) {
+                    dps['' + key] = o[key];
+                    hasDataPoint = true;
+                }
+            });
+        }
+        if (this.context.fake) {
+            if (hasDataPoint)
+                this._fakeUpdate(dps);
+            return true;
+        }
+        let result;
+        if (hasDataPoint) {
+            const t = (Date.now() / 1000).toFixed(0);
+            const payload = {
+                devId: this.context.id,
+                uid: '',
+                t,
+                dps,
+            };
+            const data = this.context.version === '3.4'
+                ? {
+                    data: { ...payload, ctype: 0, t: undefined },
+                    protocol: 5,
+                    t,
+                }
+                : payload;
+            result = this._send({
+                data: data,
+                cmd: this.context.version === '3.4' ? 13 : 7,
+            });
+            if (result !== true)
+                this.log.info(' Result', result);
+            if (this.context.sendEmptyUpdate) {
+                this._send({ cmd: this.context.version === '3.4' ? 13 : 7 });
+            }
+        }
+        else {
+            result = this._send({
+                data: {
+                    gwId: this.context.id,
+                    devId: this.context.id,
+                },
+                cmd: this.context.version === '3.4' ? 16 : 10,
+            });
+        }
+        return result;
+    }
+    _change(data) {
+        if (!isNonEmptyPlainObject(data))
+            return;
+        const changes = {};
+        Object.keys(data).forEach((key) => {
+            if (data[key] !== this.state[key]) {
+                changes[key] = data[key];
+            }
+        });
+        if (isNonEmptyPlainObject(changes)) {
+            this.state = { ...this.state, ...data };
+            this.emit('change', changes, this.state);
+        }
+    }
+    _send(o) {
+        if (this.context.fake)
+            return;
+        if (!this.connected)
+            return false;
+        const version = parseFloat(this.context.version || '3.1');
+        if (version < 3.2)
+            return this._send_3_1(o);
+        if (this.context.version === '3.3')
+            return this._send_3_3(o);
+        return this._send_3_4(o);
+    }
+    _send_3_1(o) {
+        const { cmd, data } = { ...o };
+        let msg = '';
+        if (data && typeof data !== 'string' && !(data instanceof Buffer)) {
+            switch (cmd) {
+                case 7: {
+                    const cipher = crypto_1.default.createCipheriv('aes-128-ecb', this.context.key, '');
+                    let encrypted = cipher.update(JSON.stringify(data), 'utf8', 'base64');
+                    encrypted += cipher.final('base64');
+                    const hash = crypto_1.default
+                        .createHash('md5')
+                        .update(`data=${encrypted}||lpv=${this.context.version}||${this.context.key}`, 'utf8')
+                        .digest('hex')
+                        .substr(8, 16);
+                    msg = this.context.version + hash + encrypted;
+                    break;
+                }
+                case 10:
+                    msg = JSON.stringify(data);
+                    break;
+            }
+        }
+        const payload = Buffer.from(msg);
+        const prefix = Buffer.from('000055aa00000000000000' + cmd.toString(16).padStart(2, '0'), 'hex');
+        const suffix = Buffer.concat([payload, Buffer.from('000000000000aa55', 'hex')]);
+        const len = Buffer.allocUnsafe(4);
+        len.writeInt32BE(suffix.length, 0);
+        return this._socket.write(Buffer.concat([prefix, len, suffix]));
+    }
+    _send_3_3(o) {
+        const { cmd, data } = { ...o };
+        if (cmd !== 7 || data)
+            this._sendCounter++;
+        const hex = [
+            '000055aa',
+            this._sendCounter.toString(16).padStart(8, '0'),
+            cmd.toString(16).padStart(8, '0'),
+            '00000000',
+        ];
+        if (cmd === 7 && !data)
+            hex.push('00000000');
+        else if (cmd !== 9 && cmd !== 10)
+            hex.push('332e33000000000000000000000000');
+        if (data && !(data instanceof Buffer)) {
+            const cipher = crypto_1.default.createCipheriv('aes-128-ecb', this.context.key, '');
+            let encrypted = cipher.update(Buffer.from(JSON.stringify(data)), undefined, 'hex');
+            encrypted += cipher.final('hex');
+            hex.push(encrypted);
+        }
+        hex.push('00000000');
+        hex.push('0000aa55');
+        const payload = Buffer.from(hex.join(''), 'hex');
+        payload.writeUInt32BE(payload.length - 16, 12);
+        payload.writeInt32BE(getCRC32(payload.slice(0, payload.length - 8)), payload.length - 8);
+        return this._socket.write(payload);
+    }
+    _fakeUpdate(dps) {
+        this.log.info('Fake update:', JSON.stringify(dps));
+        Object.keys(dps).forEach((dp) => {
+            this.state[dp] = dps[dp];
+        });
+        setTimeout(() => {
+            this.emit('change', dps, this.state);
+        }, 1000);
+    }
+    _send_3_4(o) {
+        const { cmd, data: _data } = { ...o };
+        let data = _data;
+        if (!data) {
+            data = Buffer.allocUnsafe(0);
+        }
+        if (!(data instanceof Buffer)) {
+            if (typeof data !== 'string') {
+                data = JSON.stringify(data);
+            }
+            data = Buffer.from(data);
+        }
+        if (cmd !== 10 && cmd !== 9 && cmd !== 16 && cmd !== 3 && cmd !== 5 && cmd !== 18) {
+            const buffer = Buffer.alloc(data.length + 15);
+            Buffer.from('3.4').copy(buffer, 0);
+            data.copy(buffer, 15);
+            data = buffer;
+        }
+        const padding = 0x10 - (data.length & 0xf);
+        const buf34 = Buffer.alloc(data.length + padding, padding);
+        data.copy(buf34);
+        data = buf34;
+        const encrypted = encrypt34(data, this.session_key ?? this.context.key);
+        const encryptedBuffer = Buffer.from(encrypted);
+        const buffer = Buffer.alloc(encryptedBuffer.length + 52);
+        buffer.writeUInt32BE(0x000055aa, 0);
+        buffer.writeUInt32BE(cmd, 8);
+        buffer.writeUInt32BE(encryptedBuffer.length + 0x24, 12);
+        if ((cmd !== 7 && cmd !== 13) || data) {
+            this._sendCounter++;
+            buffer.writeUInt32BE(this._sendCounter, 4);
+        }
+        encryptedBuffer.copy(buffer, 16);
+        const calculatedCrc = hmac(buffer.slice(0, encryptedBuffer.length + 16), this.session_key ?? this.context.key);
+        calculatedCrc.copy(buffer, encryptedBuffer.length + 16);
+        buffer.writeUInt32BE(0x0000aa55, encryptedBuffer.length + 48);
+        return this._socket.write(buffer);
+    }
+}
+const encrypt34 = (data, encryptKey) => {
+    const cipher = crypto_1.default.createCipheriv('aes-128-ecb', encryptKey, null);
+    cipher.setAutoPadding(false);
+    const encrypted = cipher.update(data);
+    cipher.final();
+    return encrypted;
+};
+const hmac = (data, hmacKey) => {
+    return crypto_1.default.createHmac('sha256', hmacKey).update(data).digest();
+};
+const crc32LookupTable = [];
+(() => {
+    for (let i = 0; i < 256; i++) {
+        let crc = i;
+        for (let j = 8; j > 0; j--)
+            crc = crc & 1 ? (crc >>> 1) ^ 3988292384 : crc >>> 1;
+        crc32LookupTable.push(crc);
+    }
+})();
+const getCRC32 = (buffer) => {
+    let crc = 0xffffffff;
+    for (let i = 0, len = buffer.length; i < len; i++)
+        crc = crc32LookupTable[buffer[i] ^ (crc & 0xff)] ^ (crc >>> 8);
+    return ~crc;
+};
+exports.default = TuyaAccessory;
+//# sourceMappingURL=TuyaAccessory.js.map