186 lines
6.1 KiB
TypeScript
186 lines
6.1 KiB
TypeScript
import { readFile } from 'node:fs/promises'
|
|
import { describe, expect, it } from 'vitest'
|
|
import {
|
|
NOISE_IK_PROTOCOL,
|
|
NoiseIkSession,
|
|
createNoisePrologue,
|
|
fromBase64Url,
|
|
generateKeyPair,
|
|
toBase64Url,
|
|
} from '../src/index.js'
|
|
|
|
interface CounterVector {
|
|
initiatorSending: string
|
|
initiatorReceiving: string
|
|
responderSending: string
|
|
responderReceiving: string
|
|
}
|
|
|
|
interface MessageVector {
|
|
sender: 'initiator' | 'responder'
|
|
payload: string
|
|
message: string
|
|
}
|
|
|
|
interface TransportVector {
|
|
sender: 'initiator' | 'responder'
|
|
plaintext: string
|
|
ciphertext: string
|
|
countersAfter: CounterVector
|
|
}
|
|
|
|
interface NoiseVector {
|
|
name: string
|
|
staticKeys: Record<'initiator' | 'responder', { privateKey: string; publicKey: string }>
|
|
ephemeralPrivateKeys: Record<'initiator' | 'responder', string>
|
|
prologue: {
|
|
connectionId: string
|
|
hostDeviceId: string
|
|
clientDeviceId: string
|
|
bytes: string
|
|
}
|
|
handshake: { message1: MessageVector; message2: MessageVector }
|
|
countersAfterHandshake: CounterVector
|
|
transport: TransportVector[]
|
|
}
|
|
|
|
interface NoiseVectorFile {
|
|
fixtureFormat: string
|
|
fixtureFormatVersion: number
|
|
protocolVersion: number
|
|
suite: string
|
|
encoding: string
|
|
vectors: NoiseVector[]
|
|
}
|
|
|
|
const vectorUrl = new URL('../../../fixtures/crypto/v1/noise-ik.json', import.meta.url)
|
|
const file = JSON.parse(await readFile(vectorUrl, 'utf8')) as NoiseVectorFile
|
|
|
|
describe('Noise IK v1 golden vectors', () => {
|
|
it('uses the supported fixture format and protocol suite', () => {
|
|
expect(file).toMatchObject({
|
|
fixtureFormat: 'dsh-remote.noise-vectors',
|
|
fixtureFormatVersion: 1,
|
|
protocolVersion: 1,
|
|
suite: NOISE_IK_PROTOCOL,
|
|
encoding: 'base64url-no-padding',
|
|
})
|
|
expect(file.vectors.length).toBeGreaterThan(0)
|
|
})
|
|
|
|
it('adapts an ephemeral private key without fixing RNG read boundaries', () => {
|
|
const value = file.vectors[0]?.ephemeralPrivateKeys.initiator
|
|
if (value === undefined) throw new Error('Noise vector is missing an initiator ephemeral private key.')
|
|
const expected = fromBase64Url(value)
|
|
const random = ephemeralPrivateKeyRandom(value)
|
|
|
|
expect(random.consumed()).toBe(false)
|
|
const first = random.read(16)
|
|
const second = random.read(expected.byteLength - first.byteLength)
|
|
expect(Uint8Array.from([...first, ...second])).toEqual(expected)
|
|
expect(random.consumed()).toBe(true)
|
|
expect(() => random.read(1)).toThrow('exceeds ephemeral key')
|
|
})
|
|
|
|
it.each(file.vectors)('$name matches deterministic handshake and transport outputs', vector => {
|
|
const initiatorRandom = ephemeralPrivateKeyRandom(vector.ephemeralPrivateKeys.initiator)
|
|
const responderRandom = ephemeralPrivateKeyRandom(vector.ephemeralPrivateKeys.responder)
|
|
const prologue = createNoisePrologue(
|
|
vector.prologue.connectionId,
|
|
vector.prologue.hostDeviceId,
|
|
vector.prologue.clientDeviceId,
|
|
)
|
|
expect(toBase64Url(prologue)).toBe(vector.prologue.bytes)
|
|
expectStaticKey(vector.staticKeys.initiator)
|
|
expectStaticKey(vector.staticKeys.responder)
|
|
|
|
const initiator = createSession('initiator', vector, prologue, initiatorRandom.read)
|
|
const responder = createSession('responder', vector, prologue, responderRandom.read)
|
|
|
|
expectHandshake('initiator', vector.handshake.message1, initiator, responder)
|
|
expectHandshake('responder', vector.handshake.message2, responder, initiator)
|
|
expect(initiator.complete).toBe(true)
|
|
expect(responder.complete).toBe(true)
|
|
expectCounters(initiator, responder, vector.countersAfterHandshake)
|
|
expect(initiatorRandom.consumed()).toBe(true)
|
|
expect(responderRandom.consumed()).toBe(true)
|
|
|
|
for (const transport of vector.transport) {
|
|
const source = transport.sender === 'initiator' ? initiator : responder
|
|
const target = transport.sender === 'initiator' ? responder : initiator
|
|
const plaintext = fromBase64Url(transport.plaintext)
|
|
const ciphertext = source.encrypt(plaintext)
|
|
expect(toBase64Url(ciphertext)).toBe(transport.ciphertext)
|
|
expect(target.decrypt(ciphertext)).toEqual(plaintext)
|
|
expectCounters(initiator, responder, transport.countersAfter)
|
|
}
|
|
})
|
|
})
|
|
|
|
function createSession(
|
|
role: 'initiator' | 'responder',
|
|
vector: NoiseVector,
|
|
prologue: Uint8Array,
|
|
random: (length: number) => Uint8Array,
|
|
): NoiseIkSession {
|
|
const local = vector.staticKeys[role]
|
|
const remote = vector.staticKeys[role === 'initiator' ? 'responder' : 'initiator']
|
|
return new NoiseIkSession({
|
|
role,
|
|
localPrivateKey: local.privateKey,
|
|
localPublicKey: local.publicKey,
|
|
remotePublicKey: remote.publicKey,
|
|
prologue,
|
|
random,
|
|
})
|
|
}
|
|
|
|
function expectHandshake(
|
|
sender: MessageVector['sender'],
|
|
message: MessageVector,
|
|
source: NoiseIkSession,
|
|
target: NoiseIkSession,
|
|
): void {
|
|
expect(message.sender).toBe(sender)
|
|
const payload = fromBase64Url(message.payload)
|
|
const encoded = source.writeHandshake(payload)
|
|
expect(toBase64Url(encoded)).toBe(message.message)
|
|
expect(target.readHandshake(fromBase64Url(message.message))).toEqual(payload)
|
|
}
|
|
|
|
function expectStaticKey(key: { privateKey: string; publicKey: string }): void {
|
|
expect(generateKeyPair(fromBase64Url(key.privateKey)).publicKey).toBe(key.publicKey)
|
|
}
|
|
|
|
function expectCounters(
|
|
initiator: NoiseIkSession,
|
|
responder: NoiseIkSession,
|
|
expected: CounterVector,
|
|
): void {
|
|
expect({
|
|
initiatorSending: initiator.sendingCounter().toString(),
|
|
initiatorReceiving: initiator.receivingCounter().toString(),
|
|
responderSending: responder.sendingCounter().toString(),
|
|
responderReceiving: responder.receivingCounter().toString(),
|
|
}).toEqual(expected)
|
|
}
|
|
|
|
function ephemeralPrivateKeyRandom(value: string): {
|
|
read: (length: number) => Uint8Array
|
|
consumed: () => boolean
|
|
} {
|
|
const key = fromBase64Url(value)
|
|
let offset = 0
|
|
return {
|
|
read(length) {
|
|
if (!Number.isSafeInteger(length) || length < 0 || offset + length > key.byteLength) {
|
|
throw new Error(`Noise vector RNG request exceeds ephemeral key: ${length}`)
|
|
}
|
|
const result = key.slice(offset, offset + length)
|
|
offset += length
|
|
return result
|
|
},
|
|
consumed: () => offset === key.byteLength,
|
|
}
|
|
}
|