Merge pull request #35 from hyphacoop/protocol-integration

Protocol Integration

Author: jackyzha0

.github/workflows/tests.yaml

@@ -1,14 +1,10 @@
 name: Tests 
 
-on:
-  push:
-    branches: [ main, v1 ]
-  pull_request:
-    branches: [ main, v1 ]
+on: [ push, pull_request ]
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     defaults:
       run:
         working-directory: v1

v1/@types/go-ipfs.d.ts

@@ -0,0 +1,4 @@
+
+declare module 'go-ipfs' {
+  export function path (): string
+}

v1/@types/hyper-sdk.d.ts

@@ -0,0 +1,20 @@
+declare module 'hyper-sdk' {
+  export class Hyperdrive {
+    once (evt: string, cb: () => void): void
+    get url (): string
+    close (): Promise<void>
+  }
+
+  export type HyperOpts = Partial<{
+    storage: string | boolean
+    corestoreOpts: {}
+    swarmOpts: {}
+  }>
+
+  export class SDK {
+    getDrive (nameOrKeyOrURL: string): Promise<Hyperdrive>
+    close (): Promise<void>
+  }
+
+  export function create (opts?: HyperOpts): Promise<SDK>
+}

v1/@types/localdrive.d.ts

@@ -0,0 +1,8 @@
+
+declare module 'localdrive' {
+  import MirrorDrive, { DriveLike } from 'mirror-drive'
+  export default class LocalDrive {
+    constructor (path: string)
+    mirror (otherDrive: DriveLike): MirrorDrive
+  }
+}

v1/@types/mirror-drive.d.ts

@@ -0,0 +1,11 @@
+
+declare module 'mirror-drive' {
+  import { Hyperdrive } from 'hyper-sdk'
+  import LocalDrive from 'localdrive'
+  export type DriveLike = LocalDrive | Hyperdrive
+  export default class MirrorDrive {
+    constructor (drive1: DriveLike, drive2: DriveLike)
+    get count (): number
+    done (): Promise<void>
+  }
+}

v1/api/admin.ts

@@ -1,15 +1,18 @@
 import { Static, Type } from '@sinclair/typebox'
 import { StoreI } from '../config/index.js'
 import { FastifyTypebox } from './index.js'
-import { NewAdmin } from './schemas.js'
+import { Admin, NewAdmin } from './schemas.js'
 
 export const adminRoutes = (store: StoreI) => async (server: FastifyTypebox): Promise<void> => {
   server.post<{
     Body: Static<typeof NewAdmin>
-    Reply: string // id of the admin
+    Reply: Static<typeof Admin>
   }>('/admin', {
     schema: {
       body: NewAdmin,
+      response: {
+        200: Admin
+      },
       description: 'Add a new admin.',
       tags: ['admin'],
       security: [{ jwt: [] }]

v1/api/auth.test.ts

@@ -1,18 +1,28 @@
-import test from 'ava'
+import anyTest, { TestFn } from 'ava'
 import { CAPABILITIES, makeJWTToken } from '../authorization/jwt.js'
-import apiBuilder from './index.js'
+import { spawnTestServer } from '../fixtures/spawnServer.js'
+import { FastifyTypebox } from './index.js'
+
+const test = anyTest as TestFn<{ server: FastifyTypebox }>
+
+test.beforeEach(async t => {
+  t.context.server = await spawnTestServer()
+})
+
+test.afterEach.always(async t => {
+  await t.context.server?.close()
+})
 
 test('no auth header should 401', async t => {
-  const server = await apiBuilder({ useMemoryBackedDB: true })
-  const responseAdmin = await server.inject({
+  const responseAdmin = await t.context.server.inject({
     method: 'POST',
     url: '/v1/admin',
     payload: {
       name: 'test_admin'
     }
   })
   t.is(responseAdmin.statusCode, 401, 'returns a status code of 401')
-  const responsePublisher = await server.inject({
+  const responsePublisher = await t.context.server.inject({
     method: 'POST',
     url: '/v1/publisher',
     payload: {
@@ -23,10 +33,9 @@ test('no auth header should 401', async t => {
 })
 
 test('token refresh with non-refresh token should fail', async t => {
-  const server = await apiBuilder({ useMemoryBackedDB: true })
-  const tokenAdmin = server.jwt.sign(makeJWTToken({ isAdmin: true, isRefresh: false }))
-  const tokenPublisher = server.jwt.sign(makeJWTToken({ isAdmin: false, isRefresh: false }))
-  const adminResponse = await server.inject({
+  const tokenAdmin = t.context.server.jwt.sign(makeJWTToken({ isAdmin: true, isRefresh: false }))
+  const tokenPublisher = t.context.server.jwt.sign(makeJWTToken({ isAdmin: false, isRefresh: false }))
+  const adminResponse = await t.context.server.inject({
     method: 'POST',
     url: '/v1/auth/exchange',
     headers: {
@@ -37,7 +46,7 @@ test('token refresh with non-refresh token should fail', async t => {
     }
   })
   t.is(adminResponse.statusCode, 401, 'refreshing a non-refresh admin token returns a status code of 401')
-  const publisherResponse = await server.inject({
+  const publisherResponse = await t.context.server.inject({
     method: 'POST',
     url: '/v1/auth/exchange',
     headers: {
@@ -51,40 +60,34 @@ test('token refresh with non-refresh token should fail', async t => {
 })
 
 test('revocation works', async t => {
-  const server = await apiBuilder({ useMemoryBackedDB: true })
   const token = makeJWTToken({ isAdmin: true, isRefresh: false })
-  const signedToken = server.jwt.sign(token)
+  const signedToken = t.context.server.jwt.sign(token)
   const tokenToBeRevoked = makeJWTToken({ isAdmin: true, isRefresh: false })
-  const signedTokenToBeRevoked = server.jwt.sign(tokenToBeRevoked)
-  const revokeResponse = await server.inject({
+  const signedTokenToBeRevoked = t.context.server.jwt.sign(tokenToBeRevoked)
+  const revokeResponse = await t.context.server.inject({
     method: 'DELETE',
     url: `/v1/auth/revoke/${tokenToBeRevoked.tokenId}`,
     headers: {
       authorization: `Bearer ${signedToken}`
-    },
-    payload: {
-      capabilities: [CAPABILITIES.PUBLISHER, CAPABILITIES.REFRESH]
     }
   })
   t.is(revokeResponse.statusCode, 200, 'revocation of another token works (should return 200)')
 
-  const failingRevokeResponse = await server.inject({
+  const failingRevokeResponse = await t.context.server.inject({
     method: 'DELETE',
     url: `/v1/auth/revoke/${token.tokenId}`,
     headers: {
       authorization: `Bearer ${signedTokenToBeRevoked}`
-    },
-    payload: {
-      capabilities: [CAPABILITIES.PUBLISHER, CAPABILITIES.REFRESH]
     }
   })
   t.is(failingRevokeResponse.statusCode, 401, 'trying to revoke the original token using the revoked token should no longer work')
 })
 
-test('requesting new token with superset of permissions (publisher -> admin) should fail', async t => {
-  const server = await apiBuilder({ useMemoryBackedDB: true })
-  const token = server.jwt.sign(makeJWTToken({ isAdmin: false, isRefresh: true }))
-  const response = await server.inject({
+test('revoking a tokens removes all tokens derived from that token', async t => {
+  // first token
+  const tokenBody = makeJWTToken({ isAdmin: true, isRefresh: true })
+  const token = t.context.server.jwt.sign(tokenBody)
+  const response = await t.context.server.inject({
     method: 'POST',
     url: '/v1/auth/exchange',
     headers: {
@@ -94,29 +97,49 @@ test('requesting new token with superset of permissions (publisher -> admin) sho
       capabilities: [CAPABILITIES.ADMIN, CAPABILITIES.PUBLISHER, CAPABILITIES.REFRESH]
     }
   })
-  t.is(response.statusCode, 401)
+  t.is(response.statusCode, 200, 'publisher refreshing their own token works')
+
+  const refreshedToken = response.body
+  const revokeResponse = await t.context.server.inject({
+    method: 'DELETE',
+    url: `/v1/auth/revoke/${tokenBody.tokenId}`,
+    headers: {
+      authorization: `Bearer ${refreshedToken}`
+    }
+  })
+  t.is(revokeResponse.statusCode, 200, 'revoking original token should work')
+
+  const newPublisherResponse = await t.context.server.inject({
+    method: 'POST',
+    url: '/v1/publisher',
+    headers: {
+      authorization: `Bearer ${refreshedToken}`
+    },
+    payload: {
+      name: 'malicious new publisher'
+    }
+  })
+  t.is(newPublisherResponse.statusCode, 401, 'operations with token derived from original token should also fail')
 })
 
-test('requesting new token with subset of permissions (admin -> publisher) should work', async t => {
-  const server = await apiBuilder({ useMemoryBackedDB: true })
-  const token = server.jwt.sign(makeJWTToken({ isAdmin: true, isRefresh: true }))
-  const response = await server.inject({
+test('requesting new token with superset of permissions (publisher -> admin) should fail', async t => {
+  const token = t.context.server.jwt.sign(makeJWTToken({ isAdmin: false, isRefresh: true }))
+  const response = await t.context.server.inject({
     method: 'POST',
     url: '/v1/auth/exchange',
     headers: {
       authorization: `Bearer ${token}`
     },
     payload: {
-      capabilities: [CAPABILITIES.PUBLISHER, CAPABILITIES.REFRESH]
+      capabilities: [CAPABILITIES.ADMIN, CAPABILITIES.PUBLISHER, CAPABILITIES.REFRESH]
     }
   })
-  t.is(response.statusCode, 200)
+  t.is(response.statusCode, 401)
 })
 
-test('trying to create new refresh tokens as a publisher should fail', async t => {
-  const server = await apiBuilder({ useMemoryBackedDB: true })
-  const token = server.jwt.sign(makeJWTToken({ isAdmin: false, isRefresh: true }))
-  const response = await server.inject({
+test('requesting new token with subset of permissions (admin -> publisher) should work', async t => {
+  const token = t.context.server.jwt.sign(makeJWTToken({ isAdmin: true, isRefresh: true }))
+  const response = await t.context.server.inject({
     method: 'POST',
     url: '/v1/auth/exchange',
     headers: {
@@ -126,5 +149,5 @@ test('trying to create new refresh tokens as a publisher should fail', async t =
       capabilities: [CAPABILITIES.PUBLISHER, CAPABILITIES.REFRESH]
     }
   })
-  t.is(response.statusCode, 401)
+  t.is(response.statusCode, 200)
 })

v1/api/auth.ts

@@ -1,5 +1,5 @@
 import { Type, Static } from '@sinclair/typebox'
-import { CAPABILITIES, getExpiry, subset, NewJWTPayload } from '../authorization/jwt.js'
+import { getExpiry, subset, NewJWTPayload } from '../authorization/jwt.js'
 import { StoreI } from '../config/index.js'
 import { FastifyTypebox } from './index.js'
 
@@ -23,9 +23,6 @@ export const authRoutes = (store: StoreI) => async (server: FastifyTypebox): Pro
     if (!subset(request.body.capabilities, token.capabilities)) {
       return await reply.status(401).send('Requested more permissions than original token has')
     }
-    if (!token.capabilities.includes(CAPABILITIES.ADMIN) && request.body.capabilities.includes(CAPABILITIES.REFRESH)) {
-      return await reply.status(401).send("Can't create new refresh tokens if you are not an admin. Please contact an administrator")
-    }
     const newToken = {
       ...token,
       issuedTo: request.body.issuedTo ?? token.issuedTo,