spec-3nweb-server 1.8.5 → 1.8.7

package/ts-code/tests/libs-for-tests/asmail.ts

@@ -0,0 +1,220 @@
+/*
+ Copyright (C) 2016, 2019, 2022 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { User, doMailerIdLogin, provisionMidSigner } from './mailerid';
+import { doJsonRequest, RequestOpts, doBodylessRequest, doBinaryRequest } from './xhr-utils';
+import { resolve as resolveUrl } from 'url';
+import { midLogin, PARAM_SC, p } from '../../lib-common/service-api/asmail/config';
+import * as random from '../../lib-common/random-node';
+import { base64 } from '../../lib-common/buffer-utils';
+import { JsonKey } from '../../lib-common/jwkeys';
+import { box } from 'ecma-nacl';
+import * as deliveryApi from '../../lib-common/service-api/asmail/delivery';
+import { BaseObj as Obj } from './3nstorage';
+import { assert } from './assert';
+
+export { BaseObj as Obj } from './3nstorage';
+
+export async function getASMailServiceUrl(
+	asmailUrl: string, service: 'delivery'|'retrieval'|'config'
+): Promise<string> {
+	const reqOpts: RequestOpts= {
+		url: asmailUrl,
+		method: 'GET',
+		responseType: 'json'
+	};
+	const rep = await doBodylessRequest<any>(reqOpts);
+	expect(rep.status).toBe(200);
+	const serviceUrl: string = rep.data[service];
+	expect(typeof serviceUrl).toBe('string');
+	return resolveUrl(asmailUrl, serviceUrl);
+}
+
+export async function setInboxParams(
+	asmailUrl: string, user: User, params: { [pUrl: string]: any; }
+): Promise<void> {
+	const confUrl = await getASMailServiceUrl(asmailUrl, 'config');
+	const sessionId = await doMailerIdLogin(
+		resolveUrl(confUrl, midLogin.URL_PART), user
+	);
+	for (const pUrl of Object.keys(params)) {
+		const reqOpts: RequestOpts= {
+			url: resolveUrl(confUrl, pUrl),
+			method: 'PUT',
+			sessionId
+		};
+		const rep = await doJsonRequest<void>(reqOpts, params[pUrl]);
+		expect(rep.status).toBe(PARAM_SC.ok);
+	}
+}
+
+export const PUBLIC_KEY_USE = 'asmail-pub-key';
+
+export async function generateInitPubKey(
+	midUrl: string, user: User
+): Promise<p.initPubKey.Certs> {
+	const midSigner = await provisionMidSigner(midUrl, user);
+	const skeyBytes = await random.bytes(box.KEY_LENGTH);
+	const pkeyBytes = box.generate_pubkey(skeyBytes);
+	const pkey: JsonKey = {
+		use: PUBLIC_KEY_USE,
+		alg: box.JWK_ALG_NAME,
+		kid: await random.stringOfB64Chars(10),
+		k: base64.pack(pkeyBytes)
+	};
+	const pkeyCert = midSigner.certifyPublicKey(pkey, 30*24*60*60);
+	const certs: p.initPubKey.Certs = {
+		pkeyCert,
+		provCert: midSigner.providerCert,
+		userCert: midSigner.userCert
+	};
+	return certs;
+}
+
+export async function startMsgDeliverySession(
+	deliveryUrl: string, req: deliveryApi.sessionStart.Request
+): Promise<deliveryApi.sessionStart.Reply> {
+	const reqOpts: RequestOpts = {
+		url: resolveUrl(deliveryUrl, deliveryApi.sessionStart.URL_END),
+		method: 'POST',
+		responseType: 'json'
+	};
+	const rep = await doJsonRequest<deliveryApi.sessionStart.Reply>(
+		reqOpts, req
+	);
+	expect(rep.status).toBe(deliveryApi.sessionStart.SC.ok);
+	return rep.data;
+}
+
+export interface DeliveryInfo extends
+	deliveryApi.msgMeta.Reply, deliveryApi.sessionStart.Reply {}
+
+export async function startMsgDelivery(
+	deliveryUrl: string, firstReq: deliveryApi.sessionStart.Request,
+	metaReq: deliveryApi.msgMeta.Request
+): Promise<DeliveryInfo> {
+	const info = (await startMsgDeliverySession(
+		deliveryUrl, firstReq
+	)) as DeliveryInfo;
+	const reqOpts: RequestOpts = {
+		url: resolveUrl(deliveryUrl, deliveryApi.msgMeta.URL_END),
+		method: 'PUT',
+		responseType: 'json',
+		sessionId: info.sessionId
+	};
+	const rep = await doJsonRequest<deliveryApi.msgMeta.Reply>(reqOpts, metaReq);
+	expect(rep.status).toBe(deliveryApi.msgMeta.SC.ok);
+	for (const field of Object.keys(rep.data)) {
+		info[field] = rep.data[field];
+	}
+	return info;
+}
+
+export async function sendMsgObj(
+	deliveryUrl: string, sessionId: string, obj: Obj,
+	chunkLimit: number|undefined
+): Promise<void> {
+	if (!obj.objId) { throw new Error(`Message object doesn't have an id`); }
+	if (!chunkLimit) {
+		chunkLimit = 512*1024;
+	}
+	
+	let ofs = 0;
+	const segsLen = obj.segs.length;
+	while (ofs < segsLen) {
+		const reqOpts: RequestOpts = { url: '', method: 'PUT', sessionId };
+		let bytesToSend: Uint8Array | Uint8Array[];
+		
+		if (ofs === 0) {
+			// first request starts with header
+			const header = obj.header.length;
+			const segsChunk = obj.segs.subarray(0, chunkLimit - header);
+			const last = (segsChunk.length === obj.segs.length);
+			bytesToSend = [ obj.header, segsChunk ];
+			reqOpts.url = resolveUrl(deliveryUrl,
+				deliveryApi.msgObj.firstPutReqUrlEnd(obj.objId, { header, last }));
+			ofs += segsChunk.length;
+		} else {
+			// second request(s) send bytes
+			bytesToSend = obj.segs.subarray(ofs, ofs+chunkLimit);
+			const last = ((ofs + bytesToSend.length) === obj.segs.length);
+			reqOpts.url = resolveUrl(deliveryUrl,
+				deliveryApi.msgObj.secondPutReqUrlEnd(obj.objId, { ofs, last }));
+			ofs += bytesToSend.length;
+		}
+		const rep = await doBinaryRequest<void>(reqOpts, bytesToSend);
+		assert(rep.status === deliveryApi.msgObj.SC.ok, `Msg obj isn't saved: server status ${rep.status} instead of expected ${deliveryApi.msgObj.SC.ok}`);
+	}
+}
+
+export interface Msg {
+	cryptoMeta: deliveryApi.msgMeta.CryptoInfo,
+	msgObjs: Obj[]
+}
+
+export async function sendMsg(
+	deliveryUrl: string, recipient: string, msg: Msg
+): Promise<string> {
+	const stepsIter = msgSendingSteps(deliveryUrl, recipient, msg);
+	const fstStep = await stepsIter.next();
+	expect(fstStep.done).toBeFalsy();
+	expect(fstStep.value).toBeDefined();
+	const msgId = fstStep.value;
+	let done: boolean;
+	do {
+		done = !!(await stepsIter.next()).done;
+	} while (!done);
+	return msgId;
+}
+
+export async function* msgSendingSteps(
+	deliveryUrl: string, recipient: string, msg: Msg
+): AsyncGenerator<string, string, unknown> {
+	const meta = makeMetaFor(msg);
+	const sessInfo = await startMsgDelivery(deliveryUrl, { recipient }, meta);
+	yield sessInfo.msgId;
+	for (const msgObj of msg.msgObjs) {
+		await sendMsgObj(
+			deliveryUrl, sessInfo.sessionId, msgObj, sessInfo.maxChunkSize
+		);
+		yield sessInfo.msgId;
+	}
+	const reqOpts: RequestOpts = {
+		url: resolveUrl(deliveryUrl, deliveryApi.completion.URL_END),
+		method: 'POST',
+		sessionId: sessInfo.sessionId
+	};
+	const rep = await doBodylessRequest<void>(reqOpts);
+	expect(rep.status).toBe(deliveryApi.completion.SC.ok);
+	return sessInfo.msgId;
+}
+
+function makeMetaFor(msg: Msg): deliveryApi.msgMeta.Request {
+	const meta = msg.cryptoMeta as deliveryApi.msgMeta.Request;
+	meta.objIds = [];
+	for (let i=0; i < msg.msgObjs.length; i+=1) {
+		const objId = msg.msgObjs[i].objId;
+		if (!objId) {
+			throw new Error(`Message object #${i} doesn't have an id`);
+		}
+		meta.objIds[i] = objId;
+	}
+	return meta;
+}
+
+
+Object.freeze(exports);

package/ts-code/tests/libs-for-tests/assert.ts

@@ -0,0 +1,22 @@
+/*
+ Copyright(c) 2018 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+export function assert(ok: boolean, errMsg?: string): void {
+	if (!ok) { throw new Error(errMsg); }
+}
+
+Object.freeze(exports);

package/ts-code/tests/libs-for-tests/async-jasmine.ts

@@ -0,0 +1,89 @@
+/*
+ Copyright (C) 2016 - 2017 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+export function itAsync(expectation: string,
+		assertion?: () => Promise<void>, timeout?: number): void {
+	if (assertion) {
+		it(expectation, done => {
+			assertion().then(
+				() => done(),
+				err => done.fail(err));
+		}, timeout);
+	} else {
+		it(expectation);
+	}
+}
+
+export function xitAsync(expectation: string,
+		assertion?: () => Promise<void>, timeout?: number): void {
+	if (assertion) {
+		xit(expectation, done => {
+			assertion().then(
+				() => done(),
+				err => done.fail(err));
+		}, timeout);
+	} else {
+		xit(expectation);
+	}
+}
+
+export function fitAsync(expectation: string,
+		assertion?: () => Promise<void>, timeout?: number): void {
+	if (assertion) {
+		fit(expectation, done => {
+			assertion().then(
+				() => done(),
+				err => done.fail(err));
+		}, timeout);
+	} else {
+		fit(expectation);
+	}
+}
+
+export function beforeAllAsync(action: () => Promise<void>, timeout?: number) {
+	beforeAll(done => {
+		action().then(
+			() => done(),
+			err => done.fail(err));
+	}, timeout);
+}
+
+export function afterAllAsync(action: () => Promise<void>, timeout?: number) {
+	afterAll(done => {
+		action().then(
+			() => done(),
+			err => done.fail(err));
+	}, timeout);
+}
+
+export function beforeEachAsync(action: () => Promise<void>, timeout?: number) {
+	beforeEach(done => {
+		action().then(
+			() => done(),
+			err => done.fail(err));
+	}, timeout);
+}
+
+export function afterEachAsync(action: () => Promise<void>, timeout?: number) {
+	afterEach(done => {
+		action().then(
+			() => done(),
+			err => done.fail(err));
+	}, timeout);
+}
+
+Object.freeze(exports);

package/ts-code/tests/libs-for-tests/bytes-equal.ts

@@ -0,0 +1,25 @@
+/*
+ Copyright (C) 2016 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+export function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+	if (a.BYTES_PER_ELEMENT !== b.BYTES_PER_ELEMENT) { return false; }
+	if (a.length !== b.length) { return false; }
+	for (let i=0; i<a.length; i+=1) {
+		if (a[i] !== b[i]) { return false; }
+	}
+	return true;
+}

package/ts-code/tests/libs-for-tests/json-copy.ts

@@ -0,0 +1,38 @@
+/*
+ Copyright (C) 2016 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+export function copy<T>(orig: T): T {
+	if (typeof orig !== 'object') { return orig; }
+	if (orig === null) { return (null as any); }
+	if (Array.isArray(orig)) {
+		let arr: any[] = orig;
+		let c: any[] = [];
+		for (let i=0; i < arr.length; i+=1) {
+			c[i] = copy(arr[i]);
+		}
+		return (c as any);
+	} else {
+		let c = ({} as T);
+		let fields = Object.keys(orig);
+		for (let f of fields) {
+			c[f] = copy<any>(orig[f]);
+		}
+		return c;
+	}
+}
+
+Object.freeze(exports);

package/ts-code/tests/libs-for-tests/json-equal.ts

@@ -0,0 +1,55 @@
+/*
+ Copyright (C) 2015 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * This module provides hex encoding of binary array into a string.
+ */
+
+export function deepEqual(a: any, b: any): boolean {
+	
+	let t = typeof a;
+	
+	if (t !== typeof b) { return false; }
+	
+	if (t !== 'object') {
+		return (a === b);
+	}
+	
+	if (a === b) { return true; }
+	if ((a === null) || (b === null)) { return false; }
+		
+	if (Array.isArray(a)) {
+		if (!Array.isArray(b)) { return false; }
+		let aArr = <Array<any>> a;
+		let bArr = <Array<any>> b;
+		if (aArr.length !== bArr.length) { return false; }
+		for (let i=0; i<aArr.length; i+=1) {
+			if (!deepEqual(aArr[i], bArr[i])) { return false; }
+		}
+	} else {
+		let keys = Object.keys(a);
+		if (keys.length !== Object.keys(b).length) { return false; }
+		for (let i=0; i<keys.length; i+=1) {
+			let key = keys[i];
+			if (!deepEqual(a[key], b[key])) { return false; }
+		}
+	}
+	
+	return true;
+}
+
+Object.freeze(exports);

package/ts-code/tests/libs-for-tests/mailerid.ts

@@ -0,0 +1,123 @@
+/*
+ Copyright (C) 2016 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { isLikeSignedKeyCert, SignedLoad } from '../../lib-common/jwkeys';
+import { doJsonRequest, RequestOpts, doBodylessRequest, doBinaryRequest }
+	from './xhr-utils';
+import { authSession, startSession }
+	from '../../lib-common/service-api/mailer-id/login';
+import { certify as certApi }
+	from '../../lib-common/service-api/mailer-id/provisioning';
+import { user as midUser }	from '../../lib-common/mid-sigs-NaCl-Ed';
+import { doPubKeyLogin, User } from './pkl';
+import { bytesSync as randomBytes } from '../../lib-common/random-node';
+import { parse as parseUrl } from 'url';
+
+export { User } from './pkl';
+
+async function getMidData(midUrl: string): Promise<any> {
+	let reqOpts: RequestOpts= {
+		url: midUrl,
+		method: 'GET',
+		responseType: 'json'
+	};
+	let rep = await doBodylessRequest<any>(reqOpts);
+	expect(rep.status).toBe(200);
+	return rep.data;
+}
+
+/**
+ * @param midUrl
+ * @return a promise, resolvable to MailerId service's provisioning url.
+ */
+export async function getProvPath(midUrl: string): Promise<any> {
+	let midData = await getMidData(midUrl);
+	let prov: string = midData['provisioning']
+	expect(typeof prov).toBe('string');
+	// return url with provision path
+	let pathStarts = midUrl.indexOf('/', midUrl.indexOf('://')+3);
+	return midUrl.substring(0, pathStarts) + prov;
+}
+
+export async function getMidRoot(midUrl: string): Promise<SignedLoad> {
+	let midData = await getMidData(midUrl);
+	let rootCert = midData["current-cert"];
+	expect(isLikeSignedKeyCert(rootCert)).toBe(true);
+	return rootCert;
+}
+
+export async function startMidSession(loginUrl: string, userId: string):
+		Promise<string> {
+	let reqOpts: RequestOpts= {
+		url: loginUrl + startSession.URL_END,
+		method: 'POST',
+		responseType: 'json'
+	};
+	let req: startSession.Request = { userId };
+	let rep = await doJsonRequest<startSession.Reply>(reqOpts, req);
+	expect(rep.status).toBe(startSession.SC.ok);
+	return rep.data.sessionId;
+}
+
+export async function provisionMidSigner(midServiceUrl: string, user: User):
+		Promise<midUser.MailerIdSigner> {
+	let provUrl = await getProvPath(midServiceUrl);
+	let sessParams = await doPubKeyLogin(provUrl, user);
+	let reqOpts: RequestOpts= {
+		url: provUrl + certApi.URL_END,
+		method: 'POST',
+		sessionId: sessParams.sessionId,
+		responseType: 'arraybuffer'
+	};
+	let midSigningPair = midUser.generateSigningKeyPair(randomBytes);
+	let reqData: certApi.Request = {
+		pkey: midSigningPair.pkey,
+		duration: 12*60*60
+	};
+	let encrBody = sessParams.sessEncr.packJSON(reqData);
+	let rep = await doBinaryRequest<Uint8Array>(reqOpts, encrBody);
+	expect(rep.status).toBe(certApi.SC.ok);
+	let repData: certApi.Reply = sessParams.sessEncr.openJSON(rep.data);
+	return midUser.makeMailerIdSigner(
+		midSigningPair.skey, repData.userCert, repData.provCert);
+}
+
+export async function doMailerIdLogin(loginUrl: string, user: User):
+		Promise<string> {
+	let sessionId = await startMidSession(loginUrl, user.id);
+	let midSigner = await provisionMidSigner(user.midUrl, user);
+	let reqOpts: RequestOpts= {
+		url: loginUrl + authSession.URL_END,
+		method: 'POST',
+		responseType: 'json',
+		sessionId
+	};
+	let serviceDomain = parseUrl(loginUrl).hostname;
+	if (!serviceDomain) { throw new Error(
+		`Cannot parse hostname from login url ${loginUrl}`); }
+	let req: authSession.Request = {
+		assertion: midSigner.generateAssertionFor(
+			serviceDomain, sessionId),
+		provCert: midSigner.providerCert,
+		userCert: midSigner.userCert
+	};
+	let rep = await doJsonRequest<void>(reqOpts, req);
+	expect(rep.status).toBe(authSession.SC.ok);
+	return sessionId;
+}
+
+Object.freeze(exports);

package/ts-code/tests/libs-for-tests/pkl.ts

@@ -0,0 +1,127 @@
+/*
+ Copyright (C) 2016 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import * as pklApi from '../../lib-common/service-api/pub-key-login';
+import { base64 } from '../../lib-common/buffer-utils';
+import { box, secret_box as sbox, nonce as nonceMod, arrays }
+	from 'ecma-nacl';
+import { makeSessionEncryptor, SessionEncryptor }
+	from '../../lib-common/session-encryptor';
+import { doJsonRequest, RequestOpts, doBinaryRequest }
+	from './xhr-utils';
+import { parse as parseUrl, resolve as resolveUrl } from 'url';
+import { bytesEqual } from './bytes-equal';
+
+export interface User {
+	id: string;
+	loginDefaultSKey: Uint8Array;
+	loginLabeledSKey: {
+		kid: string;
+		k: Uint8Array;
+	};
+	midUrl: string;
+	storageOwnerUrl: string;
+}
+
+export interface ExchangeCrypto {
+	sessEncr: SessionEncryptor;
+	serverVerificationBytes: Uint8Array;
+	encResponse: Uint8Array;
+}
+
+export function decryptSessionParamsForCurve25519(r: pklApi.start.Reply,
+		loginSKey: Uint8Array): ExchangeCrypto {
+	let serverPKey = base64.open(r.serverPubKey);
+	expect(serverPKey.length).toBe(box.KEY_LENGTH);
+	let sharedKey = box.calc_dhshared_key(serverPKey, loginSKey);
+	let encChallenge = base64.open(r.sessionKey);
+	expect(encChallenge.length).toBe(
+		sbox.NONCE_LENGTH + sbox.KEY_LENGTH);
+	let nonce = encChallenge.subarray(0, sbox.NONCE_LENGTH);
+	let zeros = new Uint8Array(sbox.KEY_LENGTH);
+	let stream = sbox.pack(zeros, nonce, sharedKey).subarray(sbox.POLY_LENGTH);
+	let sessionKey = new Uint8Array(
+		encChallenge.subarray(sbox.NONCE_LENGTH));
+	for (var i=0; i < sbox.KEY_LENGTH; i+=1) {
+		sessionKey[i] ^= stream[i];
+	}
+	let serverVerificationBytes =
+		sbox.pack(sessionKey, nonce, sharedKey)
+		.subarray(0, sbox.POLY_LENGTH);
+	nonceMod.advanceOddly(nonce);
+	let sessEncr = makeSessionEncryptor(sessionKey, nonce);
+	let encResponse = sessEncr.pack(sessionKey);
+	arrays.wipe(sessionKey);
+	return { sessEncr, serverVerificationBytes, encResponse };
+}
+
+export interface ExchangeParams {
+	crypto: ExchangeCrypto;
+	sessionId: string;
+}
+
+export async function startPKLSession(loginUrl: string, user: User,
+		useDefaultKey: boolean): Promise<ExchangeParams> {
+	let reqOpts: RequestOpts= {
+		url: resolveUrl(loginUrl, pklApi.start.URL_END),
+		method: 'POST',
+		responseType: 'json'
+	};
+	let req: pklApi.start.Request = (useDefaultKey ?
+		{ userId: user.id } :
+		{ userId: user.id, kid: user.loginLabeledSKey.kid });
+	let rep = await doJsonRequest<pklApi.start.Reply>(reqOpts, req);
+	expect(rep.status).toBe(pklApi.start.SC.ok);
+	let skey = (useDefaultKey ? user.loginDefaultSKey : user.loginLabeledSKey.k)
+	return {
+		sessionId: rep.data.sessionId,
+		crypto: decryptSessionParamsForCurve25519(rep.data, skey)
+	};
+}
+
+export interface SessionParams {
+	sessEncr: SessionEncryptor;
+	sessionId: string;
+}
+
+async function validatePKLSession(loginUrl: string,
+		exchangeParams: ExchangeParams): Promise<SessionParams> {
+	let reqOpts: RequestOpts= {
+		url: resolveUrl(loginUrl, pklApi.complete.URL_END),
+		method: 'POST',
+		sessionId: exchangeParams.sessionId,
+		responseType: 'arraybuffer'
+	};
+	let rep = await doBinaryRequest<Uint8Array>(
+		reqOpts, exchangeParams.crypto.encResponse);
+	expect(rep.status).toBe(pklApi.complete.SC.ok);
+	expect(rep.data.length).toBe(sbox.POLY_LENGTH);
+	expect(bytesEqual(rep.data, exchangeParams.crypto.serverVerificationBytes))
+	.toBe(true);
+	return {
+		sessionId: exchangeParams.sessionId,
+		sessEncr: exchangeParams.crypto.sessEncr
+	};
+}
+
+export async function doPubKeyLogin(loginUrl: string, user: User):
+		Promise<SessionParams> {
+	let exchangeParams = await startPKLSession(loginUrl, user, false);
+	return validatePKLSession(loginUrl, exchangeParams);
+}
+
+Object.freeze(exports);