Add support for message decryption and a set of get commands

README.md

@@ -10,9 +10,6 @@ since 2018. It utilizes encryption rules based on a guide found on the internet.
 This is not provided by LG, and it is not a complete implementation for every TV
 model.
 
-_Note: I wasn't able to implement deciphering of the messages sent back from the
-TV, so all commands are "send only"._
-
 **Requirements**
 
 - LG TV (tested on model OLED65B9PUA)
@@ -110,6 +107,46 @@ Disconnects from the TV. Returns a promise.
 await lgtv.disconnect();
 ```
 
+### `.getCurrentApp()`
+
+Gets the current app. Returns a promise.
+
+```ts
+const currentApp = await lgtv.getCurrentApp();
+```
+
+### `.getCurrentVolume()`
+
+Gets the current volume. Returns a promise.
+
+```ts
+const currentVolume = await lgtv.getCurrentVolume();
+```
+
+### `.getIpControlState()`
+
+Gets the ip control state. Returns a promise.
+
+```ts
+const ipControlState = await lgtv.getIpControlState();
+```
+
+### `.getMacAddress(type: 'wired' | 'wifi')`
+
+Gets the mac address by type. Returns a promise.
+
+```ts
+const macAddress = await lgtv.getMacAddress('wired');
+```
+
+### `.getMuteState()`
+
+Gets the mute state. Returns a promise.
+
+```ts
+const muteState = await lgtv.getMuteState();
+```
+
 ### `.powerOff()`
 
 Powers the TV off. Returns a promise.

src/classes/LGEncryption.ts

@@ -1,5 +1,5 @@
 import assert from 'assert';
-import { createCipheriv, pbkdf2Sync } from 'crypto';
+import { createCipheriv, createDecipheriv, pbkdf2Sync } from 'crypto';
 import { DefaultSettings } from '../constants/DefaultSettings';
 
 export interface EncryptionSettings {
@@ -137,4 +137,22 @@ export class LGEncryption {
 
     return Buffer.concat([ivEnc, dataEnc]);
   }
+
+  decrypt(cipher: Buffer) {
+    const ecbDecypher = createDecipheriv(
+      'aes-128-ecb',
+      this.derivedKey,
+      Buffer.alloc(0)
+    );
+    ecbDecypher.setAutoPadding(false);
+    const iv = ecbDecypher.update(
+      cipher.slice(0, this.settings.encryptionKeyLength)
+    );
+
+    const cbcDecypher = createDecipheriv('aes-128-cbc', this.derivedKey, iv);
+    cbcDecypher.setAutoPadding(false);
+    return cbcDecypher
+      .update(cipher.slice(this.settings.encryptionKeyLength))
+      .toString();
+  }
 }

src/classes/LGTV.ts

@@ -22,7 +22,8 @@ export class LGTV {
 
   private async sendCommand(command: string) {
     const encryptedData = this.encryption.encrypt(command);
-    await this.socket.sendReceive(encryptedData);
+    const encryptedResponse = await this.socket.sendReceive(encryptedData);
+    return this.encryption.decrypt(encryptedResponse);
   }
 
   async connect() {
@@ -33,8 +34,28 @@ export class LGTV {
     await this.socket.disconnect();
   }
 
+  async getCurrentApp() {
+    return await this.sendCommand('CURRENT_APP');
+  }
+
+  async getCurrentVolume() {
+    return await this.sendCommand('CURRENT_VOL');
+  }
+
+  async getIpControlState() {
+    return await this.sendCommand('GET_IPCONTROL_STATE');
+  }
+
+  async getMacAddress(type: 'wired' | 'wifi') {
+    return await this.sendCommand(`GET_MACADDRESS ${type}`);
+  }
+
+  async getMuteState() {
+    return await this.sendCommand('MUTE_STATE');
+  }
+
   async powerOff() {
-    await this.sendCommand(`POWER off`);
+    return await this.sendCommand(`POWER off`);
   }
 
   powerOn() {
@@ -46,7 +67,7 @@ export class LGTV {
       Object.values(Keys).some(availableKey => availableKey === key),
       'key must be valid'
     );
-    await this.sendCommand(`KEY_ACTION ${key}`);
+    return await this.sendCommand(`KEY_ACTION ${key}`);
   }
 
   async setEnergySaving(level: EnergySavingLevels) {
@@ -56,15 +77,15 @@ export class LGTV {
       ),
       'level must be valid'
     );
-    await this.sendCommand(`ENERGY_SAVING ${level}`);
+    return await this.sendCommand(`ENERGY_SAVING ${level}`);
   }
 
   async setInput(input: Inputs) {
     assert(
       Object.values(Inputs).some(availableInput => availableInput === input),
       'input must be valid'
     );
-    await this.sendCommand(`INPUT_SELECT ${input}`);
+    return await this.sendCommand(`INPUT_SELECT ${input}`);
   }
 
   async setVolume(volumeLevel: number) {
@@ -75,11 +96,11 @@ export class LGTV {
         volumeLevel <= 100,
       'volumeLevel must be an integer between 0 and 100'
     );
-    await this.sendCommand(`VOLUME_CONTROL ${volumeLevel}`);
+    return await this.sendCommand(`VOLUME_CONTROL ${volumeLevel}`);
   }
 
   async setVolumeMute(isMuted: boolean) {
     assert(typeof isMuted === 'boolean', 'isMuted must be a boolean');
-    await this.sendCommand(`VOLUME_MUTE ${isMuted ? 'on' : 'off'}`);
+    return await this.sendCommand(`VOLUME_MUTE ${isMuted ? 'on' : 'off'}`);
   }
 }

test/LGEncryption.test.ts

@@ -39,3 +39,21 @@ describe('encrypt', () => {
     mocked(Math.random).mockRestore();
   });
 });
+
+describe('decrypt', () => {
+  it('works with data from the LG document', () => {
+    const exampleKeyCode = '12345678';
+    const encryptedIv = 'd2b21ca0ad6486cb2056a8b815033508';
+    const encryptedData = 'dfe77a7de05603a59ed5316ec552fac1';
+    const exampleCipherText = Buffer.from(
+      `${encryptedIv}${encryptedData}`,
+      'hex'
+    );
+    const expectedPlainText = 'VOLUME_MUTE on\x0d\x01';
+
+    const encryption = new LGEncryption(exampleKeyCode);
+    const decryptedData = encryption.decrypt(exampleCipherText);
+
+    expect(decryptedData).toEqual(expectedPlainText);
+  });
+});