@homebridge-plugins/homebridge-ewelink 12.3.3

package/lib/connection/http.js

@@ -0,0 +1,304 @@
+import { Buffer } from 'node:buffer'
+import { createHmac } from 'node:crypto'
+import axios from 'axios'
+import platformConsts from '../utils/constants.js'
+import { sleep } from '../utils/functions.js'
+
+export default class {
+  constructor(platform) {
+    // Set up variables from the platform
+    this.appId = platform.config.appId || platformConsts.appId
+    this.appSecret = platform.config.appSecret || platformConsts.appSecret
+    this.countryCode = platform.config.countryCode
+    this.debug = platform.config.debug
+    this.homeList = []
+    this.httpHost = platform.config.httpHost
+    this.ignoredDevices = platform.ignoredDevices
+    this.ignoredHomes = platform.config.ignoredHomes.split(',')
+    this.lang = platform.lang
+    this.log = platform.log
+    this.mode = platform.config.mode
+    this.obstructSwitches = platform.obstructSwitches
+    this.password = platform.config.password
+    this.sensorSwitches = Object
+      .values(platform.deviceConf)
+      .filter(el => el.sensorId && ['garage', 'lock'].includes(el.showAs))
+      .map(el => el.sensorId)
+    this.triedBase64 = false
+    this.username = platform.config.username
+  }
+
+  async login() {
+    try {
+      // Used to log the user in and obtain the user api key and token
+      const data = {
+        countryCode: this.countryCode,
+        password: this.password,
+      }
+
+      // See if the user has provided an email or phone as username
+      if (this.username.includes('@')) {
+        data.email = this.username
+      } else {
+        data.phoneNumber = this.username
+      }
+
+      // Log the data depending on the debug setting
+      if (this.debug) {
+        this.log('%s.', this.lang.sendLogin)
+      }
+
+      // Set up the request signature
+      const dataToSign = createHmac('sha256', this.appSecret)
+        .update(JSON.stringify(data))
+        .digest('base64')
+
+      // Send the request
+      const res = await axios.post(`https://${this.httpHost}/v2/user/login`, data, {
+        headers: {
+          'Authorization': `Sign ${dataToSign}`,
+          'Content-Type': 'application/json',
+          'X-CK-Appid': this.appId,
+          'X-CK-Nonce': Math.random()
+            .toString(36)
+            .substr(2, 8),
+        },
+      })
+
+      // Parse the response
+      const body = res.data
+      if (body.error === 10004 && body?.data?.region) {
+        // In this case the user has been given a different region so retry login
+        const givenRegion = body.data.region
+
+        // Check the new received region is valid
+        switch (givenRegion) {
+          case 'eu':
+          case 'us':
+          case 'as':
+            this.httpHost = `${givenRegion}-apia.coolkit.cc`
+            break
+          case 'cn':
+            this.httpHost = 'cn-apia.coolkit.cn'
+            break
+          default:
+            throw new Error(`${this.lang.noRegionRec} - [${givenRegion}].`)
+        }
+
+        // Log the new http host if appropriate
+        if (this.debug) {
+          this.log('%s [%s].', this.lang.newRegionRec, this.httpHost)
+        }
+
+        // Retry the login with the new http host
+        return await this.login()
+      }
+
+      if ([10001, 10014].includes(body.error) && !this.triedBase64) {
+        // In this case the password is incorrect so try base64 decoding just once
+        this.triedBase64 = true
+        this.password = Buffer.from(this.password, 'base64')
+          .toString('utf8')
+          .replace(/\r\n|\n|\r/g, '')
+          .trim()
+        return await this.login()
+      }
+
+      if (body.data.at) {
+        // User api key and token received successfully
+        this.aToken = body.data.at
+        this.apiKey = body.data.user.apikey
+        return {
+          aToken: this.aToken,
+          apiKey: this.apiKey,
+          httpHost: this.httpHost,
+          password: this.password,
+        }
+      }
+      if (body.error === 500) {
+        // Retry if another attempt could be successful
+        this.log.warn('%s.', this.lang.eweError)
+        await sleep(30000)
+        return await this.login()
+      }
+      if (body.msg) {
+        throw new Error(body.msg + (body.error ? ` [${body.error}]` : ''))
+      } else {
+        throw new Error(`${this.lang.noAuthRec}.\n${JSON.stringify(body, null, 2)}`)
+      }
+    } catch (err) {
+      // Check to see if it's a eWeLink server problem, and we can retry
+      if (err.code && platformConsts.httpRetryCodes.includes(err.code)) {
+        // Retry if another attempt could be successful
+        this.log.warn('%s [login() - %s].', this.lang.httpRetry, err.code)
+        await sleep(30000)
+        return this.login()
+      }
+      // It's not a eWeLink problem so report the error back
+      this.log.warn('%s.', this.lang.errLogin)
+      if (err.message.includes('10003')) {
+        this.log.warn('%s', this.lang.httpLogin10003)
+      }
+      throw err
+    }
+  }
+
+  async getHomes() {
+    // Used to get a user's home list
+    try {
+      // Send the request
+      const res = await axios.get(`https://${this.httpHost}/v2/family`, {
+        headers: {
+          'Authorization': `Bearer ${this.aToken}`,
+          'Content-Type': 'application/json',
+          'X-CK-Appid': this.appId,
+          'X-CK-Nonce': Math.random()
+            .toString(36)
+            .substr(2, 8),
+        },
+      })
+
+      // Parse the response
+      const body = res.data
+      if (
+        !body.data
+        || body.error !== 0
+        || !body.data.familyList
+        || !Array.isArray(body.data.familyList)
+      ) {
+        throw new Error(JSON.stringify(body, null, 2))
+      }
+
+      // Add the home id to the global array of ids
+      body.data.familyList.forEach((home) => {
+        if (this.ignoredHomes.includes(home.id)) {
+          return
+        }
+        this.log('%s [%s] [%s].', this.lang.fetchHome, home.name, home.id)
+        this.homeList.push(home.id)
+      })
+    } catch (err) {
+      // Check to see if it's a eWeLink server problem, and we can retry
+      if (err.code && platformConsts.httpRetryCodes.includes(err.code)) {
+        // Retry if another attempt could be successful
+        this.log.warn('%s [getHomes() - %s].', this.lang.httpRetry, err.code)
+        await sleep(30000)
+        await this.getHomes()
+      } else {
+        // It's not a eWeLink problem so report the error back
+        this.log.warn('%s.', this.lang.errGetHomes)
+        throw err
+      }
+    }
+  }
+
+  async getDevices() {
+    // Used to get a user's device list
+    try {
+      // Send the request to get a device list for each of the homes
+      const fullDeviceList = []
+
+      for (const homeId of this.homeList) {
+        const res = await axios.get(`https://${this.httpHost}/v2/device/thing`, {
+          headers: {
+            'Authorization': `Bearer ${this.aToken}`,
+            'Content-Type': 'application/json',
+            'X-CK-Appid': this.appId,
+            'X-CK-Nonce': Math.random()
+              .toString(36)
+              .substr(2, 8),
+          },
+          params: {
+            num: 0,
+            familyid: homeId,
+          },
+        })
+
+        // Parse the response
+        const body = res.data
+        if (!body.data || body.error !== 0) {
+          throw new Error(JSON.stringify(body, null, 2))
+        }
+
+        // The list also includes scenes, so we need to remove them
+        if (body.data?.thingList.length > 0) {
+          body.data.thingList.forEach(device => fullDeviceList.push(device))
+        }
+      }
+
+      // Now we have a device list from all the eWeLink user homes
+      const deviceList = []
+      const sensorList = []
+      const groupList = []
+      fullDeviceList.forEach((d) => {
+        // Check each item is a device and also remove any devices the user has ignored
+        if (d?.itemData?.extra?.uiid && !this.ignoredDevices.includes(d.itemData.deviceid)) {
+          // If in LAN mode then don't add to device list
+          if (this.mode === 'lan' && !platformConsts.devices.lan.includes(d.itemData.extra.uiid)) {
+            return
+          }
+          // Separate the sensors as these need to be set up last
+          const isObstructSwitch = this.obstructSwitches[d.itemData.deviceid]
+          const isSensorSwitch = this.sensorSwitches[d.itemData.deviceid]
+          if (
+            platformConsts.devices.garageSensors.includes(d.itemData.extra.uiid)
+            || isObstructSwitch
+            || isSensorSwitch
+          ) {
+            sensorList.push(d.itemData)
+          } else {
+            deviceList.push(d.itemData)
+          }
+        } else if (d.itemType === 3) {
+          // Is a group
+          groupList.push(d.itemData)
+        }
+      })
+
+      // Sensors need to go last as they update garages that need to exist already
+      return {
+        httpDeviceList: deviceList.concat(sensorList),
+        httpGroupList: groupList,
+      }
+    } catch (err) {
+      // Check to see if it's a eWeLink server problem, and we can retry
+      if (err.code && platformConsts.httpRetryCodes.includes(err.code)) {
+        // Retry if another attempt could be successful
+        this.log.warn('%s [getDevices() - %s].', this.lang.httpRetry, err.code)
+        await sleep(30000)
+        return this.getDevices()
+      }
+      // It's not a eWeLink problem so report the error back
+      this.log.warn('%s.', this.lang.errGetDevices)
+      throw err
+    }
+  }
+
+  async updateGroup(groupId, params) {
+    // Used to get info about a specific device
+    const res = await axios.post(
+      `https://${this.httpHost}/v2/device/thing/status`,
+      {
+        type: 2,
+        id: groupId,
+        params,
+      },
+      {
+        headers: {
+          'Authorization': `Bearer ${this.aToken}`,
+          'Content-Type': 'application/json',
+          'X-CK-Appid': this.appId,
+          'X-CK-Nonce': Math.random()
+            .toString(36)
+            .substr(2, 8),
+        },
+      },
+    )
+
+    // Parse the response
+    const body = res.data
+    if (!body.data || body.error !== 0) {
+      throw new Error(JSON.stringify(body, null, 2))
+    }
+  }
+}

package/lib/connection/lan.js

@@ -0,0 +1,318 @@
+import { Buffer } from 'node:buffer'
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHash,
+  randomBytes,
+} from 'node:crypto'
+import events from 'node:events'
+import axios from 'axios'
+import dnsSd from '../node-dns-sd/lib/dns-sd.js'
+import platformConsts from '../utils/constants.js'
+import { hasProperty, parseError } from '../utils/functions.js'
+
+const emitter = new events()
+
+export default class {
+  constructor(platform) {
+    // Set up variables from the platform
+    this.debug = platform.config.debug
+    this.ipOverride = platform.ipOverride
+    this.lang = platform.lang
+    this.log = platform.log
+    this.mode = platform.config.mode
+
+    // Set up other variables and libraries needed by this class
+    this.deviceMap = new Map()
+  }
+
+  async getHosts() {
+    // Create a template map with our device list from the HTTP client
+    Object.entries(this.ipOverride).forEach((entry) => {
+      const [deviceId, ip] = entry
+      // Add this device into the map with its user configured IP
+      this.deviceMap.set(deviceId, {
+        ip,
+        ipOverride: true,
+      })
+    })
+
+    // Perform an initial discovery of devices on the local network
+    if (this.debug) {
+      this.log('%s.', this.lang.lanStarting)
+    }
+    const res = await dnsSd.discover({ name: '_ewelink._tcp.local' })
+    if (this.debug) {
+      this.log('%s.', this.lang.lanStarted)
+    }
+
+    // Update the device map for each device found on the local network
+    res.forEach((device) => {
+      // Obtain the ewelink deviceId and check to see it is in our map
+      const deviceId = device.fqdn.replace('._ewelink._tcp.local', '').replace('eWeLink_', '')
+
+      // Do not override any overridden IPs
+      if (!this.deviceMap.has(deviceId)) {
+        this.deviceMap.set(deviceId, {
+          ip: device.address,
+          ipOverride: false,
+        })
+      }
+    })
+    return this.deviceMap
+  }
+
+  async startMonitor() {
+    // Function to parse DNS packets picked up by node-dns-sd
+    dnsSd.ondata = (packet) => {
+      try {
+        if (!packet.answers) {
+          return
+        }
+        packet.answers
+          .filter(value => value.name.includes('_ewelink._tcp.local'))
+          .filter(value => value.type === 'TXT')
+          .filter(value => this.deviceMap.has(value.rdata.id))
+          .filter(value => this.deviceMap.get(value.rdata.id).lanKey)
+          .forEach((value) => {
+            const { rdata } = value
+
+            // Check the packet relates to a device in our map
+            const deviceInfo = this.deviceMap.get(rdata.id)
+
+            // Skip the update if it's a duplicate
+            if (deviceInfo.lastIV === rdata.iv) {
+              return
+            }
+            deviceInfo.lastIV = rdata.iv
+
+            // Obtain the packet information
+            const data = rdata.data1 + (rdata.data2 || '') + (rdata.data3 || '') + (rdata.data4 || '')
+            const key = createHash('md5')
+              .update(Buffer.from(deviceInfo.lanKey, 'utf8'))
+              .digest()
+            const dText = createDecipheriv(
+              'aes-128-cbc',
+              key,
+              Buffer.from(rdata.iv, 'base64'),
+            )
+            const pText = Buffer.concat([
+              dText.update(Buffer.from(data, 'base64')),
+              dText.final(),
+            ]).toString('utf8')
+
+            // Check to see if the IP address of the device has changed
+            if (packet.address !== deviceInfo.ip) {
+              deviceInfo.ip = deviceInfo.ipOverride ? deviceInfo.ip : packet.address
+            }
+
+            this.deviceMap.set(rdata.id, deviceInfo)
+
+            // Parse the deconstructed information from the packet
+            let params
+            try {
+              params = JSON.parse(pText)
+            } catch (err) {
+              this.log.warn(
+                '[%s] %s %s:\n%s',
+                rdata.id,
+                this.lang.cantReadPacket,
+                err.message,
+                pText,
+              )
+              return
+            }
+
+            // Remove any params we don't need
+            Object.keys(params).forEach((param) => {
+              if (!platformConsts.paramsToKeep.includes(param.replace(/\d/g, ''))) {
+                delete params[param]
+              }
+            })
+
+            // If any params are left then generate the template to be emitted
+            if (Object.keys(params).length > 0) {
+              if (packet.address !== deviceInfo.ip) {
+                params.ip = packet.address
+              }
+              params.online = true
+              params.updateSource = 'LAN'
+              const returnTemplate = {
+                deviceid: rdata.id,
+                params,
+              }
+              emitter.emit('update', returnTemplate)
+            }
+          })
+      } catch (err) {
+        this.log.warn('%s %s.', this.lang.cantParsePacket, parseError(err))
+      }
+    }
+
+    // Start the DNS packet monitoring
+    await dnsSd.startMonitoring()
+    this.log('%s.', this.lang.lanMonitor)
+  }
+
+  async sendUpdate(json) {
+    try {
+      // Check this device exists in the map
+      if (!this.deviceMap.has(json.deviceid)) {
+        throw new Error(this.lang.devNotReachLAN)
+      }
+
+      const deviceInfo = this.deviceMap.get(json.deviceid)
+
+      // Check we have an IP address for the device
+      if (!deviceInfo.ip) {
+        throw new Error(this.lang.devNotReachLAN)
+      }
+
+      // Check we have the device lan key
+      if (!deviceInfo.lanKey || !deviceInfo.uiid || !deviceInfo.productModel) {
+        throw new Error(this.lang.devNoAPIKey)
+      }
+
+      const params = {}
+      let suffix
+
+      // Check the params to see which suffix and params we need
+      if (json.params.brightness) {
+        params.switch = 'on'
+        params.brightness = json.params.brightness
+        params.mode = 0
+        suffix = 'dimmable'
+      } else if (json.params.switches) {
+        const specialModels = ['iFan03', 'iFan', 'iFan04']
+        if (deviceInfo.uiid === 34 && specialModels.includes(deviceInfo.productModel)) {
+          // Special format for some iFan models
+          if (json.params.switches[0].outlet === 0) {
+            // Turn on/off the light for the iFan
+            params.light = json.params.switches[0].switch
+            suffix = 'light'
+          } else {
+            // Change the state or speed of the iFan
+            if (json.params.switches[0].switch === 'off') {
+              params.fan = 'off'
+            } else {
+              params.fan = 'on'
+              switch (json.params.switches[1].switch + json.params.switches[2].switch) {
+                case 'offoff':
+                  params.speed = 1
+                  break
+                case 'onoff':
+                  params.speed = 2
+                  break
+                case 'offon':
+                  params.speed = 3
+                  break
+                default:
+                  // Should never happen
+                  return 'ok'
+              }
+            }
+            suffix = 'fan'
+          }
+        } else {
+          params.switches = json.params.switches
+          suffix = 'switches'
+        }
+      } else if (json.params.switch) {
+        params.switch = json.params.switch
+        if (deviceInfo.uiid === 15) {
+          // TH10/16 only supports LAN in normal mode
+          if (json.params.deviceType === 'normal') {
+            // Extra params for the TH10/16
+            params.mainSwitch = json.params.mainSwitch
+            params.deviceType = json.params.deviceType
+          } else {
+            throw new Error(this.lang.devNotConfLAN)
+          }
+        }
+        suffix = 'switch'
+      } else if (
+        hasProperty(json.params, 'location')
+        && platformConsts.devices.switchMultiPower.includes(deviceInfo.uiid)
+      ) {
+        // Use hasProperty has location can be INT 0
+        params.location = json.params.location
+        suffix = 'location'
+      } else if (json.params.uiActive && deviceInfo.uiid === 32) {
+        params.uiActive = json.params.uiActive
+        suffix = 'monitor'
+      } else if (json.params.cmd) {
+        params.cmd = 'transmit'
+        params.rfChl = json.params.rfChl
+        suffix = 'transmit'
+      } else if (hasProperty(json.params, 'ltype')) {
+        params.ltype = json.params.ltype
+        if (hasProperty(json.params, 'white')) {
+          params.white = json.params.white
+        } else {
+          params.color = json.params.color
+        }
+        suffix = 'dimmable'
+      } else {
+        throw new Error(this.lang.devNotConfLAN)
+      }
+
+      // Generate the HTTP request
+      const key = createHash('md5')
+        .update(Buffer.from(deviceInfo.lanKey, 'utf8'))
+        .digest()
+      const iv = randomBytes(16)
+      const enc = createCipheriv('aes-128-cbc', key, iv)
+      const data = {
+        data: Buffer.concat([enc.update(JSON.stringify(params)), enc.final()]).toString('base64'),
+        deviceid: json.deviceid,
+        encrypt: true,
+        iv: iv.toString('base64'),
+        selfApikey: '123',
+        sequence: Date.now().toString(),
+      }
+
+      // Send the HTTP request
+      const res = await axios({
+        method: 'post',
+        url: `http://${deviceInfo.ip}:8081/zeroconf/${suffix}`,
+        headers: {
+          'Accept': 'application/json',
+          'Content-Type': 'application/json',
+        },
+        data,
+        timeout: this.mode === 'lan' ? 9000 : 3000,
+      })
+
+      // Check for any errors in the response
+      if (!res.data || res.data.error !== 0) {
+        const error = res?.data?.error || this.lang.lanErr
+        throw new Error(error)
+      }
+
+      // This ok is needed by the plugin
+      return 'ok'
+    } catch (err) {
+      return parseError(err)
+    }
+  }
+
+  receiveUpdate(f) {
+    emitter.addListener('update', f)
+  }
+
+  addDeviceDetailsToMap(deviceId, context) {
+    const entry = this.deviceMap.get(deviceId) || { ip: this.ipOverride[deviceId] }
+    entry.lanKey = context.lanKey
+    entry.uiid = context.eweUIID
+    entry.productModel = context.eweModel
+    this.deviceMap.set(deviceId, entry)
+  }
+
+  async closeConnection() {
+    // This is called when Homebridge is shutdown
+    await dnsSd.stopMonitoring()
+    if (this.debug) {
+      this.log('%s.', this.lang.stoppedLAN)
+    }
+  }
+}