@joclaim/attestor-core 0.2.0 → 0.2.3

package/src/tests/zk.test.ts

@@ -1,453 +0,0 @@
-import type { CipherSuite } from '@joclaim/tls'
-import { crypto, encryptWrappedRecord, SUPPORTED_CIPHER_SUITE_MAP } from '@joclaim/tls'
-import type { ZKEngine } from '@joclaim/zk-symmetric-crypto'
-import assert from 'node:assert'
-import { describe, it } from 'node:test'
-import '#src/server/utils/config-env.ts'
-
-import { TOPRF_DOMAIN_SEPARATOR } from '#src/config/index.ts'
-import type { MessageReveal_ZKProof as ZKProof } from '#src/proto/api.ts'
-import { ZKProofEngine } from '#src/proto/api.ts'
-import { toprf } from '#src/server/handlers/toprf.ts'
-import type { CompleteTLSPacket, MessageRevealInfo, RedactedOrHashedArraySlice, TOPRFProofParams } from '#src/types/index.ts'
-import {
-	getBlocksToReveal,
-	isTls13Suite,
-	logger,
-	makeDefaultOPRFOperator,
-	makeZkProofGenerator,
-	preparePacketsForReveal,
-	redactSlices,
-	strToUint8Array,
-	uint8ArrayToStr,
-	verifyZkPacket
-} from '#src/utils/index.ts'
-
-const ZK_CIPHER_SUITES: CipherSuite[] = [
-	'TLS_CHACHA20_POLY1305_SHA256',
-	'TLS_AES_128_GCM_SHA256',
-	'TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384',
-]
-
-const ZK_ENGINES: ZKEngine[] = [
-	'gnark',
-	'snarkjs'
-]
-
-type RedactionTestVector = {
-	input: string[]
-	output: string[]
-	redactions: RedactedOrHashedArraySlice[]
-}
-
-describe('Redaction Tests', () => {
-
-	it('should correctly redact blocks', async() => {
-		const vectors: RedactionTestVector[] = [
-			{
-				input: [
-					'hell',
-					'o world'
-				],
-				output: [
-					'h***',
-					'* world'
-				],
-				redactions: [
-					{ fromIndex: 1, toIndex: 5 }
-				]
-			},
-			{
-				input: [
-					'hell',
-					'o world'
-				],
-				output: [
-					// first block is completely
-					// redacted, so it won't be included
-					'* world'
-				],
-				redactions: [
-					{ fromIndex: 0, toIndex: 5 }
-				]
-			},
-			{
-				input: [
-					'hello',
-					'how',
-					'do',
-					'you',
-					'do'
-				],
-				output: [
-					'he**o',
-					'd*',
-					'y*u',
-					'do'
-				],
-				redactions: [
-					{ fromIndex: 2, toIndex: 4 },
-					{ fromIndex: 5, toIndex: 8 },
-					{ fromIndex: 9, toIndex: 10 },
-					{ fromIndex: 11, toIndex: 12 }
-				]
-			}
-		]
-
-		for(const { input, output, redactions } of vectors) {
-			const realOutput = await getBlocksToReveal(
-				input.map(i => ({ plaintext: Buffer.from(i) })),
-				() => redactions,
-				() => {
-					throw new Error('should not call this')
-				}
-			)
-			assert(realOutput !== 'all', 'should not return "all"')
-
-			assert.equal(realOutput.length, output.length)
-			for(const [i, element] of output.entries()) {
-				assert.equal(
-					uint8ArrayToStr(realOutput[i].redactedPlaintext),
-					element
-				)
-			}
-		}
-	})
-
-	it('should correctly hash blocks', async() => {
-		const nullifer = strToUint8Array('abcdefg')
-		const base64Nullifier = Buffer.from(nullifer).toString('base64')
-		const vectors: RedactionTestVector[] = [
-			{
-				input: [
-					'hell',
-					'o world'
-				],
-				output: [
-					'h' + base64Nullifier.slice(0, 3),
-					base64Nullifier.slice(3, 4) + ' world'
-				],
-				redactions: [
-					{ fromIndex: 1, toIndex: 5, hash: 'oprf' }
-				]
-			},
-			{
-				input: [
-					'hell',
-					'o world'
-				],
-				output: [
-					base64Nullifier.slice(0, 4),
-					base64Nullifier.slice(4, 5) + ' world'
-				],
-				redactions: [
-					{ fromIndex: 0, toIndex: 5, hash: 'oprf' }
-				]
-			},
-		]
-
-		for(const { input, output, redactions } of vectors) {
-			const realOutput = await getBlocksToReveal(
-				input.map(i => ({ plaintext: Buffer.from(i) })),
-				() => redactions,
-				async() => ({
-					dataLocation: undefined,
-					nullifier: nullifer,
-					responses: [],
-					mask: strToUint8Array('mask'),
-					plaintext: strToUint8Array('abcdefg')
-				})
-			)
-			assert(realOutput !== 'all', 'should not return "all"')
-
-			assert.equal(realOutput.length, output.length)
-			for(const [i, element] of output.entries()) {
-				assert.equal(
-					uint8ArrayToStr(realOutput[i].redactedPlaintext),
-					element
-				)
-			}
-		}
-	})
-})
-
-describe('OPRF Slicing Tests', () => {
-
-	const cipherSuite: CipherSuite = 'TLS_CHACHA20_POLY1305_SHA256'
-	const alg = 'CHACHA20-POLY1305'
-	const zkEngine = 'gnark'
-	const keylength = 32
-
-	it('should correctly demarcate blocks for OPRF', async() => {
-		const plaintext = `lorem ipsum dolor sit amet, consectetur adipiscing elit,
-			sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
-			Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris
-			nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
-			cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
-			cupidatat non proident, sunt in culpa qui officia deserunt mollit anim
-			id est laborum`
-		const vectors = [
-			{
-				plaintext: plaintext,
-				redactions: [
-					{ fromIndex: 0, toIndex: 35, hash: 'oprf' as const },
-				]
-			},
-			{
-				plaintext: plaintext,
-				redactions: [
-					{ fromIndex: 128, toIndex: 138, hash: 'oprf' as const },
-				]
-			},
-			{
-				plaintext: plaintext,
-				redactions: [
-					{ fromIndex: 125, toIndex: 135, hash: 'oprf' as const },
-				]
-			}
-		]
-
-		const key = Buffer.alloc(keylength, 0)
-		key[0] = 1
-		key[3] = 4
-		const {
-			ivLength: fixedIvLength,
-		} = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite]
-		const fixedIv = Buffer.alloc(fixedIvLength, 0)
-		fixedIv[0] = 1
-		fixedIv[3] = 4
-
-		const encKey = await crypto.importKey(alg, key)
-
-		for(const [i, { plaintext, redactions }] of vectors.entries()) {
-			const plaintextArr = Buffer.from(plaintext)
-			const { ciphertext, iv } = await encryptWrappedRecord(
-				plaintextArr,
-				{
-					key: encKey,
-					iv: fixedIv,
-					recordNumber: 1234,
-					recordHeaderOpts: { type: 'WRAPPED_RECORD' },
-					cipherSuite,
-					version: isTls13Suite(cipherSuite) ? 'TLS1_3' : 'TLS1_2',
-				}
-			)
-
-			const packet: CompleteTLSPacket = {
-				type: 'ciphertext',
-				encKey,
-				iv,
-				recordNumber: 1234,
-				plaintext: plaintextArr,
-				ciphertext,
-				fixedIv: fixedIv,
-				data: ciphertext
-			}
-
-			const blocksToReveal
-				= await getBlocksToReveal([packet], () => redactions, performOprf)
-			assert(blocksToReveal !== 'all')
-			assert.equal(blocksToReveal.length, 1)
-			assert.ok(blocksToReveal[0].toprfs)
-
-			const revealsMap: Map<CompleteTLSPacket, MessageRevealInfo> = new Map()
-			revealsMap.set(packet, {
-				type: 'zk',
-				redactedPlaintext: blocksToReveal[0].redactedPlaintext,
-				toprfs: blocksToReveal[0].toprfs
-			})
-
-			const revealedMessages = await preparePacketsForReveal(
-				[{ sender: 'server', message: packet }],
-				revealsMap,
-				{
-					logger,
-					cipherSuite: cipherSuite,
-					zkEngine: zkEngine,
-				}
-			)
-
-			const zkReveal = revealedMessages[0].reveal?.zkReveal
-			assert.ok(zkReveal?.proofs?.length)
-			assert.ok(zkReveal?.toprfs?.length)
-
-			const x = await verifyZkPacket(
-				{
-					ciphertext,
-					zkReveal,
-					logger,
-					cipherSuite,
-					zkEngine,
-					recordNumber: 1234,
-					iv: fixedIv,
-					getNextPacket() {
-						throw new Error('should not be called in this test')
-					}
-				},
-			)
-
-			assert.deepEqual(
-				uint8ArrayToStr(x.redactedPlaintext),
-				uint8ArrayToStr(blocksToReveal[0].redactedPlaintext)
-			)
-
-			console.log(`done: ${i + 1}/${vectors.length}`)
-		}
-	})
-
-	async function performOprf(plaintext: Uint8Array) {
-		logger.info({ length: plaintext.length }, 'generating OPRF...')
-
-		const oprfOperator = makeDefaultOPRFOperator(
-			'chacha20',
-			zkEngine,
-			logger
-		)
-		const reqData = await oprfOperator.generateOPRFRequestData(
-			plaintext,
-			TOPRF_DOMAIN_SEPARATOR,
-			logger
-		)
-		const res = await toprf(
-			{
-				maskedData: reqData.maskedData,
-				engine: ZKProofEngine.ZK_ENGINE_GNARK
-			},
-			{ logger } as any
-		)
-		const nullifier = await oprfOperator.finaliseOPRF(
-			res.publicKeyShare,
-			reqData,
-			[res]
-		)
-
-		const data: TOPRFProofParams = {
-			nullifier,
-			responses: [res],
-			mask: reqData.mask,
-			dataLocation: undefined,
-			plaintext
-		}
-
-		return data
-	}
-})
-
-const ZK_TEST_MATRIX = ZK_CIPHER_SUITES.flatMap(cipherSuite => (
-	ZK_ENGINES.map(zkEngine => ({ cipherSuite, zkEngine }))
-))
-
-for(const { cipherSuite, zkEngine } of ZK_TEST_MATRIX) {
-	describe(`[${cipherSuite}]-[${zkEngine}] should generate ZK proof for ciphertext`, () => {
-		const zkProofConcurrency = zkEngine === 'snarkjs' ? 1 : undefined
-
-		it(zkEngine + '-' + cipherSuite, async() => {
-			const alg = cipherSuite.includes('CHACHA20')
-				? 'CHACHA20-POLY1305'
-				: (
-					cipherSuite.includes('AES_256_GCM')
-						? 'AES-256-GCM'
-						: 'AES-128-GCM'
-				)
-			const keylength = alg === 'AES-128-GCM' ? 16 : 32
-			const key = Buffer.alloc(keylength, 0)
-			key[0] = 1
-			key[3] = 4
-			const {
-				ivLength: fixedIvLength,
-			} = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite]
-			const fixedIv = Buffer.alloc(fixedIvLength, 0)
-			fixedIv[0] = 1
-			fixedIv[3] = 4
-
-			const encKey = await crypto.importKey(alg, key)
-			const vectors = [
-				{
-					plaintext:
-						'My cool API secret is "my name jeff". Please don\'t reveal it',
-					redactions: [
-						{ fromIndex: 23, toIndex: 35 }
-					]
-				},
-				{
-					plaintext: `lorem ipsum dolor sit amet, consectetur adipiscing elit,
-				sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
-				Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris
-				nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
-				cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
-				cupidatat non proident, sunt in culpa qui officia deserunt mollit anim
-				id est laborum`,
-					redactions: [
-						{ fromIndex: 5, toIndex: 15 },
-					]
-				}
-			]
-
-			const proofGenerator = await makeZkProofGenerator({
-				logger,
-				cipherSuite,
-				zkEngine,
-				zkProofConcurrency,
-			})
-			for(const { plaintext, redactions } of vectors) {
-				const plaintextArr = Buffer.from(plaintext)
-				const redactedPlaintext = redactSlices(plaintextArr, redactions)
-				// ensure redaction fn kinda works at least
-				assert.notEqual(redactedPlaintext, plaintextArr)
-
-				const { ciphertext, iv } = await encryptWrappedRecord(
-					plaintextArr,
-					{
-						key: encKey,
-						iv: fixedIv,
-						recordNumber: 1234,
-						recordHeaderOpts: { type: 'WRAPPED_RECORD' },
-						cipherSuite,
-						version: cipherSuite.includes('ECDHE_')
-							? 'TLS1_2'
-							: 'TLS1_3',
-					}
-				)
-
-				const packet: CompleteTLSPacket = {
-					type: 'ciphertext',
-					encKey,
-					iv,
-					recordNumber: 1234,
-					plaintext: plaintextArr,
-					ciphertext,
-					fixedIv: fixedIv,
-					data: ciphertext
-				}
-
-				let proofs: ZKProof[] | undefined
-				await proofGenerator.addPacketToProve(
-					packet,
-					{ type: 'zk', redactedPlaintext },
-					p => proofs = p,
-					() => {
-						throw new Error('should not be called in this test')
-					}
-				)
-				await proofGenerator.generateProofs()
-
-				const x = await verifyZkPacket(
-					{
-						ciphertext,
-						zkReveal: { proofs: proofs!, toprfs: [] },
-						logger,
-						cipherSuite,
-						zkEngine: zkEngine,
-						recordNumber: 1234,
-						iv: fixedIv,
-						getNextPacket() {
-							throw new Error('should not be called in this test')
-						}
-					},
-				)
-
-				assert.deepEqual(redactedPlaintext, x.redactedPlaintext)
-			}
-		})
-	})
-}

package/src/types/bgp.ts

@@ -1,17 +0,0 @@
-
-export type BGPAnnouncementOverlapData = {
-	prefix: string
-}
-
-export type BGPListener = {
-	/**
-	 * Add an IP to listen for overlap,
-	 * @returns a function to remove the IP from the listener
-	 */
-	onOverlap(
-		ips: string[],
-		callback: (event: BGPAnnouncementOverlapData) => void
-	): (() => void)
-
-	close(): void
-}

package/src/types/claims.ts

@@ -1,79 +0,0 @@
-import type { ProviderClaimData } from '#src/proto/api.ts'
-import type { IAttestorClient, IAttestorClientInitParams } from '#src/types/client.ts'
-import type { CompleteTLSPacket, Logger } from '#src/types/general.ts'
-import type { ProofGenerationStep, ProviderName, ProviderParams, ProviderSecretParams } from '#src/types/providers.ts'
-import type { Transcript } from '#src/types/tunnel.ts'
-import type { PrepareZKProofsBaseOpts } from '#src/types/zk.ts'
-
-/**
- * Uniquely identifies a claim.
- * Hash of claim info.
- * Utilise `getIdentifierFromClaimInfo` to obtain this.
- */
-export type ClaimID = ProviderClaimData['identifier']
-
-export type ClaimInfo = Pick<ProviderClaimData, 'context' | 'provider' | 'parameters'>
-
-export type AnyClaimInfo = ClaimInfo | { identifier: ClaimID }
-
-export type CompleteClaimData = Pick<ProviderClaimData, 'owner' | 'timestampS' | 'epoch'>
-	& AnyClaimInfo
-
-export type CreateClaimOnAttestorOpts<N extends ProviderName> = {
-	/** name of the provider to generate signed receipt for */
-	name: N
-	/**
-	 * secrets that are used to make the API request;
-	 * not included in the receipt & cannot be viewed by anyone
-	 * outside this client
-	 */
-	secretParams: ProviderSecretParams<N>
-	params: ProviderParams<N>
-	/**
-	 * Some metadata context to be included in the claim
-	 */
-	context?: { [key: string]: any }
-
-	onStep?(step: ProofGenerationStep): void
-	/**
-	 * Private key in hex format,
-	 * prefixed with '0x'
-	 */
-	ownerPrivateKey: string
-	/**
-	 * Provide either the client or the URL
-	 * to the server -- so a client can be created internally.
-	 *
-	 * The created client will go into the global client pool.
-	 */
-	client: IAttestorClient | IAttestorClientInitParams
-	/**
-	 * Optionally set the timestamp of the claim
-	 * in unix seconds. If not provided, the current
-	 * time will be used.
-	 */
-	timestampS?: number
-
-	logger?: Logger
-
-	/**
-	 * Maximum number of retries to attempt
-	 * @default 3
-	 */
-	maxRetries?: number
-	/**
-	 * Optionally update the provider parameters
-	 * based on the transcript
-	 */
-	updateProviderParams? (transcript: Transcript<CompleteTLSPacket>, tlsVersion: string): Promise<{
-		params: Partial<ProviderParams<N>>
-		secretParams: Partial<ProviderSecretParams<N>>
-	}>
-
-	/**
-	 * Replaces paramValue with corresponding OPRF hash before proof is made
-	 * Only if there's matching redaction exists
-	 * For example: "domain.com" -> "dv4Nrgtr"
-	 */
-	updateParametersFromOprfData?: boolean
-} & PrepareZKProofsBaseOpts