162 lines
5.7 KiB
TypeScript
162 lines
5.7 KiB
TypeScript
import {
|
|
NqHandshake,
|
|
chachaPoly,
|
|
noiseIk,
|
|
sha256H,
|
|
type TransportState,
|
|
} from '@lukeburns/clatterjs'
|
|
import { randomBytes } from '@noble/ciphers/webcrypto'
|
|
import { fromBase64Url } from './index.js'
|
|
|
|
export const NOISE_IK_PROTOCOL = 'Noise_IK_25519_ChaChaPoly_SHA256' as const
|
|
|
|
export interface NoiseIkSessionOptions {
|
|
role: 'initiator' | 'responder'
|
|
localPrivateKey: string
|
|
localPublicKey: string
|
|
remotePublicKey: string
|
|
prologue: Uint8Array
|
|
random?: (length: number) => Uint8Array
|
|
}
|
|
|
|
/**
|
|
* A narrow DSH Remote wrapper around a maintained Noise framework.
|
|
*
|
|
* It intentionally exposes only the fixed v1 IK suite and verifies the
|
|
* transcript's remote static key before transport messages can be used.
|
|
*/
|
|
export class NoiseIkSession {
|
|
private handshake?: NqHandshake
|
|
private readonly expectedRemoteStatic: Uint8Array
|
|
private transport?: TransportState
|
|
private destroyed = false
|
|
|
|
constructor(options: NoiseIkSessionOptions) {
|
|
const localPrivate = requireKey(options.localPrivateKey, 'local private key')
|
|
const localPublic = requireKey(options.localPublicKey, 'local public key')
|
|
this.expectedRemoteStatic = requireKey(options.remotePublicKey, 'remote public key')
|
|
const initiator = options.role === 'initiator'
|
|
this.handshake = new NqHandshake(noiseIk(), {
|
|
prologue: Uint8Array.from(options.prologue),
|
|
initiator,
|
|
s: { secretKey: localPrivate, publicKey: localPublic },
|
|
...(initiator ? { rs: Uint8Array.from(this.expectedRemoteStatic) } : {}),
|
|
cipher: chachaPoly,
|
|
hash: sha256H,
|
|
rng: options.random ?? randomBytes,
|
|
})
|
|
if (this.handshake.getName() !== NOISE_IK_PROTOCOL) {
|
|
throw new NoiseSessionError('NOISE_SUITE_MISMATCH', 'The Noise provider selected an unexpected cipher suite.')
|
|
}
|
|
}
|
|
|
|
get protocol(): typeof NOISE_IK_PROTOCOL { return NOISE_IK_PROTOCOL }
|
|
|
|
get complete(): boolean { return this.transport !== undefined }
|
|
|
|
get canWriteHandshake(): boolean {
|
|
this.assertLive()
|
|
return !this.complete && this.handshake!.isWriteTurn()
|
|
}
|
|
|
|
writeHandshake(payload = new Uint8Array()): Uint8Array {
|
|
this.assertHandshake(false)
|
|
const output = new Uint8Array(payload.byteLength + this.handshake!.getNextMessageOverhead())
|
|
const length = this.handshake!.writeMessage(payload, output)
|
|
this.finishIfReady()
|
|
return output.slice(0, length)
|
|
}
|
|
|
|
readHandshake(message: Uint8Array): Uint8Array {
|
|
this.assertHandshake(true)
|
|
const output = new Uint8Array(message.byteLength)
|
|
const length = this.handshake!.readMessage(message, output)
|
|
this.verifyRemoteStatic()
|
|
this.finishIfReady()
|
|
return output.slice(0, length)
|
|
}
|
|
|
|
encrypt(plaintext: Uint8Array): Uint8Array {
|
|
this.assertLive()
|
|
if (this.transport === undefined) throw new NoiseSessionError('NOISE_NOT_READY', 'The Noise handshake is not complete.')
|
|
return this.transport.sendVec(plaintext)
|
|
}
|
|
|
|
decrypt(ciphertext: Uint8Array): Uint8Array {
|
|
this.assertLive()
|
|
if (this.transport === undefined) throw new NoiseSessionError('NOISE_NOT_READY', 'The Noise handshake is not complete.')
|
|
return this.transport.receiveVec(ciphertext)
|
|
}
|
|
|
|
sendingCounter(): bigint {
|
|
if (this.transport === undefined) return 0n
|
|
return this.transport.sendingNonce()
|
|
}
|
|
|
|
receivingCounter(): bigint {
|
|
if (this.transport === undefined) return 0n
|
|
return this.transport.receivingNonce()
|
|
}
|
|
|
|
destroy(): void {
|
|
if (this.destroyed) return
|
|
this.destroyed = true
|
|
this.expectedRemoteStatic.fill(0)
|
|
this.transport = undefined
|
|
// clatterjs has no key erase API. Release its handshake and transport owners.
|
|
this.handshake = undefined
|
|
}
|
|
|
|
private finishIfReady(): void {
|
|
if (!this.handshake!.isFinished()) return
|
|
this.verifyRemoteStatic()
|
|
this.transport = this.handshake!.finalize()
|
|
}
|
|
|
|
private verifyRemoteStatic(): void {
|
|
const actual = this.handshake!.getRemoteStatic()
|
|
if (actual === undefined || !constantTimeEqual(actual, this.expectedRemoteStatic)) {
|
|
this.destroy()
|
|
throw new NoiseSessionError('PEER_IDENTITY_MISMATCH', 'The Noise peer static key does not match local trust.')
|
|
}
|
|
}
|
|
|
|
private assertHandshake(reading: boolean): void {
|
|
this.assertLive()
|
|
if (this.complete) throw new NoiseSessionError('NOISE_ALREADY_READY', 'The Noise handshake is already complete.')
|
|
if (this.handshake!.isWriteTurn() === reading) {
|
|
throw new NoiseSessionError('NOISE_HANDSHAKE_ORDER', 'The Noise handshake message arrived out of order.')
|
|
}
|
|
}
|
|
|
|
private assertLive(): void {
|
|
if (this.destroyed) throw new NoiseSessionError('NOISE_DESTROYED', 'The Noise session is closed.')
|
|
}
|
|
}
|
|
|
|
export class NoiseSessionError extends Error {
|
|
constructor(readonly code: string, message: string) { super(message) }
|
|
}
|
|
|
|
export function createNoisePrologue(connectionId: string, hostDeviceId: string, clientDeviceId: string): Uint8Array {
|
|
for (const [name, value] of Object.entries({ connectionId, hostDeviceId, clientDeviceId })) {
|
|
if (value.length === 0 || value.includes('\0')) throw new TypeError(`${name} is not safe for a Noise prologue`)
|
|
}
|
|
return new TextEncoder().encode(
|
|
`DSH-REMOTE\0v=1\0connection=${connectionId}\0host=${hostDeviceId}\0client=${clientDeviceId}`,
|
|
)
|
|
}
|
|
|
|
function requireKey(value: string, label: string): Uint8Array {
|
|
const key = fromBase64Url(value)
|
|
if (key.byteLength !== 32) throw new NoiseSessionError('INVALID_KEY', `${label} must be a 32-byte X25519 key.`)
|
|
return Uint8Array.from(key)
|
|
}
|
|
|
|
function constantTimeEqual(left: Uint8Array, right: Uint8Array): boolean {
|
|
if (left.byteLength !== right.byteLength) return false
|
|
let different = 0
|
|
for (let index = 0; index < left.byteLength; index += 1) different |= left[index]! ^ right[index]!
|
|
return different === 0
|
|
}
|