PhishingController implementation

Author: bitpshr

package-lock.json

@@ -51,6 +51,7 @@
     "@types/node": "^10.1.4",
     "@types/sinon": "^4.3.3",
     "eth-json-rpc-infura": "^3.1.2",
+    "eth-phishing-detect": "^1.1.13",
     "eth-query": "^2.1.2",
     "husky": "^0.14.3",
     "isomorphic-fetch": "^2.2.1",

package.json

@@ -1,7 +1,10 @@
 import { EventEmitter } from 'events';
 import { ChildControllerContext } from './ComposableController';
 
-type Listener<T> = (state: T) => void;
+/**
+ * State change callbacks
+ */
+export type Listener<T> = (state: T) => void;
 
 /**
  * @type BaseConfig

src/BaseController.ts

@@ -0,0 +1,68 @@
+import 'isomorphic-fetch';
+import { stub } from 'sinon';
+import PhishingController from './PhishingController';
+
+describe('NetworkStatusController', () => {
+	it('should set default state', () => {
+		const controller = new PhishingController();
+		expect(controller.state.phishing).toHaveProperty('blacklist');
+		expect(controller.state.phishing).toHaveProperty('fuzzylist');
+		expect(controller.state.phishing).toHaveProperty('version');
+		expect(controller.state.phishing).toHaveProperty('whitelist');
+	});
+
+	it('should set default config', () => {
+		const controller = new PhishingController();
+		expect(controller.config).toEqual({ interval: 180000 });
+	});
+
+	it('should poll on correct interval', () => {
+		const mock = stub(global, 'setInterval');
+		/* tslint:disable-next-line:no-unused-expression */
+		new PhishingController(undefined, { interval: 1337 });
+		expect(mock.getCall(0).args[1]).toBe(1337);
+		mock.restore();
+	});
+
+	it('should update lists on interval', () => {
+		return new Promise((resolve) => {
+			const controller = new PhishingController(undefined, { interval: 10 });
+			const mock = stub(controller, 'updatePhishingLists');
+			setTimeout(() => {
+				expect(mock.called).toBe(true);
+				mock.restore();
+				resolve();
+			}, 20);
+		});
+	});
+
+	it('should update lists', async () => {
+		const controller = new PhishingController();
+		controller.update({}, true);
+		await controller.updatePhishingLists();
+		expect(controller.state.phishing).toHaveProperty('blacklist');
+		expect(controller.state.phishing).toHaveProperty('fuzzylist');
+		expect(controller.state.phishing).toHaveProperty('version');
+		expect(controller.state.phishing).toHaveProperty('whitelist');
+	});
+
+	it('should not update infura rate if disabled', async () => {
+		const controller = new PhishingController(undefined, { disabled: true });
+		controller.update({}, true);
+		await controller.updatePhishingLists();
+		expect(controller.state.phishing).toBe(undefined);
+	});
+
+	it('should clear previous interval', () => {
+		const mock = stub(global, 'clearInterval');
+		const controller = new PhishingController(undefined, { interval: 1337 });
+		controller.interval = 1338;
+		expect(mock.called).toBe(true);
+		mock.restore();
+	});
+
+	it('should verify approved domain', () => {
+		const controller = new PhishingController();
+		expect(controller.test('metamask.io')).toBe(false);
+	});
+});

src/PhishingController.test.ts

@@ -0,0 +1,112 @@
+import BaseController, { BaseConfig, BaseState } from './BaseController';
+
+const DEFAULT_PHISHING_RESPONSE = require('eth-phishing-detect/src/config.json');
+const PhishingDetector = require('eth-phishing-detect/src/detector');
+
+/**
+ * @type EthPhishingResponse
+ *
+ * Configuration response from the eth-phishing-detect package
+ * consisting of approved and unapproved website origins
+ *
+ * @property blacklist - List of unapproved origins
+ * @property fuzzylist - List of fuzzy-matched unapproved origins
+ * @property tolerance - Fuzzy match tolerance level
+ * @property version - Versin number of this configuration
+ * @property whitelist - List of approved origins
+ */
+export interface EthPhishingResponse {
+	blacklist: string[];
+	fuzzylist: string[];
+	tolerance: number;
+	version: number;
+	whitelist: string[];
+}
+
+/**
+ * @type PhishingConfig
+ *
+ * Phishing controller configuration
+ *
+ * @property interval - Polling interval used to fetch new block / approve lists
+ */
+export interface PhishingConfig extends BaseConfig {
+	interval: number;
+}
+
+/**
+ * @type PhishingState
+ *
+ * Phishing controller state
+ *
+ * @property phishing - eth-phishing-detect configuration
+ */
+export interface PhishingState extends BaseState {
+	phishing: EthPhishingResponse;
+}
+
+/**
+ * Controller that passively polls on a set interval for approved and unapproved website origins
+ */
+export class PhishingController extends BaseController<PhishingState, PhishingConfig> {
+	private detector: any;
+	private handle?: NodeJS.Timer;
+
+	/**
+	 * Creates a PhishingController instance
+	 *
+	 * @param state - Initial state to set on this controller
+	 * @param config - Initial options used to configure this controller
+	 */
+	constructor(state?: Partial<PhishingState>, config?: Partial<PhishingConfig>) {
+		super(state, config);
+		this.defaultConfig = { interval: 180000 };
+		this.defaultState = { phishing: DEFAULT_PHISHING_RESPONSE };
+		this.detector = new PhishingDetector(this.defaultState.phishing);
+		this.initialize();
+	}
+
+	/**
+	 * Sets a new polling interval
+	 *
+	 * @param interval - Polling interval used to fetch new exchange rates
+	 */
+	set interval(interval: number) {
+		this.handle && clearInterval(this.handle);
+		this.updatePhishingLists();
+		this.handle = setInterval(() => {
+			this.updatePhishingLists();
+		}, interval);
+	}
+
+	/**
+	 * Determines if a given origin is unapproved
+	 *
+	 * @param origin - Domain origin of a website
+	 * @returns - True if the origin is an unapproved origin
+	 */
+	test(origin: string) {
+		return this.detector.check(origin).result;
+	}
+
+	/**
+	 * Updates lists of approved and unapproved website origins
+	 */
+	async updatePhishingLists() {
+		let phishing;
+		if (this.disabled) {
+			return;
+		}
+		try {
+			const response = await fetch('https://api.infura.io/v2/blacklist');
+			const json = await response.json();
+			phishing = json && json.whitelist ? json : /* istanbul ignore next */ null;
+		} catch (error) {
+			/* tslint:disable-next-line:no-empty */
+		}
+		this.detector = new PhishingDetector(phishing);
+		phishing && this.update({ phishing });
+	}
+}
+
+export default PhishingController;