import { strict as assert } from 'assert' import ObservableStore from 'obs-store' import nanoid from 'nanoid' import { useFakeTimers } from 'sinon' import PermissionsLogController from '../../../../../app/scripts/controllers/permissions/permissionsLog' import { LOG_LIMIT, LOG_METHOD_TYPES, } from '../../../../../app/scripts/controllers/permissions/enums' import { validateActivityEntry } from './helpers' import { constants, getters, noop } from './mocks' const { PERMS, RPC_REQUESTS } = getters const { ACCOUNTS, EXPECTED_HISTORIES, DOMAINS, PERM_NAMES, REQUEST_IDS, RESTRICTED_METHODS, } = constants let clock const initPermLog = () => { return new PermissionsLogController({ store: new ObservableStore(), restrictedMethods: RESTRICTED_METHODS, }) } const mockNext = (handler) => { if (handler) { handler(noop) } } const initMiddleware = (permLog) => { const middleware = permLog.createMiddleware() return (req, res, next = mockNext) => { middleware(req, res, next) } } const initClock = () => { // useFakeTimers, is in fact, not a react-hook // eslint-disable-next-line clock = useFakeTimers(1) } const tearDownClock = () => { clock.restore() } const getSavedMockNext = (arr) => (handler) => { arr.push(handler) } describe('permissions log', function () { describe('activity log', function () { let permLog, logMiddleware beforeEach(function () { permLog = initPermLog() logMiddleware = initMiddleware(permLog) }) it('records activity for restricted methods', function () { let log, req, res // test_method, success req = RPC_REQUESTS.test_method(DOMAINS.a.origin) req.id = REQUEST_IDS.a res = { foo: 'bar' } logMiddleware({ ...req }, res) log = permLog.getActivityLog() const entry1 = log[0] assert.equal(log.length, 1, 'log should have single entry') validateActivityEntry( entry1, { ...req }, { ...res }, LOG_METHOD_TYPES.restricted, true, ) // eth_accounts, failure req = RPC_REQUESTS.eth_accounts(DOMAINS.b.origin) req.id = REQUEST_IDS.b res = { error: new Error('Unauthorized.') } logMiddleware({ ...req }, res) log = permLog.getActivityLog() const entry2 = log[1] assert.equal(log.length, 2, 'log should have 2 entries') validateActivityEntry( entry2, { ...req }, { ...res }, LOG_METHOD_TYPES.restricted, false, ) // eth_requestAccounts, success req = RPC_REQUESTS.eth_requestAccounts(DOMAINS.c.origin) req.id = REQUEST_IDS.c res = { result: ACCOUNTS.c.permitted } logMiddleware({ ...req }, res) log = permLog.getActivityLog() const entry3 = log[2] assert.equal(log.length, 3, 'log should have 3 entries') validateActivityEntry( entry3, { ...req }, { ...res }, LOG_METHOD_TYPES.restricted, true, ) // test_method, no response req = RPC_REQUESTS.test_method(DOMAINS.a.origin) req.id = REQUEST_IDS.a res = null logMiddleware({ ...req }, res) log = permLog.getActivityLog() const entry4 = log[3] assert.equal(log.length, 4, 'log should have 4 entries') validateActivityEntry( entry4, { ...req }, null, LOG_METHOD_TYPES.restricted, false, ) // validate final state assert.equal(entry1, log[0], 'first log entry should remain') assert.equal(entry2, log[1], 'second log entry should remain') assert.equal(entry3, log[2], 'third log entry should remain') assert.equal(entry4, log[3], 'fourth log entry should remain') }) it('handles responses added out of order', function () { let log const handlerArray = [] const id1 = nanoid() const id2 = nanoid() const id3 = nanoid() const req = RPC_REQUESTS.test_method(DOMAINS.a.origin) // get make requests req.id = id1 const res1 = { foo: id1 } logMiddleware({ ...req }, { ...res1 }, getSavedMockNext(handlerArray)) req.id = id2 const res2 = { foo: id2 } logMiddleware({ ...req }, { ...res2 }, getSavedMockNext(handlerArray)) req.id = id3 const res3 = { foo: id3 } logMiddleware({ ...req }, { ...res3 }, getSavedMockNext(handlerArray)) // verify log state log = permLog.getActivityLog() assert.equal(log.length, 3, 'log should have 3 entries') const entry1 = log[0] const entry2 = log[1] const entry3 = log[2] assert.ok( entry1.id === id1 && entry1.response === null && entry2.id === id2 && entry2.response === null && entry3.id === id3 && entry3.response === null, 'all entries should be in correct order and without responses', ) // call response handlers for (const i of [1, 2, 0]) { handlerArray[i](noop) } // verify log state again log = permLog.getActivityLog() assert.equal(log.length, 3, 'log should have 3 entries') // verify all entries log = permLog.getActivityLog() validateActivityEntry( log[0], { ...req, id: id1 }, { ...res1 }, LOG_METHOD_TYPES.restricted, true, ) validateActivityEntry( log[1], { ...req, id: id2 }, { ...res2 }, LOG_METHOD_TYPES.restricted, true, ) validateActivityEntry( log[2], { ...req, id: id3 }, { ...res3 }, LOG_METHOD_TYPES.restricted, true, ) }) it('handles a lack of response', function () { let req = RPC_REQUESTS.test_method(DOMAINS.a.origin) req.id = REQUEST_IDS.a let res = { foo: 'bar' } // noop for next handler prevents recording of response logMiddleware({ ...req }, res, noop) let log = permLog.getActivityLog() const entry1 = log[0] assert.equal(log.length, 1, 'log should have single entry') validateActivityEntry( entry1, { ...req }, null, LOG_METHOD_TYPES.restricted, true, ) // next request should be handled as normal req = RPC_REQUESTS.eth_accounts(DOMAINS.b.origin) req.id = REQUEST_IDS.b res = { result: ACCOUNTS.b.permitted } logMiddleware({ ...req }, res) log = permLog.getActivityLog() const entry2 = log[1] assert.equal(log.length, 2, 'log should have 2 entries') validateActivityEntry( entry2, { ...req }, { ...res }, LOG_METHOD_TYPES.restricted, true, ) // validate final state assert.equal(entry1, log[0], 'first log entry remains') assert.equal(entry2, log[1], 'second log entry remains') }) it('ignores expected methods', function () { let log = permLog.getActivityLog() assert.equal(log.length, 0, 'log should be empty') const res = { foo: 'bar' } const req1 = RPC_REQUESTS.wallet_sendDomainMetadata( DOMAINS.c.origin, 'foobar', ) const req2 = RPC_REQUESTS.custom(DOMAINS.b.origin, 'eth_getBlockNumber') const req3 = RPC_REQUESTS.custom(DOMAINS.b.origin, 'net_version') logMiddleware(req1, res) logMiddleware(req2, res) logMiddleware(req3, res) log = permLog.getActivityLog() assert.equal(log.length, 0, 'log should still be empty') }) it('enforces log limit', function () { const req = RPC_REQUESTS.test_method(DOMAINS.a.origin) const res = { foo: 'bar' } // max out log let lastId for (let i = 0; i < LOG_LIMIT; i++) { lastId = nanoid() logMiddleware({ ...req, id: lastId }, { ...res }) } // check last entry valid let log = permLog.getActivityLog() assert.equal( log.length, LOG_LIMIT, 'log should have LOG_LIMIT num entries', ) validateActivityEntry( log[LOG_LIMIT - 1], { ...req, id: lastId }, res, LOG_METHOD_TYPES.restricted, true, ) // store the id of the current second entry const nextFirstId = log[1].id // add one more entry to log, putting it over the limit lastId = nanoid() logMiddleware({ ...req, id: lastId }, { ...res }) // check log length log = permLog.getActivityLog() assert.equal( log.length, LOG_LIMIT, 'log should have LOG_LIMIT num entries', ) // check first and last entries validateActivityEntry( log[0], { ...req, id: nextFirstId }, res, LOG_METHOD_TYPES.restricted, true, ) validateActivityEntry( log[LOG_LIMIT - 1], { ...req, id: lastId }, res, LOG_METHOD_TYPES.restricted, true, ) }) }) describe('permissions history', function () { let permLog, logMiddleware beforeEach(function () { permLog = initPermLog() logMiddleware = initMiddleware(permLog) initClock() }) afterEach(function () { tearDownClock() }) it('only updates history on responses', function () { let permHistory const req = RPC_REQUESTS.requestPermission( DOMAINS.a.origin, PERM_NAMES.test_method, ) const res = { result: [PERMS.granted.test_method()] } // noop => no response logMiddleware({ ...req }, { ...res }, noop) permHistory = permLog.getHistory() assert.deepEqual(permHistory, {}, 'history should not have been updated') // response => records granted permissions logMiddleware({ ...req }, { ...res }) permHistory = permLog.getHistory() assert.equal( Object.keys(permHistory).length, 1, 'history should have single origin', ) assert.ok( Boolean(permHistory[DOMAINS.a.origin]), 'history should have expected origin', ) }) it('ignores malformed permissions requests', function () { const req = RPC_REQUESTS.requestPermission( DOMAINS.a.origin, PERM_NAMES.test_method, ) delete req.params const res = { result: [PERMS.granted.test_method()] } // no params => no response logMiddleware({ ...req }, { ...res }) assert.deepEqual( permLog.getHistory(), {}, 'history should not have been updated', ) }) it('records and updates account history as expected', async function () { let permHistory const req = RPC_REQUESTS.requestPermission( DOMAINS.a.origin, PERM_NAMES.eth_accounts, ) const res = { result: [PERMS.granted.eth_accounts(ACCOUNTS.a.permitted)], } logMiddleware({ ...req }, { ...res }) // validate history permHistory = permLog.getHistory() assert.deepEqual( permHistory, EXPECTED_HISTORIES.case1[0], 'should have correct history', ) // mock permission requested again, with another approved account clock.tick(1) res.result = [PERMS.granted.eth_accounts([ACCOUNTS.a.permitted[0]])] logMiddleware({ ...req }, { ...res }) permHistory = permLog.getHistory() assert.deepEqual( permHistory, EXPECTED_HISTORIES.case1[1], 'should have correct history', ) }) it('handles eth_accounts response without caveats', async function () { const req = RPC_REQUESTS.requestPermission( DOMAINS.a.origin, PERM_NAMES.eth_accounts, ) const res = { result: [PERMS.granted.eth_accounts(ACCOUNTS.a.permitted)], } delete res.result[0].caveats logMiddleware({ ...req }, { ...res }) // validate history assert.deepEqual( permLog.getHistory(), EXPECTED_HISTORIES.case2[0], 'should have expected history', ) }) it('handles extra caveats for eth_accounts', async function () { const req = RPC_REQUESTS.requestPermission( DOMAINS.a.origin, PERM_NAMES.eth_accounts, ) const res = { result: [PERMS.granted.eth_accounts(ACCOUNTS.a.permitted)], } res.result[0].caveats.push({ foo: 'bar' }) logMiddleware({ ...req }, { ...res }) // validate history assert.deepEqual( permLog.getHistory(), EXPECTED_HISTORIES.case1[0], 'should have correct history', ) }) // wallet_requestPermissions returns all permissions approved for the // requesting origin, including old ones it('handles unrequested permissions on the response', async function () { const req = RPC_REQUESTS.requestPermission( DOMAINS.a.origin, PERM_NAMES.eth_accounts, ) const res = { result: [ PERMS.granted.eth_accounts(ACCOUNTS.a.permitted), PERMS.granted.test_method(), ], } logMiddleware({ ...req }, { ...res }) // validate history assert.deepEqual( permLog.getHistory(), EXPECTED_HISTORIES.case1[0], 'should have correct history', ) }) it('does not update history if no new permissions are approved', async function () { let req = RPC_REQUESTS.requestPermission( DOMAINS.a.origin, PERM_NAMES.test_method, ) let res = { result: [PERMS.granted.test_method()], } logMiddleware({ ...req }, { ...res }) // validate history assert.deepEqual( permLog.getHistory(), EXPECTED_HISTORIES.case4[0], 'should have correct history', ) // new permission requested, but not approved clock.tick(1) req = RPC_REQUESTS.requestPermission( DOMAINS.a.origin, PERM_NAMES.eth_accounts, ) res = { result: [PERMS.granted.test_method()], } logMiddleware({ ...req }, { ...res }) // validate history assert.deepEqual( permLog.getHistory(), EXPECTED_HISTORIES.case4[0], 'should have same history as before', ) }) it('records and updates history for multiple origins, regardless of response order', async function () { let permHistory // make first round of requests const round1 = [] const handlers1 = [] // first origin round1.push({ req: RPC_REQUESTS.requestPermission( DOMAINS.a.origin, PERM_NAMES.test_method, ), res: { result: [PERMS.granted.test_method()], }, }) // second origin round1.push({ req: RPC_REQUESTS.requestPermission( DOMAINS.b.origin, PERM_NAMES.eth_accounts, ), res: { result: [PERMS.granted.eth_accounts(ACCOUNTS.b.permitted)], }, }) // third origin round1.push({ req: RPC_REQUESTS.requestPermissions(DOMAINS.c.origin, { [PERM_NAMES.test_method]: {}, [PERM_NAMES.eth_accounts]: {}, }), res: { result: [ PERMS.granted.test_method(), PERMS.granted.eth_accounts(ACCOUNTS.c.permitted), ], }, }) // make requests and process responses out of order round1.forEach((x) => { logMiddleware({ ...x.req }, { ...x.res }, getSavedMockNext(handlers1)) }) for (const i of [1, 2, 0]) { handlers1[i](noop) } // validate history permHistory = permLog.getHistory() assert.deepEqual( permHistory, EXPECTED_HISTORIES.case3[0], 'should have expected history', ) // make next round of requests clock.tick(1) const round2 = [] // we're just gonna process these in order // first origin round2.push({ req: RPC_REQUESTS.requestPermission( DOMAINS.a.origin, PERM_NAMES.test_method, ), res: { result: [PERMS.granted.test_method()], }, }) // nothing for second origin // third origin round2.push({ req: RPC_REQUESTS.requestPermissions(DOMAINS.c.origin, { [PERM_NAMES.eth_accounts]: {}, }), res: { result: [PERMS.granted.eth_accounts(ACCOUNTS.b.permitted)], }, }) // make requests round2.forEach((x) => { logMiddleware({ ...x.req }, { ...x.res }) }) // validate history permHistory = permLog.getHistory() assert.deepEqual( permHistory, EXPECTED_HISTORIES.case3[1], 'should have expected history', ) }) }) })