@joclaim/attestor-core 0.2.0 → 0.2.3

package/src/tests/http-provider.test.ts

@@ -1,125 +0,0 @@
-import assert from 'node:assert'
-import { afterEach, it } from 'node:test'
-
-import { createClaimOnAttestor } from '#src/client/index.ts'
-import { describeWithServer } from '#src/tests/describe-with-server.ts'
-import { getFirstTOprfBlock, verifyNoDirectRevealLeaks } from '#src/tests/utils.ts'
-import { binaryHashToStr } from '#src/utils/index.ts'
-
-describeWithServer('HTTP Provider', opts => {
-
-	afterEach(async() => {
-		await verifyNoDirectRevealLeaks()
-	})
-
-	it('should create claim with template params', async() => {
-		const resp = await createClaimOnAttestor({
-			name: 'http',
-			params: {
-				url: 'https://news.ycombinator.{{param1}}/{{param6}}?token={{param4}}&token1={{param5}}',
-				method: 'GET',
-				responseMatches: [{
-					type: 'regex',
-					value: '<title.*?(?<domain>{{param2}})<\\/title>',
-				}],
-				responseRedactions: [{
-					xPath: './html/head/{{param3}}',
-				}],
-				paramValues: {
-					param1: 'com',
-					param2: 'Top Links | Hacker News',
-					param3: 'title',
-				}
-			},
-			secretParams: {
-				cookieStr: '<cookie-str>',
-				paramValues: {
-					param4: 'quhrfqiuherfqlireufh',
-					param5: 'sssbbbbr123',
-					param6: 'best',
-				}
-			},
-			ownerPrivateKey: opts.privateKeyHex,
-			client: opts.client,
-			zkEngine: 'gnark'
-		})
-		assert.ok(!resp.error)
-		assert.match(
-			resp.claim?.context || '',
-			/0x5e3e976476ded7b58120d606b33b75be52adb8345a7979c181764f00763e7b2a/
-		)
-	})
-
-	it('should create claim with OPRF template params', async() => {
-		const resp = await createClaimOnAttestor({
-			name: 'http',
-			params: {
-				url: 'https://example.com/',
-				method: 'GET',
-				responseMatches: [
-					{
-						type: 'contains',
-						value: '<title>{{domain}}</title>',
-					}
-				],
-				responseRedactions: [
-					{
-						xPath: '/html/head/title',
-						regex: '<title>(?<domain>.*?)<\\/title>',
-						hash: 'oprf'
-					}
-				],
-				paramValues:{ domain:'Example Domain' }
-			},
-			secretParams: {
-				cookieStr: '<cookie-str>'
-			},
-			ownerPrivateKey: opts.privateKeyHex,
-			client: opts.client,
-			zkEngine: 'gnark',
-		})
-		assert.ok(!resp.error)
-
-		const ctx = JSON.parse(resp.claim!.context)
-		const domainStr = ctx.extractedParameters.domain
-
-		const toprf = getFirstTOprfBlock(resp.request!)?.payload
-		assert.ok(toprf)
-		const toprfStr = binaryHashToStr(
-			toprf.nullifier,
-			toprf.dataLocation!.length
-		)
-		assert.equal(domainStr, toprfStr.slice(0, domainStr.length))
-	})
-
-	it('should create claim with non 200 response', async() => {
-		const resp = await createClaimOnAttestor({
-			name: 'http',
-			params: {
-				url: 'https://the-internet.herokuapp.com/status_codes/201',
-				method: 'GET',
-				responseMatches: [{
-					type: 'contains',
-					value: 'Status Codes',
-				}],
-				responseRedactions: [{
-					xPath: '/html/body/div[2]/div/div/h3',
-				}],
-				headers: {
-					accept: 'application/json, text/plain, */*'
-				}
-			},
-			secretParams: {
-				cookieStr: '<cookie-str>'
-			},
-			ownerPrivateKey: opts.privateKeyHex,
-			client: opts.client,
-			zkEngine: 'gnark'
-		})
-		assert.ok(!resp.error)
-		assert.match(
-			resp.claim?.context || '',
-			/0x51004e4a2d91eda6fa8cf2e6fa9a8dd973070114a7c670a4c47797e9a55ab872/
-		)
-	})
-})

package/src/tests/jsc.test_mac.ts

@@ -1,296 +0,0 @@
-/**
- * This file tests that if the TLS library works on javascript
- * core (jsc) environment.
- * 1. Ensure you have the jsc binary installed
- * 2. Ensure you have built the jsc file via `npm run build:jsc`
- */
-import { asciiToUint8Array } from '@joclaim/tls'
-import { makeLocalFileFetch } from '@joclaim/zk-symmetric-crypto'
-import { initGnark } from '@joclaim/zk-symmetric-crypto/gnark'
-import { exec } from 'child_process'
-import { after, afterEach, before, beforeEach, describe, it } from 'node:test'
-import { stderr, stdout } from 'process'
-import type { WebSocketServer } from 'ws'
-
-import { generateRpcRequestId } from '#src/external-rpc/utils.ts'
-import { ALL_ENC_ALGORITHMS } from '#src/external-rpc/zk.ts'
-import { createServer } from '#src/server/create-server.ts'
-import { getRandomPort, randomPrivateKey } from '#src/tests/utils.ts'
-import { B64_JSON_REPLACER, B64_JSON_REVIVER } from '#src/utils/b64-json.ts'
-import { uint8ArrayToBinaryStr } from '#src/utils/generics.ts'
-import { logger } from '#src/utils/logger.ts'
-import { makeDefaultZkOperator } from '#src/utils/zk.ts'
-
-// algorithm doesn't matter, as the JSC bridge handles that part internally
-// we'll just initialise all of them now
-for(const alg of ALL_ENC_ALGORITHMS) {
-	await initGnark(alg, makeLocalFileFetch(), logger)
-}
-
-const GNARK_ZK = makeDefaultZkOperator('chacha20', 'gnark', logger)
-
-describe('JSC Test', () => {
-
-	let wsServer: WebSocketServer
-	let privateKeyHex: string
-	const wsServerPort = getRandomPort()
-
-	let bridge: Awaited<ReturnType<typeof runJscBridge>>
-
-	before(async() => {
-		wsServer = await createServer(wsServerPort)
-	})
-
-	after(async() => {
-		wsServer.close()
-	})
-
-	beforeEach(async() => {
-		privateKeyHex = randomPrivateKey()
-		bridge = await runJscBridge(
-			{ attestorBaseUrl: `http://localhost:${wsServerPort}` }
-		)
-	})
-
-	afterEach(() => {
-		bridge?.exit()
-	})
-
-	it('should create claim with RPC', async() => {
-		const result = await bridge.rpc({
-			type: 'createClaim',
-			id: generateRpcRequestId(),
-			request: {
-				name: 'http',
-				params: {
-					url: 'https://the-internet.herokuapp.com/status_codes/201',
-					method: 'GET',
-					responseMatches: [{
-						type: 'contains',
-						value: 'Status Codes',
-					}],
-					responseRedactions: [{
-						xPath: '/html/body/div[2]/div/div/h3',
-					}],
-					headers: {
-						accept: 'application/json, text/plain, */*'
-					}
-				},
-				secretParams: {
-					cookieStr: '<cookie-str>'
-				},
-				ownerPrivateKey: privateKeyHex,
-				zkEngine: 'gnark',
-				zkOperatorMode: 'rpc'
-			}
-		})
-		console.log('Claim created:', result)
-	})
-})
-
-async function runJscBridge(
-	init: {
-		attestorBaseUrl: string
-	},
-) {
-	const wsMap: Record<string, WebSocket> = {}
-	const pendingRpcMap: Record<
-		string, (data: JSCOutgoingMsg) => void
-	> = {}
-
-	const prc = exec('jsc -x out/jsc-cli-rpc.mjs', { })
-	prc.stdout!.on('data', async(data) => {
-		const cmds = Array.from(tryReadCmds(data))
-		if(!cmds.length) {
-			stdout.write('[JSC] ')
-			stdout.write(data)
-			return
-		}
-
-		for(const cmd of cmds) {
-			let res: JSCIncomingMsg
-			try {
-				const rslt = await handleCmd(cmd)
-				if(!rslt) {
-					return
-				}
-
-				res = {
-					type: `${cmd.type}Done`,
-					id: cmd.id,
-					module: 'attestor-core',
-					isResponse: true,
-					response: rslt,
-				} as any
-			} catch(err) {
-				res = {
-					type: 'error',
-					isResponse: true,
-					id: cmd.id,
-					data: {
-						message: err.message,
-						stack: err.stack,
-					}
-				}
-			}
-
-			await writeCmd(res)
-		}
-	})
-	prc.stderr!.on('data', (data) => {
-		stderr.write('[JSC-ERR] ')
-		stderr.write(data)
-	})
-
-	prc.on('exit', (err) => {
-		console.error('Error in JSC process', err)
-	})
-
-	await writeCmd({ type: 'init', ...init })
-
-	return {
-		writeCmd,
-		rpc,
-		exit() {
-			prc.kill()
-			onExit()
-		}
-	}
-
-	function onExit() {
-		for(const [id, ws] of Object.entries(wsMap)) {
-			ws.close()
-			delete wsMap[id]
-		}
-
-		for(const [id, resolve] of Object.entries(pendingRpcMap)) {
-			resolve({
-				type: 'error',
-				id,
-				isResponse: true,
-				data: {
-					message: 'Bridge closed before response',
-					stack: ''
-				}
-			})
-			delete pendingRpcMap[id]
-		}
-	}
-
-	async function handleCmd(cmd: JSCOutgoingMsg) {
-		if(pendingRpcMap[cmd.id]) {
-			const resolve = pendingRpcMap[cmd.id]
-			delete pendingRpcMap[cmd.id]
-			resolve(cmd)
-			return
-		}
-
-		if(cmd.type === 'connectWs') {
-			const { request: { id, url } } = cmd
-			const ws = (wsMap[id] = new WebSocket(url))
-			ws.binaryType = 'arraybuffer'
-			await new Promise<void>((resolve, reject) => {
-				ws.onopen = () => resolve()
-				ws.onerror = (ev) => reject(ev['error'] || ev)
-			})
-
-			ws.onclose = async() => {
-				await writeCmd({
-					type: 'disconnectWs',
-					id: generateRpcRequestId(),
-					request: { id }
-				})
-				delete wsMap[id]
-			}
-
-			ws.onmessage = async(ev) => {
-				const data = typeof ev.data === 'string'
-					? ev.data
-					: new Uint8Array(ev.data)
-				await writeCmd({
-					type: 'sendWsMessage',
-					id: generateRpcRequestId(),
-					request: { id, data }
-				})
-			}
-
-			return {}
-		}
-
-		if(cmd.type === 'sendWsMessage') {
-			const { request: { id, data } } = cmd
-			const ws = wsMap[id]
-			if(!ws) {
-				throw new Error(`WebSocket with id ${id} not found`)
-			}
-
-			ws.send(data)
-			return {}
-		}
-
-		if(cmd.type === 'executeZkFunctionV3') {
-			const { request: { fn, args } } = cmd
-			// @ts-expect-error
-			const result = await GNARK_ZK[fn]!(...args)
-			return result
-		}
-
-		if(cmd.type === 'createClaimStep') {
-			return
-		}
-
-		throw new Error(`Unknown command: ${cmd.type}`)
-	}
-
-	async function rpc<T>(cmd: JSCIncomingMsg) {
-		if(!('id' in cmd)) {
-			throw new Error('RPC command must have an id')
-		}
-
-		const waitForRes = new Promise<T>((resolve, reject) => {
-			pendingRpcMap[cmd.id] = data => {
-				if(data.type === 'error') {
-					reject(new Error(data.data.message))
-					return
-				}
-
-				resolve(data['response'] as T)
-			}
-		})
-		await writeCmd(cmd)
-
-		return waitForRes
-	}
-
-	function writeCmd(cmd: JSCIncomingMsg) {
-		const cmdStr = JSON.stringify(cmd, B64_JSON_REPLACER)
-		return new Promise<void>((resolve, reject) => {
-			prc.stdin!.write(asciiToUint8Array(cmdStr + '\n'), (err) => {
-				if(err) {
-					reject(err)
-				} else {
-					resolve()
-				}
-			})
-		})
-	}
-}
-
-function *tryReadCmds(str: string | Uint8Array): Generator<JSCOutgoingMsg> {
-	str = typeof str === 'string' ? str : uint8ArrayToBinaryStr(str)
-	const lines = str.split('\n')
-	for(const line of lines) {
-		try {
-			const cmd = JSON.parse(line, B64_JSON_REVIVER)
-			if(
-				typeof cmd !== 'object'
-				|| !cmd.type
-				|| cmd.module !== 'attestor-core'
-			) {
-				continue
-			}
-
-			yield cmd as JSCOutgoingMsg
-		} catch{}
-	}
-}

package/src/tests/mock-provider-server.ts

@@ -1,106 +0,0 @@
-/**
- * Mock HTTPS server to implement the "mock-login" provider
- */
-import { readFileSync } from 'fs'
-import { createServer } from 'https'
-
-import { logger } from '#src/utils/index.ts'
-
-/**
- * Mock https server to test claim creation.
- * It implements a GET /me endpoint that returns the email address
- * of the user. A bearer token is expected in the Authorization header.
- *
- * The bearer token is expected to be the email address without the domain.
- * Eg. to claim the email address "abcd@mock.com", the header
- * should be "Authorization: Bearer abcd".
- */
-export function createMockServer(port: number) {
-	const tlsSessionStore: Record<string, Buffer> = {}
-
-	const server = createServer(
-		{
-			key: readFileSync('./cert/private-key.pem'),
-			cert: readFileSync('./cert/public-cert.pem'),
-		}
-	)
-
-	server.on('request', (req, res) => {
-		if(req.method !== 'GET') {
-			endWithError(405, 'invalid method')
-			return
-		}
-
-		if(!req.url?.startsWith('/me')) {
-			endWithError(404, 'invalid path')
-			return
-		}
-
-		const auth = req.headers.authorization
-		if(!auth) {
-			endWithError(401, 'missing authorization header')
-			return
-		}
-
-		if(!auth?.startsWith('Bearer ')) {
-			endWithError(401, 'invalid authorization header')
-			return
-		}
-
-		const userId = auth.slice('Bearer '.length)
-		const emailAddress = userId + '@mock.com'
-		const resp = { emailAddress }
-		const parsedUrl = new URL(req.url, 'http://localhost')
-
-		const split = parsedUrl.searchParams.get('splitDataAcrossPackets')
-		if(split === 'true') {
-			// simulate spread across multiple packets by adding delays
-			// in sending the response
-			const str = JSON.stringify({ emailAddress })
-			const splitStart = str.indexOf(userId) + 4
-			if(splitStart <= 0 || splitStart >= str.length - 1) {
-				endWithError(500, 'could not split response')
-				return
-			}
-
-			res.writeHead(200, {
-				'Content-Type': 'application/json',
-				'Content-Length': str.length.toString(),
-			})
-			res.write(str.slice(0, splitStart))
-
-			setTimeout(() => {
-				res.write(str.slice(splitStart))
-				res.end()
-			}, 500)
-
-			logger.info({ emailAddress }, 'sent split response')
-
-			return
-		}
-
-		endWithJson(200, resp)
-		logger.info({ emailAddress }, 'ended with success')
-
-		function endWithError(status: number, message: string) {
-			endWithJson(status, { error: message })
-
-			logger.info({ status, message }, 'ended with error')
-		}
-
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		function endWithJson(status: number, json: any) {
-			const str = JSON.stringify(json)
-			res.writeHead(status, {
-				'Content-Type': 'application/json',
-				'Content-Length': str.length.toString(),
-			})
-			res.write(str)
-			res.end()
-		}
-	})
-
-	server.listen(port)
-
-	return { server, tlsSessionStore }
-}

package/src/tests/mocks.ts

@@ -1,25 +0,0 @@
-import { setCryptoImplementation } from '@joclaim/tls'
-import { webcryptoCrypto } from '@joclaim/tls/webcrypto'
-import { mock } from 'node:test'
-import '#src/server/utils/config-env.ts'
-
-import { preparePacketsForReveal } from '#src/utils/prepare-packets.ts'
-
-setCryptoImplementation(webcryptoCrypto)
-
-/**
- * Spies on the preparePacketsForReveal function
- */
-export const SPY_PREPARER = mock.fn(preparePacketsForReveal)
-
-mock.module('#src/utils/prepare-packets.ts', {
-	namedExports: {
-		preparePacketsForReveal: SPY_PREPARER
-	}
-})
-
-mock.module('#src/server/utils/apm.ts', {
-	namedExports: {
-		getApm: mock.fn()
-	}
-})

package/src/tests/rpc-communication.test.ts

@@ -1,115 +0,0 @@
-import assert from 'node:assert'
-import { beforeEach, it } from 'node:test'
-
-import { AttestorClient } from '#src/client/index.ts'
-import { describeWithServer } from '#src/tests/describe-with-server.ts'
-import { AttestorError, logger } from '#src/utils/index.ts'
-
-describeWithServer('RPC Communication', opts => {
-
-	const { getClientOnServer } = opts
-
-	let client: AttestorClient
-	beforeEach(() => {
-		client = opts.client
-	})
-
-	it('should successfully initialise a session', async() => {
-		await client.waitForInit()
-		assert.ok(client.isInitialised)
-		// ensure the server has our client
-		assert.ok(getClientOnServer())
-	})
-
-	it('should gracefully handle terminated connection during init', async() => {
-		await client.terminateConnection()
-		client = new AttestorClient({
-			logger,
-			// a URL without a WS server
-			url: `ws://localhost:${opts.mockhttpsServerPort}`
-		})
-		await assert.rejects(
-			() => client.waitForInit(),
-			err => {
-				assert.ok(err instanceof AttestorError)
-				assert.strictEqual(err.code, 'ERROR_NETWORK_ERROR')
-				return true
-			}
-		)
-	})
-
-	it('should gracefully handle connection termination', async() => {
-		const err = new AttestorError(
-			'ERROR_INTERNAL',
-			'Test error',
-			{ abcd: 1 }
-		)
-		const waitForEnd = new Promise<AttestorError>(resolve => {
-			client.addEventListener('connection-terminated', d => {
-				resolve(d.data)
-			})
-		})
-
-		const ws = getClientOnServer()!
-		await ws.terminateConnection(err)
-		const recvErr = await waitForEnd
-		assert.deepEqual(recvErr, err)
-		assert.ok(!client.isOpen)
-	})
-
-	it('should terminate connection to server', async() => {
-		const ws = getClientOnServer()!
-		const waitForEnd = new Promise<AttestorError>(resolve => {
-			ws.addEventListener('connection-terminated', d => {
-				resolve(d.data)
-			})
-		})
-
-		await client.terminateConnection()
-		await waitForEnd
-	})
-
-	it('should handle RPC error response', async() => {
-		const err = new AttestorError(
-			'ERROR_INTERNAL',
-			'Test error',
-			{ abcd: 1 }
-		)
-
-		const ws = getClientOnServer()!
-		ws.addEventListener('rpc-request', ev => {
-			ev.stopImmediatePropagation()
-			ev.data.respond(err)
-		})
-
-		await assert.rejects(
-			() => client.rpc(
-				'createTunnel',
-				{
-					host: 'localhost',
-					port: 9999,
-				}
-			),
-			recvErr => {
-				assert.partialDeepStrictEqual(recvErr, err)
-				return true
-			}
-		)
-	})
-
-	it('should handle fetchCertificateBytes RPC', async() => {
-		const url = 'http://cacerts.rapidssl.com/RapidSSLTLSRSACAG1.crt'
-		const result = await client.rpc('fetchCertificateBytes', { url })
-		assert.ok(result.bytes?.length)
-	})
-
-	it('should fail fetchCertificateBytes RPC', async() => {
-		const url = 'http://cacerts.rapidssl.com/RapidSSLTLSRSACAG1.crt1'
-		await assert.rejects(
-			() => client.rpc('fetchCertificateBytes', { url }),
-			err => {
-				return err instanceof AttestorError
-			}
-		)
-	})
-})