@stoprocent/bleno 0.7.0

package/lib/hci-socket/mgmt.js

@@ -0,0 +1,89 @@
+const debug = require('debug')('mgmt');
+
+const BluetoothHciSocket = require('@stoprocent/bluetooth-hci-socket');
+
+const LTK_INFO_SIZE = 36;
+
+const MGMT_OP_LOAD_LONG_TERM_KEYS = 0x0013;
+
+class Mgmt {
+  constructor () {
+    this._socket = new BluetoothHciSocket();
+    this._ltkInfos = [];
+
+    this._socket.on('data', this.onSocketData.bind(this));
+    this._socket.on('error', this.onSocketError.bind(this));
+
+    this._socket.bindControl();
+    this._socket.start();
+  }
+
+  onSocketData (data) {
+    debug('on data ->' + data.toString('hex'));
+  }
+
+  onSocketError (error) {
+    debug('on error ->' + error.message);
+  }
+
+  addLongTermKey (address, addressType, authenticated, master, ediv, rand, key) {
+    const ltkInfo = Buffer.alloc(LTK_INFO_SIZE);
+
+    address.copy(ltkInfo, 0);
+    ltkInfo.writeUInt8(addressType.readUInt8(0) + 1, 6); // BDADDR_LE_PUBLIC = 0x01, BDADDR_LE_RANDOM 0x02, so add one
+
+    ltkInfo.writeUInt8(authenticated, 7);
+    ltkInfo.writeUInt8(master, 8);
+    ltkInfo.writeUInt8(key.length, 9);
+
+    ediv.copy(ltkInfo, 10);
+    rand.copy(ltkInfo, 12);
+    key.copy(ltkInfo, 20);
+
+    this._ltkInfos.push(ltkInfo);
+
+    this.loadLongTermKeys();
+  }
+
+  clearLongTermKeys () {
+    this._ltkInfos = [];
+
+    this.loadLongTermKeys();
+  }
+
+  loadLongTermKeys () {
+    const numLongTermKeys = this._ltkInfos.length;
+    const op = Buffer.alloc(2 + numLongTermKeys * LTK_INFO_SIZE);
+
+    op.writeUInt16LE(numLongTermKeys, 0);
+
+    for (let i = 0; i < numLongTermKeys; i++) {
+      this._ltkInfos[i].copy(op, 2 + i * LTK_INFO_SIZE);
+    }
+
+    this.write(MGMT_OP_LOAD_LONG_TERM_KEYS, 0, op);
+  }
+
+  write (opcode, index, data) {
+    let length = 0;
+
+    if (data) {
+      length = data.length;
+    }
+
+    const pkt = Buffer.alloc(6 + length);
+
+    pkt.writeUInt16LE(opcode, 0);
+    pkt.writeUInt16LE(index, 2);
+    pkt.writeUInt16LE(length, 4);
+
+    if (length) {
+      data.copy(pkt, 6);
+    }
+
+    debug('writing -> ' + pkt.toString('hex'));
+    this._socket.write(pkt);
+  }
+}
+
+module.exports = new Mgmt();

package/lib/hci-socket/smp.js

@@ -0,0 +1,160 @@
+const { EventEmitter } = require('events');
+const crypto = require('./crypto');
+const mgmt = require('./mgmt');
+
+const SMP_CID = 0x0006;
+
+const SMP_PAIRING_REQUEST = 0x01;
+const SMP_PAIRING_RESPONSE = 0x02;
+const SMP_PAIRING_CONFIRM = 0x03;
+const SMP_PAIRING_RANDOM = 0x04;
+const SMP_PAIRING_FAILED = 0x05;
+const SMP_ENCRYPT_INFO = 0x06;
+const SMP_MASTER_IDENT = 0x07;
+
+const SMP_UNSPECIFIED = 0x08;
+
+class Smp extends EventEmitter {
+  constructor (aclStream, localAddressType, localAddress, remoteAddressType, remoteAddress) {
+    super();
+
+    this._aclStream = aclStream;
+
+    this._iat = Buffer.from([(remoteAddressType === 'random') ? 0x01 : 0x00]);
+    this._ia = Buffer.from(remoteAddress.split(':').reverse().join(''), 'hex');
+    this._rat = Buffer.from([(localAddressType === 'random') ? 0x01 : 0x00]);
+    this._ra = Buffer.from(localAddress.split(':').reverse().join(''), 'hex');
+
+    this._stk = null;
+    this._random = null;
+    this._diversifier = null;
+
+    this.onAclStreamDataBinded = this.onAclStreamData.bind(this);
+    this.onAclStreamEncryptChangeBinded = this.onAclStreamEncryptChange.bind(this);
+    this.onAclStreamLtkNegReplyBinded = this.onAclStreamLtkNegReply.bind(this);
+    this.onAclStreamEndBinded = this.onAclStreamEnd.bind(this);
+
+    this._aclStream.on('data', this.onAclStreamDataBinded);
+    this._aclStream.on('encryptChange', this.onAclStreamEncryptChangeBinded);
+    this._aclStream.on('ltkNegReply', this.onAclStreamLtkNegReplyBinded);
+    this._aclStream.on('end', this.onAclStreamEndBinded);
+  }
+
+  onAclStreamData (cid, data) {
+    if (cid !== SMP_CID) {
+      return;
+    }
+
+    const code = data.readUInt8(0);
+
+    if (SMP_PAIRING_REQUEST === code) {
+      this.handlePairingRequest(data);
+    } else if (SMP_PAIRING_CONFIRM === code) {
+      this.handlePairingConfirm(data);
+    } else if (SMP_PAIRING_RANDOM === code) {
+      this.handlePairingRandom(data);
+    } else if (SMP_PAIRING_FAILED === code) {
+      this.handlePairingFailed(data);
+    }
+  }
+
+  onAclStreamEncryptChange (encrypted) {
+    if (encrypted) {
+      if (this._stk && this._diversifier && this._random) {
+        this.write(Buffer.concat([
+          Buffer.from([SMP_ENCRYPT_INFO]),
+          this._stk
+        ]));
+
+        this.write(Buffer.concat([
+          Buffer.from([SMP_MASTER_IDENT]),
+          this._diversifier,
+          this._random
+        ]));
+      }
+    }
+  }
+
+  onAclStreamLtkNegReply () {
+    this.write(Buffer.from([
+      SMP_PAIRING_FAILED,
+      SMP_UNSPECIFIED
+    ]));
+
+    this.emit('fail');
+  }
+
+  onAclStreamEnd () {
+    this._aclStream.removeListener('data', this.onAclStreamDataBinded);
+    this._aclStream.removeListener('encryptChange', this.onAclStreamEncryptChangeBinded);
+    this._aclStream.removeListener('ltkNegReply', this.onAclStreamLtkNegReplyBinded);
+    this._aclStream.removeListener('end', this.onAclStreamEndBinded);
+  }
+
+  handlePairingRequest (data) {
+    this._preq = data;
+
+    this._pres = Buffer.from([
+      SMP_PAIRING_RESPONSE,
+      0x03, // IO capability: NoInputNoOutput
+      0x00, // OOB data: Authentication data not present
+      0x01, // Authentication requirement: Bonding - No MITM
+      0x10, // Max encryption key size
+      0x00, // Initiator key distribution: <none>
+      0x01 // Responder key distribution: EncKey
+    ]);
+
+    this.write(this._pres);
+  }
+
+  handlePairingConfirm (data) {
+    this._pcnf = data;
+
+    this._tk = Buffer.from('00000000000000000000000000000000', 'hex');
+    this._r = crypto.r();
+
+    this.write(Buffer.concat([
+      Buffer.from([SMP_PAIRING_CONFIRM]),
+      crypto.c1(this._tk, this._r, this._pres, this._preq, this._iat, this._ia, this._rat, this._ra)
+    ]));
+  }
+
+  handlePairingRandom (data) {
+    const r = data.slice(1);
+
+    const pcnf = Buffer.concat([
+      Buffer.from([SMP_PAIRING_CONFIRM]),
+      crypto.c1(this._tk, r, this._pres, this._preq, this._iat, this._ia, this._rat, this._ra)
+    ]);
+
+    if (this._pcnf.toString('hex') === pcnf.toString('hex')) {
+      this._diversifier = Buffer.from('0000', 'hex');
+      this._random = Buffer.from('0000000000000000', 'hex');
+      this._stk = crypto.s1(this._tk, this._r, r);
+
+      mgmt.addLongTermKey(this._ia, this._iat, 0, 0, this._diversifier, this._random, this._stk);
+
+      this.write(Buffer.concat([
+        Buffer.from([SMP_PAIRING_RANDOM]),
+        this._r
+      ]));
+    } else {
+      this.write(Buffer.from([
+        SMP_PAIRING_FAILED,
+        SMP_PAIRING_CONFIRM
+      ]));
+
+      this.emit('fail');
+    }
+  }
+
+  handlePairingFailed (data) {
+    this.emit('fail');
+  }
+
+  write (data) {
+    this._aclStream.write(SMP_CID, data);
+  }
+}
+
+module.exports = Smp;

package/lib/hci-socket/vs.js

@@ -0,0 +1,156 @@
+// This file is based on the bluez implementation
+// https://github.com/bluez/bluez/blob/master/tools/bdaddr.c
+
+const OGF_VENDOR_CMD = 0x3f;
+
+const OCF_ERICSSON_WRITE_BD_ADDR = 0x000d;
+const OCF_TI_WRITE_BD_ADDR = 0x0006;
+const OCF_LINUX_FOUNDATION_WRITE_BD_ADDR = 0x0006;
+const OCF_BCM_WRITE_BD_ADDR = 0x0001;
+const OCF_ZEEVO_WRITE_BD_ADDR = 0x0001;
+const OCF_MRVL_WRITE_BD_ADDR = 0x0022;
+const OCF_ERICSSON_STORE_IN_FLASH = 0x0022;
+const ERICSSON_STORE_IN_FLASH_CP_SIZE = 0xFF;
+
+function parseAddress (address) {
+  // Parse MAC Address as in 00:00:00:00:00:00 into Buffer (needs to reverse byte order)
+  const macAddress = Buffer.from(address.split(':').reverse().join(''), 'hex');
+
+  if (Buffer.isBuffer(macAddress) && macAddress.byteLength !== 6) {
+    throw new Error('Invalid MAC Address. Should be formated as 00:00:00:00:00:00 string.');
+  }
+
+  return macAddress;
+}
+
+// eslint-disable-next-line camelcase
+function csr_write_bd_addr (address) {
+  // Parse MAC Address
+  const macAddress = parseAddress(address);
+
+  if (macAddress === null) {
+    return null;
+  }
+
+  // Base command
+  const base = Buffer.from([
+    0x02, 0x00, 0x0c, 0x00, 0x11, 0x47, 0x03, 0x70,
+    0x00, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  ]);
+
+  // Command
+  const cmd = Buffer.alloc(3 + base.byteLength);
+
+  cmd.writeUInt16LE(0x00 | OGF_VENDOR_CMD << 10, 0);
+  cmd.writeUInt8(0xC2, 2);
+
+  base.writeUint8(macAddress.readUInt8(2), 16);
+  base.writeUint8(0x00, 17);
+  base.writeUint8(macAddress.readUInt8(0), 18);
+  base.writeUint8(macAddress.readUInt8(1), 19);
+  base.writeUint8(macAddress.readUInt8(3), 20);
+  base.writeUint8(0x00, 21);
+  base.writeUint8(macAddress.readUInt8(4), 22);
+  base.writeUint8(macAddress.readUInt8(5), 23);
+  base.copy(cmd, 3);
+
+  return cmd;
+}
+
+// eslint-disable-next-line camelcase
+function ericsson_store_in_flash (user_id, data) {
+  // Check Data
+  if (Buffer.isBuffer(data) === false || data.byteLength > OCF_ERICSSON_STORE_IN_FLASH - 2) {
+    return null;
+  }
+
+  // Command
+  const cmd = Buffer.alloc(3 + ERICSSON_STORE_IN_FLASH_CP_SIZE);
+
+  cmd.writeUInt16LE(OCF_ERICSSON_STORE_IN_FLASH | OGF_VENDOR_CMD << 10, 0);
+  cmd.writeUInt8(ERICSSON_STORE_IN_FLASH_CP_SIZE, 2);
+  cmd.writeUInt8(user_id, 3); // user_id
+  cmd.writeUInt8(data.byteLength, 4); // flash_length
+  data.copy(cmd, 5); // flash_data
+
+  return cmd;
+}
+
+// eslint-disable-next-line camelcase
+function st_write_bd_addr (address) {
+  // Parse MAC Address
+  const macAddress = parseAddress(address);
+
+  if (macAddress === null) {
+    return null;
+  }
+
+  return ericsson_store_in_flash(0xFE, macAddress);
+}
+
+// eslint-disable-next-line camelcase
+function mrvl_write_bd_addr (address) {
+  // Parse MAC Address
+  const macAddress = parseAddress(address);
+
+  if (macAddress === null) {
+    return null;
+  }
+
+  // Command
+  const cmd = Buffer.alloc(11);
+
+  cmd.writeUInt16LE(OCF_MRVL_WRITE_BD_ADDR | OGF_VENDOR_CMD << 10, 0);
+  cmd.writeUInt8(0x08, 2);
+  cmd.writeUInt8(0xFE, 3); // parameter_id
+  cmd.writeUInt8(0x06, 4); // bdaddr_len
+  macAddress.copy(cmd, 5); // bdaddr
+
+  return cmd;
+}
+
+// eslint-disable-next-line camelcase
+function write_common_bd_addr (OCF_VS_WRITE_BD_ADDR) {
+  // Return a function
+  return (address) => {
+    // Parse MAC Address
+    const macAddress = parseAddress(address);
+
+    if (macAddress === null) {
+      return null;
+    }
+
+    // Command
+    const cmd = Buffer.alloc(9);
+
+    cmd.writeUInt16LE(OCF_VS_WRITE_BD_ADDR | OGF_VENDOR_CMD << 10, 0);
+    cmd.writeUInt8(0x06, 2);
+    macAddress.copy(cmd, 3); // bdaddr
+
+    return cmd;
+  };
+}
+
+const vendors = new Map();
+
+vendors.set(0, write_common_bd_addr(OCF_ERICSSON_WRITE_BD_ADDR));
+vendors.set(10, csr_write_bd_addr);
+vendors.set(13, write_common_bd_addr(OCF_TI_WRITE_BD_ADDR));
+vendors.set(15, write_common_bd_addr(OCF_BCM_WRITE_BD_ADDR));
+vendors.set(18, write_common_bd_addr(OCF_ZEEVO_WRITE_BD_ADDR));
+vendors.set(48, st_write_bd_addr);
+vendors.set(57, write_common_bd_addr(OCF_ERICSSON_WRITE_BD_ADDR));
+vendors.set(72, mrvl_write_bd_addr);
+vendors.set(1521, write_common_bd_addr(OCF_LINUX_FOUNDATION_WRITE_BD_ADDR));
+
+module.exports = {
+  // Vendor Specific Set Address
+  setAddressCmd: (manufacturer, address) => {
+    const generateCommand = vendors.get(manufacturer);
+    if (typeof generateCommand === 'function') {
+      return generateCommand(address) || null;
+    }
+    return null;
+  }
+};

package/lib/mac/binding.gyp

@@ -0,0 +1,39 @@
+{
+  'variables': {
+    'openssl_fips' : '' 
+  },
+  'targets': [
+    {
+      'target_name': 'binding',
+      'sources': [ 
+        'src/bleno_mac.mm', 
+        'src/napi_objc.mm', 
+        'src/ble_peripheral_manager.mm', 
+        'src/objc_cpp.mm',
+        'src/callbacks.mm' 
+      ],
+      'include_dirs': [
+        "<!(node -p \"require('node-addon-api').include_dir\")",
+        "<!@(node -p \"require('napi-thread-safe-callback').include\")"
+      ],
+      'cflags!': [ '-fno-exceptions' ],
+      'cflags_cc!': [ '-fno-exceptions' ],
+      "defines": ["NAPI_CPP_EXCEPTIONS"],
+      'xcode_settings': {
+        'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+        'MACOSX_DEPLOYMENT_TARGET': '10.13',
+        'CLANG_CXX_LIBRARY': 'libc++',
+        'OTHER_CFLAGS': [
+          '-fobjc-arc',
+          '-arch x86_64',
+          '-arch arm64'
+        ],
+        'OTHER_LDFLAGS': [
+          '-framework CoreBluetooth',
+          '-arch x86_64',
+          '-arch arm64'
+        ]
+      }
+    }
+  ]
+}

package/lib/mac/bindings.js

@@ -0,0 +1,12 @@
+const events = require('events');
+const util = require('util');
+
+const { resolve } = require('path');
+const dir = resolve(__dirname, '..', '..');
+const binding = require('node-gyp-build')(dir);
+
+const { BlenoMac } = binding;
+
+util.inherits(BlenoMac, events.EventEmitter);
+
+module.exports = BlenoMac;

package/lib/mac/src/ble_peripheral_manager.h

@@ -0,0 +1,32 @@
+//
+//  ble_peripheral_manager.h
+//  bleno-mac-native
+//
+//  Created by Georg Vienna on 28.08.18.
+//
+
+#pragma once
+
+#import <CoreBluetooth/CoreBluetooth.h>
+
+#import "callbacks.h"
+
+#import <map>
+
+@interface BLEPeripheralManager : NSObject {
+    @public Emit emit;
+    @public std::map<CBUUID *, EmitCharacteristic> emitters;
+}
+
+- (nonnull instancetype)init NS_DESIGNATED_INITIALIZER;
+
+- (void)start;
+- (void)startAdvertising:(NSString * _Nonnull)name serviceUUIDs:(NSArray<CBUUID *> * _Nonnull)serviceUUIDs;
+- (void)startAdvertisingIBeacon:(NSData * _Nullable)data;
+- (void)startAdvertisingWithEIRData:(NSData * _Nullable)data;
+- (void)stopAdvertising;
+- (void)setServices:(NSArray<CBMutableService *> * _Nonnull)services;
+- (void)disconnect;
+- (void)updateRssi;
+
+@end