387955343

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/homebridge/HAP-NodeJS/commit/<a class=hub.com/homebridge/HAP-NodeJS/commit/<a class="double-link" href="https://git"><a class=hub.com/homebridge/HAP-NodeJS/commit/<a class="double-link" href="https://git"><a class=hub.com/homebridge/HAP-NodeJS/commit/f5c58e4a9e713e3a913af3179c59349e73da2f98">f5c58e4a9<a href="https://github.com/homebridge/HAP-NodeJS/commit/f5c58e4a9e713e3a913af3179c59349e73da2f98">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/homebridge/HAP-NodeJS/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/homebridge/HAP-NodeJS/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/homebridge/HAP-NodeJS/commit/f5c58e4a9e713e3a913af3179c59349e73da2f98&quot;&gt;f5c58e4a9&lt;/a&gt;&lt;a href=&quot;https://github.com/homebridge/HAP-NodeJS/commit/f5c58e4a9e713e3a913af3179c59349e73da2f98&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/homebridge/HAP-NodeJS/commit/f5c58e4a9e713e3a913af3179c59349e&lt;/a&gt;73da2f98&quot;>&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/homebridge/HAP-NodeJS/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/homebridge/HAP-NodeJS/commit/<a class="double-link" href="https://github.com/homebridge/HAP-NodeJS/commit/bf825fc5eddc9d35b370972febc15d9b6fafbfd7">bf825fc5e</a><a href="https://github.com/homebridge/HAP-NodeJS/commit/f5c58e4a9e713e3a913af3179c59349e73da2f98">&amp;quot;&amp;gt;bf825fc5e&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;bf825fc5e&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/homebridge/HAP-NodeJS/commit/f5c58e4a9e713e3a913af3179c59349e73da2&lt;/a&gt;f98&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/homebridge/HAP-NodeJS/commit/<a class="double-link" href="https://github.com/homebridge/HAP-NodeJS/commit/c2e0451c8">c2e0451c8">c2e0451c8</a>

Pull Request Pull Request #730: Support random setup codes and saved verifiers

Run Details

934 of 3706 branches covered (25.2%)

Branch coverage included in aggregate %.

30 of 188 new or added lines in 11 files covered. (15.96%)

4487 of 9164 relevant lines covered (48.96%)

36.16 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

15.02

/src/lib/model/AccessoryInfo.ts

import assert from 'assert';
import crypto from "crypto";
import tweetnacl from 'tweetnacl';
import util from 'util';
import { AccessoryJsonObject } from "../../internal-types";
import { MacAddress } from "../../types";
import { Categories } from '../Accessory';
import { EventedHTTPServer, HAPConnection, HAPUsername } from "../util/eventedhttp";
import { HAPStorage } from "./HAPStorage";


const packageJson = require("../../../package.json");

export const enum PermissionTypes {
  // noinspection JSUnusedGlobalSymbols
  USER = 0x00,
  ADMIN = 0x01, // admins are the only ones who can add/remove/list pairings (additionally some characteristics are restricted)
}

export type PairingInformation = {
  username: HAPUsername,
  publicKey: Buffer,
  permission: PermissionTypes,
}

/**
 * AccessoryInfo is a model class containing a subset of Accessory data relevant to the internal HAP server,
 * such as encryption keys and username. It is persisted to disk.
 */
export class AccessoryInfo {

  static readonly deviceIdPattern: RegExp = /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/;

  username: MacAddress;
  displayName: string;
  model: string; // this property is currently not saved to disk
  category: Categories;
  pincode: string | {salt: Buffer; verifier: Buffer} | null;
  signSk: Buffer;
  signPk: Buffer;
  pairedClients: Record<HAPUsername, PairingInformation>;
  pairedAdminClients: number;
  private configVersion: number = 1;
  private configHash: string;
  setupID: string;
  private lastFirmwareVersion: string = "";

  private constructor(username: MacAddress) {
    this.username = username;
    this.displayName = "";
    this.model = "";
    // @ts-ignore
    this.category = "";
    this.pincode = "";
    this.signSk = Buffer.alloc(0);
    this.signPk = Buffer.alloc(0);
    this.pairedClients = {};
    this.pairedAdminClients = 0;
    this.configHash = "";

    this.setupID = "";
  }

  /**
   * Add a paired client to memory.
   * @param {HAPUsername} username
   * @param {Buffer} publicKey
   * @param {PermissionTypes} permission
   */
  public addPairedClient(username: HAPUsername, publicKey: Buffer, permission: PermissionTypes): void {
    this.pairedClients[username] = {
      username: username,
      publicKey: publicKey,
      permission: permission
    };

    if (permission === PermissionTypes.ADMIN) {
      this.pairedAdminClients++;
    }
  };

  public updatePermission(username: HAPUsername, permission: PermissionTypes): void {
    const pairingInformation = this.pairedClients[username];

    if (pairingInformation) {
      const oldPermission = pairingInformation.permission;
      pairingInformation.permission = permission;

      if (oldPermission === PermissionTypes.ADMIN && permission !== PermissionTypes.ADMIN) {
        this.pairedAdminClients--;
      } else if (oldPermission !== PermissionTypes.ADMIN && permission === PermissionTypes.ADMIN) {
        this.pairedAdminClients++;
      }
    }
  };

  public listPairings(): PairingInformation[] {
    const array: PairingInformation[] = [];

    for (const username in this.pairedClients) {
      const pairingInformation = this.pairedClients[username] as PairingInformation;
      array.push(pairingInformation);
    }

    return array;
  };

  /**
   * Remove a paired client from memory.
   * @param connection - the session of the connection initiated the removal of the pairing
   * @param {string} username
   */
  public removePairedClient(connection: HAPConnection, username: HAPUsername): void {
    this._removePairedClient0(connection, username);

    if (this.pairedAdminClients === 0) { // if we don't have any admin clients left paired it is required to kill all normal clients
      for (const username0 in this.pairedClients) {
        this._removePairedClient0(connection, username0);
      }
    }
  };

  private _removePairedClient0(connection: HAPConnection, username: HAPUsername): void {
    if (this.pairedClients[username] && this.pairedClients[username].permission === PermissionTypes.ADMIN)
      this.pairedAdminClients--;
    delete this.pairedClients[username];

    EventedHTTPServer.destroyExistingConnectionsAfterUnpair(connection, username);
  };

  /**
   * Check if username is paired
   * @param username
   */
  public isPaired(username: HAPUsername): boolean {
    return !!this.pairedClients[username];
  };

  public hasAdminPermissions(username: HAPUsername): boolean {
    if (!username) return false;
    const pairingInformation = this.pairedClients[username];
    return !!pairingInformation && pairingInformation.permission === PermissionTypes.ADMIN;
  };

  // Gets the public key for a paired client as a Buffer, or falsy value if not paired.
  public getClientPublicKey(username: HAPUsername): Buffer | undefined {
    const pairingInformation = this.pairedClients[username];
    if (pairingInformation) {
      return pairingInformation.publicKey;
    } else {
      return undefined;
    }
  };

  // Returns a boolean indicating whether this accessory has been paired with a client.
  paired = (): boolean => {
    return Object.keys(this.pairedClients).length > 0; // if we have any paired clients, we're paired.
  }

  /**
   * Checks based on the current accessory configuration if the current configuration number needs to be incremented.
   * Additionally, if desired, it checks if the firmware version was incremented (aka the HAP-NodeJS) version did grow.
   *
   * @param configuration - The current accessory configuration.
   * @param checkFirmwareIncrement
   * @returns True if the current configuration number was incremented and thus a new TXT must be advertised.
   */
  public checkForCurrentConfigurationNumberIncrement(configuration: AccessoryJsonObject[], checkFirmwareIncrement?: boolean): boolean {
    const shasum = crypto.createHash('sha1');
    shasum.update(JSON.stringify(configuration));
    const configHash = shasum.digest('hex');

    let changed = false;

    if (configHash !== this.configHash) {
      this.configVersion++;
      this.configHash = configHash;

      this.ensureConfigVersionBounds();
      changed = true;
    }
    if (this.lastFirmwareVersion !== packageJson.version) {
      // we only check if it is different and not only if it is incremented
      // HomeKit spec prohibits firmware downgrades, but with hap-nodejs it's possible lol
      this.lastFirmwareVersion = packageJson.version;
      changed = true;
    }

    if (changed) {
      this.save();
    }

    return changed;
  }

  public getConfigVersion(): number {
    return this.configVersion;
  }

  private ensureConfigVersionBounds(): void {
    // current configuration number must be in the range of 1-65535 and wrap to 1 when it overflows

    this.configVersion = this.configVersion % (0xFFFF + 1);
    if (this.configVersion === 0) {
      this.configVersion = 1;
    }
  }

  save = () => {
    const saved = {
      displayName: this.displayName,
      category: this.category,
      pincode: typeof this.pincode === 'object' && this.pincode ?
        {salt: this.pincode.salt.toString('hex'), verifier: this.pincode.verifier.toString('hex')} :
        this.pincode,
      signSk: this.signSk.toString('hex'),
      signPk: this.signPk.toString('hex'),
      pairedClients: {},
      // moving permissions into an extra object, so there is nothing to migrate from old files.
      // if the legacy node-persist storage should be upgraded some time, it would be reasonable to combine the storage
      // of public keys (pairedClients object) and permissions.
      pairedClientsPermission: {},
      configVersion: this.configVersion,
      configHash: this.configHash,
      setupID: this.setupID,
      lastFirmwareVersion: this.lastFirmwareVersion,
    };

    for (let username in this.pairedClients) {
      const pairingInformation: PairingInformation = this.pairedClients[username];
      //@ts-ignore
      saved.pairedClients[username] = pairingInformation.publicKey.toString("hex");
      // @ts-ignore
      saved.pairedClientsPermission[username] = pairingInformation.permission;
    }

    const key = AccessoryInfo.persistKey(this.username);

    HAPStorage.storage().setItemSync(key, saved);
  }

// Gets a key for storing this AccessoryInfo in the filesystem, like "AccessoryInfo.CC223DE3CEF3.json"
  static persistKey = (username: MacAddress) => {
    return util.format("AccessoryInfo.%s.json", username.replace(/:/g, "").toUpperCase());
  }

  static create = (username: MacAddress) => {
    AccessoryInfo.assertValidUsername(username);
    const accessoryInfo = new AccessoryInfo(username);

    accessoryInfo.lastFirmwareVersion = packageJson.version;

    // Create a new unique key pair for this accessory.
    const keyPair = tweetnacl.sign.keyPair();

    accessoryInfo.signSk = Buffer.from(keyPair.secretKey);
    accessoryInfo.signPk = Buffer.from(keyPair.publicKey);

    return accessoryInfo;
  }

  static load = (username: MacAddress) => {
    AccessoryInfo.assertValidUsername(username);

    const key = AccessoryInfo.persistKey(username);
    const saved = HAPStorage.storage().getItem(key);

    if (saved) {
      const info = new AccessoryInfo(username);
      info.displayName = saved.displayName || "";
      info.category = saved.category || "";
      info.pincode = saved.pincode && typeof saved.pincode === 'object' && 'verifier' in saved.pincode && 'salt' in saved.pincode ?
        {salt: Buffer.from(saved.pincode.salt, 'hex'), verifier: Buffer.from(saved.pincode.verifier, 'hex')} :
        saved.pincode || "";
      info.signSk = Buffer.from(saved.signSk || '', 'hex');
      info.signPk = Buffer.from(saved.signPk || '', 'hex');

      info.pairedClients = {};
      for (let username in saved.pairedClients || {}) {
        const publicKey = saved.pairedClients[username];
        let permission = saved.pairedClientsPermission? saved.pairedClientsPermission[username]: undefined;
        if (permission === undefined)
          permission = PermissionTypes.ADMIN; // defaulting to admin permissions is the only suitable solution, there is no way to recover permissions

        info.pairedClients[username] = {
          username: username,
          publicKey: Buffer.from(publicKey, 'hex'),
          permission: permission
        };
        if (permission === PermissionTypes.ADMIN)
          info.pairedAdminClients++;
      }

      info.configVersion = saved.configVersion || 1;
      info.configHash = saved.configHash || "";

      info.setupID = saved.setupID || "";

      info.lastFirmwareVersion = saved.lastFirmwareVersion || packageJson.version;

      info.ensureConfigVersionBounds();

      return info;
    } else {
      return null;
    }
  }

  static remove(username: MacAddress) {
    const key = AccessoryInfo.persistKey(username);
    HAPStorage.storage().removeItemSync(key);
  }

  static assertValidUsername = (username: MacAddress) => {
    assert.ok(AccessoryInfo.deviceIdPattern.test(username),
        "The supplied username (" + username + ") is not valid " +
        "(expected a format like 'XX:XX:XX:XX:XX:XX' with XX being a valid hexadecimal string). " +
        "Note that, if you had this accessory already paired with the invalid username, you will need to repair " +
        "the accessory and reconfigure your services in the Home app. " +
        "Using an invalid username will lead to unexpected behaviour.")
  };

}


1	import assert from 'assert';	12✔
2	import crypto from "crypto";	12✔
3	import tweetnacl from 'tweetnacl';	12✔
4	import util from 'util';	12✔
5	import { AccessoryJsonObject } from "../../internal-types";
6	import { MacAddress } from "../../types";
7	import { Categories } from '../Accessory';
8	import { EventedHTTPServer, HAPConnection, HAPUsername } from "../util/eventedhttp";	12✔
9	import { HAPStorage } from "./HAPStorage";	12✔
10
11
12	const packageJson = require("../../../package.json");	12✔
13
14	export const enum PermissionTypes {	12✔
15	// noinspection JSUnusedGlobalSymbols
16	USER = 0x00,	12✔
17	ADMIN = 0x01, // admins are the only ones who can add/remove/list pairings (additionally some characteristics are restricted)	12✔
18	}
19
20	export type PairingInformation = {
21	username: HAPUsername,
22	publicKey: Buffer,
23	permission: PermissionTypes,
24	}
25
26	/**
27	* AccessoryInfo is a model class containing a subset of Accessory data relevant to the internal HAP server,
28	* such as encryption keys and username. It is persisted to disk.
29	*/
30	export class AccessoryInfo {	12✔
31
32	static readonly deviceIdPattern: RegExp = /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/;	12✔
33
34	username: MacAddress;
35	displayName: string;
36	model: string; // this property is currently not saved to disk
37	category: Categories;
38	pincode: string \| {salt: Buffer; verifier: Buffer} \| null;
39	signSk: Buffer;
40	signPk: Buffer;
41	pairedClients: Record<HAPUsername, PairingInformation>;
42	pairedAdminClients: number;
43	private configVersion: number = 1;	×
44	private configHash: string;
45	setupID: string;
46	private lastFirmwareVersion: string = "";	×
47
48	private constructor(username: MacAddress) {	×
49	this.username = username;	×
50	this.displayName = "";	×
51	this.model = "";	×
52	// @ts-ignore
53	this.category = "";	×
54	this.pincode = "";	×
55	this.signSk = Buffer.alloc(0);	×
56	this.signPk = Buffer.alloc(0);	×
57	this.pairedClients = {};	×
58	this.pairedAdminClients = 0;	×
59	this.configHash = "";	×
60
61	this.setupID = "";	×
62	}
63
64	/**
65	* Add a paired client to memory.
66	* @param {HAPUsername} username
67	* @param {Buffer} publicKey
68	* @param {PermissionTypes} permission
69	*/
70	public addPairedClient(username: HAPUsername, publicKey: Buffer, permission: PermissionTypes): void {	12✔
71	this.pairedClients[username] = {	×
72	username: username,
73	publicKey: publicKey,
74	permission: permission
75	};
76
77	if (permission === PermissionTypes.ADMIN) {	×
78	this.pairedAdminClients++;	×
79	}
80	};
81
82	public updatePermission(username: HAPUsername, permission: PermissionTypes): void {	12✔
83	const pairingInformation = this.pairedClients[username];	×
84
85	if (pairingInformation) {	×
86	const oldPermission = pairingInformation.permission;	×
87	pairingInformation.permission = permission;	×
88
89	if (oldPermission === PermissionTypes.ADMIN && permission !== PermissionTypes.ADMIN) {	×
90	this.pairedAdminClients--;	×
91	} else if (oldPermission !== PermissionTypes.ADMIN && permission === PermissionTypes.ADMIN) {	×
92	this.pairedAdminClients++;	×
93	}
94	}
95	};
96
97	public listPairings(): PairingInformation[] {	12✔
98	const array: PairingInformation[] = [];	×
99
100	for (const username in this.pairedClients) {	×
101	const pairingInformation = this.pairedClients[username] as PairingInformation;	×
102	array.push(pairingInformation);	×
103	}
104
105	return array;	×
106	};
107
108	/**
109	* Remove a paired client from memory.
110	* @param connection - the session of the connection initiated the removal of the pairing
111	* @param {string} username
112	*/
113	public removePairedClient(connection: HAPConnection, username: HAPUsername): void {	12✔
114	this._removePairedClient0(connection, username);	×
115
116	if (this.pairedAdminClients === 0) { // if we don't have any admin clients left paired it is required to kill all normal clients	×
117	for (const username0 in this.pairedClients) {	×
118	this._removePairedClient0(connection, username0);	×
119	}
120	}
121	};
122
123	private _removePairedClient0(connection: HAPConnection, username: HAPUsername): void {	12✔
124	if (this.pairedClients[username] && this.pairedClients[username].permission === PermissionTypes.ADMIN)	×
125	this.pairedAdminClients--;	×
126	delete this.pairedClients[username];	×
127
128	EventedHTTPServer.destroyExistingConnectionsAfterUnpair(connection, username);	×
129	};
130
131	/**
132	* Check if username is paired
133	* @param username
134	*/
135	public isPaired(username: HAPUsername): boolean {	12✔
136	return !!this.pairedClients[username];	×
137	};
138
139	public hasAdminPermissions(username: HAPUsername): boolean {	12✔
140	if (!username) return false;	×
141	const pairingInformation = this.pairedClients[username];	×
142	return !!pairingInformation && pairingInformation.permission === PermissionTypes.ADMIN;	×
143	};
144
145	// Gets the public key for a paired client as a Buffer, or falsy value if not paired.
146	public getClientPublicKey(username: HAPUsername): Buffer \| undefined {	12✔
147	const pairingInformation = this.pairedClients[username];	×
148	if (pairingInformation) {	×
149	return pairingInformation.publicKey;	×
150	} else {
151	return undefined;	×
152	}
153	};
154
155	// Returns a boolean indicating whether this accessory has been paired with a client.
156	paired = (): boolean => {	×
157	return Object.keys(this.pairedClients).length > 0; // if we have any paired clients, we're paired.	×
158	}
159
160	/**
161	* Checks based on the current accessory configuration if the current configuration number needs to be incremented.
162	* Additionally, if desired, it checks if the firmware version was incremented (aka the HAP-NodeJS) version did grow.
163	*
164	* @param configuration - The current accessory configuration.
165	* @param checkFirmwareIncrement
166	* @returns True if the current configuration number was incremented and thus a new TXT must be advertised.
167	*/
168	public checkForCurrentConfigurationNumberIncrement(configuration: AccessoryJsonObject[], checkFirmwareIncrement?: boolean): boolean {	12✔
169	const shasum = crypto.createHash('sha1');	×
170	shasum.update(JSON.stringify(configuration));	×
171	const configHash = shasum.digest('hex');	×
172
173	let changed = false;	×
174
175	if (configHash !== this.configHash) {	×
176	this.configVersion++;	×
177	this.configHash = configHash;	×
178
179	this.ensureConfigVersionBounds();	×
180	changed = true;	×
181	}
182	if (this.lastFirmwareVersion !== packageJson.version) {	×
183	// we only check if it is different and not only if it is incremented
184	// HomeKit spec prohibits firmware downgrades, but with hap-nodejs it's possible lol
185	this.lastFirmwareVersion = packageJson.version;	×
186	changed = true;	×
187	}
188
189	if (changed) {	×
190	this.save();	×
191	}
192
193	return changed;	×
194	}
195
196	public getConfigVersion(): number {	12✔
197	return this.configVersion;	×
198	}
199
200	private ensureConfigVersionBounds(): void {	12✔
201	// current configuration number must be in the range of 1-65535 and wrap to 1 when it overflows
202
203	this.configVersion = this.configVersion % (0xFFFF + 1);	×
204	if (this.configVersion === 0) {	×
205	this.configVersion = 1;	×
206	}
207	}
208
209	save = () => {	×
210	const saved = {	×
211	displayName: this.displayName,
212	category: this.category,
213	pincode: typeof this.pincode === 'object' && this.pincode ?	×
214	{salt: this.pincode.salt.toString('hex'), verifier: this.pincode.verifier.toString('hex')} :	×
215	this.pincode,
216	signSk: this.signSk.toString('hex'),
217	signPk: this.signPk.toString('hex'),
218	pairedClients: {},
219	// moving permissions into an extra object, so there is nothing to migrate from old files.
220	// if the legacy node-persist storage should be upgraded some time, it would be reasonable to combine the storage
221	// of public keys (pairedClients object) and permissions.
222	pairedClientsPermission: {},
223	configVersion: this.configVersion,
224	configHash: this.configHash,
225	setupID: this.setupID,
226	lastFirmwareVersion: this.lastFirmwareVersion,
227	};
228
229	for (let username in this.pairedClients) {	×
230	const pairingInformation: PairingInformation = this.pairedClients[username];	×
231	//@ts-ignore
232	saved.pairedClients[username] = pairingInformation.publicKey.toString("hex");	×
233	// @ts-ignore
234	saved.pairedClientsPermission[username] = pairingInformation.permission;	×
235	}
236
237	const key = AccessoryInfo.persistKey(this.username);	×
238
239	HAPStorage.storage().setItemSync(key, saved);	×
240	}
241
242	// Gets a key for storing this AccessoryInfo in the filesystem, like "AccessoryInfo.CC223DE3CEF3.json"
243	static persistKey = (username: MacAddress) => {	12✔
244	return util.format("AccessoryInfo.%s.json", username.replace(/:/g, "").toUpperCase());	×
245	}
246
247	static create = (username: MacAddress) => {	12✔
248	AccessoryInfo.assertValidUsername(username);	×
249	const accessoryInfo = new AccessoryInfo(username);	×
250
251	accessoryInfo.lastFirmwareVersion = packageJson.version;	×
252
253	// Create a new unique key pair for this accessory.
254	const keyPair = tweetnacl.sign.keyPair();	×
255
256	accessoryInfo.signSk = Buffer.from(keyPair.secretKey);	×
257	accessoryInfo.signPk = Buffer.from(keyPair.publicKey);	×
258
259	return accessoryInfo;	×
260	}
261
262	static load = (username: MacAddress) => {	12✔
263	AccessoryInfo.assertValidUsername(username);	×
264
265	const key = AccessoryInfo.persistKey(username);	×
266	const saved = HAPStorage.storage().getItem(key);	×
267
268	if (saved) {	×
269	const info = new AccessoryInfo(username);	×
270	info.displayName = saved.displayName \|\| "";	×
271	info.category = saved.category \|\| "";	×
NEW 272	info.pincode = saved.pincode && typeof saved.pincode === 'object' && 'verifier' in saved.pincode && 'salt' in saved.pincode ?	×
273	{salt: Buffer.from(saved.pincode.salt, 'hex'), verifier: Buffer.from(saved.pincode.verifier, 'hex')} :	×
274	saved.pincode \|\| "";	×
275	info.signSk = Buffer.from(saved.signSk \|\| '', 'hex');	×
276	info.signPk = Buffer.from(saved.signPk \|\| '', 'hex');	×
277
278	info.pairedClients = {};	×
279	for (let username in saved.pairedClients \|\| {}) {	×
280	const publicKey = saved.pairedClients[username];	×
281	let permission = saved.pairedClientsPermission? saved.pairedClientsPermission[username]: undefined;	×
282	if (permission === undefined)	×
283	permission = PermissionTypes.ADMIN; // defaulting to admin permissions is the only suitable solution, there is no way to recover permissions	×
284
285	info.pairedClients[username] = {	×
286	username: username,
287	publicKey: Buffer.from(publicKey, 'hex'),
288	permission: permission
289	};
290	if (permission === PermissionTypes.ADMIN)	×
291	info.pairedAdminClients++;	×
292	}
293
294	info.configVersion = saved.configVersion \|\| 1;	×
295	info.configHash = saved.configHash \|\| "";	×
296
297	info.setupID = saved.setupID \|\| "";	×
298
299	info.lastFirmwareVersion = saved.lastFirmwareVersion \|\| packageJson.version;	×
300
301	info.ensureConfigVersionBounds();	×
302
303	return info;	×
304	} else {
305	return null;	×
306	}
307	}
308
309	static remove(username: MacAddress) {	12✔
310	const key = AccessoryInfo.persistKey(username);	×
311	HAPStorage.storage().removeItemSync(key);	×
312	}
313
314	static assertValidUsername = (username: MacAddress) => {	12✔
315	assert.ok(AccessoryInfo.deviceIdPattern.test(username),	15✔
316	"The supplied username (" + username + ") is not valid " +
317	"(expected a format like 'XX:XX:XX:XX:XX:XX' with XX being a valid hexadecimal string). " +
318	"Note that, if you had this accessory already paired with the invalid username, you will need to repair " +
319	"the accessory and reconfigure your services in the Home app. " +
320	"Using an invalid username will lead to unexpected behaviour.")
321	};
322
323	}	12✔
324

homebridge / HAP-NodeJS / 387955343

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous