add join parser

houluy · houluy · commit 89e2923be0a6 · 2018-12-20T11:08:29.000+08:00
diff --git a/index.js b/index.js
@@ -74,6 +74,7 @@ mqClient.connect()
             if (udpUlJSON.pushData) {
               return udpHandler.pushDataParser(udpUlJSON)
                 .then((pushData) => {
+                  console.log(pushData);
                   return gatewayHandler.uploadPushData(pushData);
                 });
             } else {
diff --git a/lib/joinHandler/joinHandler.js b/lib/joinHandler/joinHandler.js
@@ -1,5 +1,9 @@
 const bluebird = require('bluebird');
-const { consts, utils } = require('../lora-lib');
+const { consts, utils, ERROR } = require('../lora-lib');
+const slice = utils.bufferSlice;
+const reverse = utils.bufferReverse;
+const cmac = require('node-aes-cmac').aesCmac;
+const crypto = require('crypto');
 
 class JoinHandler {
   constructor(DeviceInfo, log) {
@@ -8,25 +12,53 @@ class JoinHandler {
   }
 
   parser(phyPayloadJSON) {
+    const MACPayload = this.joinReqParser(phyPayloadJSON.macPayload);
     const phyPayload = {
       MHDR: phyPayloadJSON.mhdrJSON,
-      MHDRRaw: phyPayloadJSON.mhdr,
-      MACPayload: phyPayloadJSON.macPayload,
+      MACPayload,
       MIC: phyPayloadJSON.mic,
     };
-    return bluebird.resolve(phyPayload);
+
+    const MICfields = {
+      MHDR: phyPayloadJSON.mhdr,
+      AppEUI: MACPayload.AppEUI,
+      DevEUI: MACPayload.DevEUI,
+      DevNonce: MACPayload.DevNonce,
+      MIC: phyPayloadJSON.mic,
+    };
+
+    const query = { DevEUI: MACPayload.DevEUI };
+    const attr = ['AppKey'];
+    return this.DeviceInfo.readItem(query, attr)
+      .then((res) => {
+        return this.micVerification(MICfields, res.AppKey, phyPayloadJSON.mic);
+      })
+      .then(() => {
+        return bluebird.resolve(phyPayload);
+      });
+
   }
 
-  packager(phyPayloadJSON) {
-    const MHDR = this.MHDRPackager(phyPayloadJSON.MHDR);
-    const MACPayload = phyPayloadJSON.MACPayload;
+  packager(phyPayloadJSON, key) {
+    phyPayloadJSON.MHDR = this.MHDRPackager(phyPayloadJSON.MHDR);
+    const MACPayloadJSON = phyPayloadJSON.MACPayload;
+    const MIC = this.joinMICCalculator(phyPayloadJSON, key, 'accept');
+    let macpayload = Buffer.concat([
+      reverse(MACPayloadJSON.AppNonce),
+      reverse(MACPayloadJSON.NetID),
+      reverse(MACPayloadJSON.DevAddr),
+      reverse(MACPayloadJSON.DLSettings),
+      reverse(MACPayloadJSON.RxDelay),
+    ]);
+    if ('CFList' in MACPayloadJSON) {
+      macpayload = Buffer.concat([macpayload, MACPayloadJSON.CFList]);
+    }
 
-    /*this.DeviceInfo.createDeviceInfo(
-      phyPayloadJSON.DevAddr,
-      phyPayloadJSON.NwkSKey,
-      phyPayloadJSON.AppSKey
-    );*/
-    return bluebird.resolve(Buffer.concat([MHDR, MACPayload]));
+    macpayload = Buffer.concat([macpayload, MIC]);
+
+    const encmacpayload = this.AcptEncryption(macpayload, key);
+    const phypayload = Buffer.concat([phyPayloadJSON.MHDR, encmacpayload]);
+    return bluebird.resolve(phypayload);
   }
 
   MHDRPackager(mhdr) {
@@ -35,6 +67,84 @@ class JoinHandler {
     utils.bitwiseAssigner(MHDR, consts.MAJOR_OFFSET, consts.MAJOR_LEN, mhdr.Major);
     return MHDR;
   }
+
+  joinReqParser (MACPayload) {
+    const joinReqJSON = {};
+    joinReqJSON.AppEUI = slice(MACPayload, consts.JOINEUI_OFFSET, consts.DEVEUI_OFFSET);
+    joinReqJSON.DevEUI = slice(MACPayload, consts.DEVEUI_OFFSET, consts.DEVNONCE_OFFSET);
+    joinReqJSON.DevNonce = slice(MACPayload, consts.DEVNONCE_OFFSET);
+    return joinReqJSON;
+  }
+
+  micVerification (requiredFields, key, receivedMIC) {
+    return new bluebird((resolve, reject) => {
+      const calculatedMIC = this.joinMICCalculator(requiredFields, key, 'request');
+      if (receivedMIC.equals(calculatedMIC)) {
+        return resolve({});
+      } else {
+        const errorMessage = {
+          message: 'MIC Mismatch',
+          DevEUI: requiredFields.DevEUI,
+          AppEUI: requiredFields.AppEUI,
+        };
+        return reject(new ERROR.MICMismatchError(errorMessage));
+      }
+
+    });
+  };
+
+  joinMICCalculator (requiredFields, key, type) {
+    let micPayload;
+    let bufferArray;
+    switch (type) {
+      case 'request': {
+        bufferArray = [
+          reverse(requiredFields.MHDR),
+          reverse(requiredFields.AppEUI),
+          reverse(requiredFields.DevEUI),
+          reverse(requiredFields.DevNonce)
+        ];
+        micPayload = Buffer.concat(bufferArray, consts.BLOCK_LEN_REQ_MIC);
+        break;
+      }
+      case 'accept': {
+        bufferArray = [
+          reverse(requiredFields.MHDR),
+          reverse(requiredFields.MACPayload.AppNonce),
+          reverse(requiredFields.MACPayload.NetID),
+          reverse(requiredFields.MACPayload.DevAddr),
+          reverse(requiredFields.MACPayload.DLSettings),
+          reverse(requiredFields.MACPayload.RxDelay)
+        ];
+        micPayload = Buffer.concat(bufferArray, consts.BLOCK_LEN_ACPT_MIC_BASE);
+        if (requiredFields.MACPayload.hasOwnProperty('CFList')) {
+          micPayload = Buffer.concat([
+            micPayload,
+            reverse(requiredFields.MACPayload.CFList)
+          ], consts.BLOCK_LEN_ACPT_MIC_BASE + requiredFields.CFList.length);
+        }
+
+        break;
+      }
+    }
+    const options = {
+      returnAsBuffer: true,
+    };
+
+    return cmac(
+      key,
+      micPayload,
+      options
+    ).slice(0, consts.V102_CMAC_LEN);
+  }
+
+  AcptEncryption (acpt, key) {
+    const iv = '';
+    const cipher = crypto.createDecipheriv(consts.ENCRYPTION_ALGO, key, iv);
+    cipher.setAutoPadding(false);
+    return cipher.update(acpt);
+  };
+
 }
 
 module.exports = JoinHandler;
diff --git a/lib/lora-lib b/lib/lora-lib
@@ -1 +1 @@
-Subproject commit 33c9625c05764fd2335e20ccf29c6325189d9d5a
+Subproject commit cbc63b68b02ccbe0c46ed738f49647321c91a9df
diff --git a/lib/phyHandler/phyPackager.js b/lib/phyHandler/phyPackager.js
@@ -28,8 +28,10 @@ PHYPackager.FHDRPackager = function (FHDRJSON) {
   reverse(FHDRJSON.DevAddr).copy(FHDR, consts.MP_DEVADDR_OFFSET);
   reverse(FCtrl).copy(FHDR, consts.MP_FCTRL_OFFSET);
   slice(FHDRJSON.FCnt, consts.FCNT_LEAST_OFFSET).copy(FHDR, consts.MP_FCNT_OFFSET);
+  console.log(FHDRJSON);
   if (FHDRJSON.FCtrl.FOptsLen > 0) {
     const FOpts = MACPackager.packager(FHDRJSON.FOpts);
+    console.log(FOpts);
     FHDR = Buffer.concat([FHDR, FOpts]);
   }
 
@@ -48,26 +50,31 @@ PHYPackager.FCtrlPackager = function (FCtrlJSON) {
 PHYPackager.prototype.packager = function (phyPayloadJSON) {
   const MType = phyPayloadJSON.MHDR.MType;
   const MACPayload = phyPayloadJSON.MACPayload;
-  if (MACPayload.FPort !== 0 && !MACPayload.FPort) {
-    MACPayload.FPort = Buffer.alloc(0);
-  }
-
-  if (!MACPayload.FRMPayload) {
-    MACPayload.FRMPayload = Buffer.alloc(0);
-  } else if (MACPayload.FPort.readUInt8() == consts.MACCOMMANDPORT.readUInt8()) {
-    MACPayload.FRMPayload = MACPackager.packager(MACPayload.FRMPayload);
-  }
 
   let MHDR;
   let FHDR;
 
   //const MType = utils.bitwiseFilter(phyPayloadJSON.MHDR, consts.MTYPE_OFFSET, consts.MTYPE_LEN);
   switch (MType) {
     case consts.JOIN_ACCEPT: {
-      return this.joinHandler.packager(phyPayloadJSON);
+      const devaddr = MACPayload.DevAddr;
+      return this.DeviceInfo.read(devaddr, ['AppKey'])
+      .then((key) => {
+        return this.joinHandler.packager(phyPayloadJSON, key.AppKey);
+      });
     }
     case consts.UNCONFIRMED_DATA_DOWN:
     case consts.CONFIRMED_DATA_DOWN: {
+      if (MACPayload.FPort !== 0 && !MACPayload.FPort) {
+        MACPayload.FPort = Buffer.alloc(0);
+      }
+
+      if (!MACPayload.FRMPayload) {
+        MACPayload.FRMPayload = Buffer.alloc(0);
+      } else if (MACPayload.FPort.readUInt8() == consts.MACCOMMANDPORT.readUInt8()) {
+        MACPayload.FRMPayload = MACPackager.packager(MACPayload.FRMPayload);
+      }
+
       MHDR = PHYPackager.MHDRPackager(phyPayloadJSON.MHDR);
       FHDR = PHYPackager.FHDRPackager(MACPayload.FHDR);
       break;
diff --git a/lib/phyHandler/phyParser.js b/lib/phyHandler/phyParser.js
@@ -253,7 +253,6 @@ PHYParser.prototype.parser = function (phyPayloadRaw) {
             MACPayload: {
               FHDR: macPayloadJSON.fhdrJSON,
             },
-            MIC: phyPayloadJSON.mic,
           };
 
           if (macPayloadJSON.FPort) {
diff --git a/lib/phyHandler/phyUtils.js b/lib/phyHandler/phyUtils.js
@@ -56,6 +56,7 @@ const _this = new function () {
 
     block[consts.BLOCK_LENMSG_OFFSET] = msg.length;
     const cmacBlock = Buffer.concat([block, msg], consts.BLOCK_LEN + msg.length);
+    console.log(cmacBlock);
     const options = { returnAsBuffer: true };
     return cmac(
       key,
diff --git a/test/unit/lib/cmdHandler/MACCmdPackager.test.js b/test/unit/lib/cmdHandler/MACCmdPackager.test.js
@@ -30,6 +30,7 @@ const maccommand = '01010245670389abcdef';
 describe('Test MACCmd Packager', () => {
   it('test packager', () => {
     const res = macCmdPackager.packager(cmdArr);
+    console.log(res);
     expect(res.toString('hex')).to.equal(maccommand);
   });
 });
diff --git a/test/unit/lib/mqClient/kafka/kafkaClient.test.js b/test/unit/lib/mqClient/kafka/kafkaClient.test.js
@@ -47,14 +47,15 @@ describe('Test MQ client', () => {
     const len = 10;
     const message = crypto.randomBytes(len).toString('hex');
 
-    mqClient.connect()
+    return mqClient.connect()
       .then(() => {
         mqClient.message((res) => {
           expect(res.value).to.equal(message);
           done();
         });
-        mqClient.publish(topic, message);
-      });
+        return mqClient.publish(topic, message);
+      })
+      .then(() => done(), done);
   }).timeout(config.mocha.timeout);
   after('Close MQ client', (done) => {
     mqClient.disconnect()
diff --git a/test/unit/lib/phyHandler/phyPackager.test.js b/test/unit/lib/phyHandler/phyPackager.test.js
@@ -21,16 +21,16 @@ const modelIns = {
   RedisModel: {},
   MySQLModel: {},
 };
-for (let model in Models.RedisModel) {
-  modelIns.RedisModel[model] = new Models.RedisModel[model](db.RedisClient);
+for (let model in Models.RedisModels) {
+  modelIns.RedisModel[model] = new Models.RedisModels[model](db.RedisClient);
 }
 
-for (let model in Models.MySQLModel) {
-  modelIns.MySQLModel[model] = new Models.MySQLModel[model](db.MySQLClient);
+for (let model in Models.MySQLModels) {
+  modelIns.MySQLModel[model] = new Models.MySQLModels[model](db.MySQLClient);
 }
 
 const PhyPackager = require(join('lib/phyHandler/phyPackager'));
-const phyPackager = new PhyPackager(modelIns.MySQLModel.DeviceInfo, null, log);
+const phyPackager = new PhyPackager(modelIns.RedisModel.DeviceInfo, null, log);
 
 describe('Test PHY packager', () => {
 
@@ -41,7 +41,7 @@ describe('Test PHY packager', () => {
       ADR: 0,
       ACK: 1,
       FPending: 0,
-      FOptsLen: 1,
+      FOptsLen: 5,
     };
 
   });
@@ -57,7 +57,7 @@ describe('Test PHY packager', () => {
   });
 
   it('Test FCtrl packager', () => {
-    const expectedFCtrl = Buffer.from('21', 'hex');
+    const expectedFCtrl = Buffer.from('25', 'hex');
     FCtrl = PhyPackager.FCtrlPackager(FCtrlJSON);
     expect(FCtrl.equals(expectedFCtrl)).to.be.true;
   });
@@ -67,15 +67,23 @@ describe('Test PHY packager', () => {
       DevAddr: crypto.randomBytes(consts.DEVADDR_LEN),
       FCtrl: FCtrlJSON,
       FCnt: crypto.randomBytes(consts.FCNT_LEN),
-      FOpts: crypto.randomBytes(FCtrlJSON.FOptsLen),
+      FOpts: [{ 
+        '03': { 
+          TXPower: Buffer.from('01', 'hex'),
+          ChMask: Buffer.from('00ff', 'hex'),
+          Redundancy: Buffer.from('02', 'hex'),
+        },
+      }],
     };
     const expectedFHDR = Buffer.concat([
       reverse(FHDRJSON.DevAddr),
       reverse(FCtrl),
       reverse(FHDRJSON.FCnt.slice(consts.FCNT_LEAST_OFFSET)),
-      reverse(FHDRJSON.FOpts),
+      Buffer.from('030100ff02', 'hex'),
     ]);
     const FHDR = PhyPackager.FHDRPackager(FHDRJSON);
+    console.log(FHDR);
+    console.log(expectedFHDR);
     expect(FHDR.equals(expectedFHDR)).to.be.true;
 
   });
diff --git a/test/unit/lib/udpHandler/udpHandler.test.js b/test/unit/lib/udpHandler/udpHandler.test.js
@@ -25,7 +25,7 @@ describe('Test UDP parser', () => {
   let udpErrorIdentifier;
   before('Initial a handler', () => {
     udpHandler = new UDPHandler(log);
-    const udpEUI = crypto.randomBytes(consts.GW_ID_LEN);
+    const udpEUI = crypto.randomBytes(consts.GWEUI_LEN);
     const baseLen = 4;
     const base = Buffer.alloc(baseLen);
     base.writeUIntBE(0x02000000, 0, baseLen);
@@ -153,7 +153,7 @@ describe('Test UDP packager', (done) => {
   it('PULL_ACK', (done) => {
     udpPULLACKJSON = Object.assign({}, udpBaseJSON);
     udpPULLACKJSON.identifier.writeUInt8(consts.UDP_ID_PULL_ACK);
-    udpPULLACKJSON.gatewayId = Buffer.alloc(consts.GW_ID_LEN);
+    udpPULLACKJSON.gatewayId = Buffer.alloc(consts.GWEUI_LEN);
     udpHandler.packager(udpPULLACKJSON)
     .then((udpRecPULLACK) => {
       expect(udpRecPULLACK.equals(udpPULLACK)).to.be.true;
diff --git a/test/unit/models/GatewayInfo.test.js b/test/unit/models/GatewayInfo.test.js
@@ -37,8 +37,8 @@ describe('Test GatewayInfo model', function () {
   let testMySQLGatewayInfo;
   const testUser = 'testUser';
   before('Get connection with database', function (done) {
-    GatewayInfoRedis = new Models.RedisModel.GatewayInfo(_ioredis);
-    GatewayInfoMySQL = new Models.MySQLModel.GatewayInfo(_sequelize);
+    GatewayInfoRedis = new Models.RedisModels.GatewayInfo(_ioredis);
+    GatewayInfoMySQL = new Models.MySQLModels.GatewayInfo(_sequelize);
     query = {
       gatewayId: testGatewayId,
     };
