feat(pencil): added webhook middleware support

Author: alexivsn

src/enums/interception-module.ts

@@ -0,0 +1,7 @@
+enum InterceptionModule {
+  Express = "/node_modules/express/lib/express.js",
+  Koa = "/node_modules/koa/lib/application.js",
+  Hapi = "/node_modules/@hapi/hapi/lib/index.js"
+};
+
+export default InterceptionModule;

src/middleware/express-middleware.ts

@@ -0,0 +1,24 @@
+import { Request, Response, NextFunction } from 'express';
+import { Middleware, IMiddleware } from './middleware';
+import { SecureNativeOptions } from '../types/securenative-options';
+
+export default class ExpressMiddleware extends Middleware implements IMiddleware {
+  private _routes: Array<string> = [];
+  constructor(options: SecureNativeOptions) {
+    super(options);
+  }
+
+  verifyWebhook(req: Request, res: Response, next: NextFunction) {
+    const { body = null, headers = null } = req;
+
+    if (!body || !headers) {
+      return res.status(400).send('Bad Request');
+    }
+
+    if (!super.verifySignature(headers, body, this.options.apiKey)) {
+      return res.status(401).send('Mismatched signatures');
+    }
+
+    return next();
+  }
+}

src/middleware/koa-middleware.ts

@@ -0,0 +1,24 @@
+import { Context } from 'koa';
+import {} from 'koa-bodyparser';
+import { Middleware, IMiddleware } from './middleware';
+import { SecureNativeOptions } from '../types/securenative-options';
+
+export default class KoaMiddleware extends Middleware implements IMiddleware {
+  constructor(options: SecureNativeOptions) {
+    super(options);
+  }
+
+  verifyWebhook(ctx: Context, next: Function) {
+    const { request: { body } = null, req: { headers } = null } = ctx;
+
+    if (!body || !headers) {
+      return ctx.throw(400, 'Bad Request');
+    }
+
+    if (!super.verifySignature(headers, body, this.options.apiKey)) {
+      return ctx.throw(401, 'Mismatched signatures');
+    }
+
+    return next();
+  }
+}

src/middleware/middleware.ts

@@ -0,0 +1,26 @@
+import { createHmac, timingSafeEqual } from 'crypto';
+import { SecureNativeOptions } from '../types/securenative-options';
+ 
+const SIGNATURE_KEY = 'x-securenative';
+
+export interface IMiddleware {
+  verifyWebhook(...params: any[]);
+}
+
+export abstract class Middleware {
+  constructor(protected options: SecureNativeOptions) {}
+
+  verifySignature(headers, body, apiKey): Boolean {
+    const signature = headers[SIGNATURE_KEY] || '';
+    // calculating signature
+    const hmac = createHmac('sha512', apiKey);
+    const comparison_signature = hmac.update(JSON.stringify(body)).digest('hex');
+
+    // comparing signatures
+    if (!timingSafeEqual(Buffer.from(signature.toString()), Buffer.from(comparison_signature))) {
+      return false;
+    }
+
+    return true;
+  }
+}

src/middleware/midlleware-factory.ts

@@ -0,0 +1,15 @@
+import KoaMiddleware from './koa-middleware';
+import ExpressMiddleware from './express-middleware';
+import { IMiddleware } from './middleware';
+import InterceptionModule from '../enums/interception-module';
+import ModuleManager from '../module-manager';
+import { SecureNativeOptions } from '../types/securenative-options';
+
+export function createMiddleware(moduleManager: ModuleManager, options: SecureNativeOptions): IMiddleware {
+  if (moduleManager.Modules[InterceptionModule.Koa]) {
+    return new KoaMiddleware(options);
+  }
+
+  //make express as default middleware
+  return new ExpressMiddleware(options);
+}

src/module-manager.spec.ts

@@ -0,0 +1,16 @@
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import ModuleManager from './module-manager';
+
+chai.use(chaiAsPromised);
+const expect = chai.expect;
+
+describe('ModuleManager', () => {
+  it('Should have all methods defined', () => {
+    const moduleManager = new ModuleManager(null);
+    expect(moduleManager.Modules).to.not.be.null;
+    expect(Object.keys(moduleManager.Modules), 'Loaded modules').length.above(0);
+    expect(moduleManager.pkg).to.be.null;
+    expect(moduleManager.framework).to.be.undefined;
+  });
+});

src/module-manager.ts

@@ -0,0 +1,27 @@
+import { Package } from "./package-manager";
+
+export default class ModuleManager {
+  private _modules: Object;
+  public framework: string;
+
+  constructor(public pkg: Package) {
+    this._modules = this.getLoadedModules();
+  }
+
+  get Modules(): Object {
+    return this._modules;
+  }
+  
+  private getLoadedModules() {
+    const loadedModules = {};
+    const dirname = process.cwd();
+    const modules = require.cache;
+
+    Object.entries(modules).forEach(([key, val]) => {
+      const moduleName = key.replace(dirname, '');
+      loadedModules[moduleName] = val;
+    });
+
+    return loadedModules;
+  }
+}

src/securenative.ts

@@ -7,24 +7,35 @@ import { Logger } from './logger';
 import { PackageManager, Package } from './package-manager';
 import ConfigurationManager from './configuration-manager';
 import { join } from 'path';
+import ModuleManager from './module-manager';
+import { IMiddleware } from './middleware/middleware';
+import { createMiddleware } from './middleware/midlleware-factory';
 
 const PACKAGE_FILE_NAME = 'package.json';
 
 export default class SecureNative {
   private apiManager: ApiManager;
-  private static instance = null;
+  public middleware: IMiddleware;
+  private static instance: SecureNative;
 
-  private constructor(eventManager: EventManager, options: SecureNativeOptions) {
-    if (!eventManager || !options) {
+  private constructor(eventManager: EventManager, moduleManager: ModuleManager, private options: SecureNativeOptions) {
+    if (!eventManager || !moduleManager || !options) {
       throw new Error('Unable to create SecureNative instance, invalid config provided');
     }
+
+    if (!options.disable) {
+      // create middleware
+      this.middleware = createMiddleware(moduleManager, options);
+      this.middleware.verifyWebhook = this.middleware.verifyWebhook.bind(this.middleware);
+    }
+
     this.apiManager = new ApiManager(eventManager, options);
   }
 
   public static init(options: SecureNativeOptions) {
     const defaultOptions = ConfigurationManager.getConfig();
     const config: SecureNativeOptions = { ...options, ...defaultOptions };
-    
+
     const eventManager = new EventManager(fetch, config);
     SecureNative.initialize(eventManager, config);
   }
@@ -33,18 +44,23 @@ export default class SecureNative {
     if (SecureNative.instance) {
       throw new Error('This SDK was already initialized');
     }
-
+    
     const appPkg: Package = PackageManager.getPackage(join(process.cwd(), PACKAGE_FILE_NAME));
     // set default app name
     if (!options.appName) {
       ConfigurationManager.setConfigKey('appName', appPkg.name);
     }
 
+    // create moduleManager
+    const moduleManager = new ModuleManager(appPkg);
+
     // init logger
     Logger.initLogger(options);
     Logger.debug('Loaded Configurations', JSON.stringify(options));
 
-    SecureNative.instance = new SecureNative(eventManager, options);
+    const secureNative = new SecureNative(eventManager, moduleManager, options);
+
+    SecureNative.instance = secureNative;
   }
 
   public static getInstance(): SecureNative {