spec-3nweb-server 1.8.5 → 1.8.7

package/ts-code/lib-server/web-sockets/app.ts

@@ -0,0 +1,339 @@
+/*
+ Copyright (C) 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/>.
+*/
+
+import * as http from 'http';
+import * as https from 'https';
+import * as express from 'express';
+import * as WebSocket from 'ws';
+import { MapOfSets } from '../../lib-common/map-of-sets';
+import { CheckSession, BaseRequest as HttpRequest, SessionParams } from '../resources/sessions';
+import { parse as parseUrl } from 'url';
+	
+export type HttpServer = http.Server | https.Server;
+
+const MAX_MSG_PAYLOAD = 4*1024;
+
+
+class UserSocketsServer {
+
+	/**
+	 * This is a web socket server. It is undefined, when app hasn't started, or
+	 * when it has already closed.
+	 */
+	private wss: WebSocket.Server|undefined = undefined;
+
+	private socksByPath = new Map<string, UserSockets>();
+	
+	prefixPathsWith(prefix: string): void {
+		if (this.wss) { throw new Error(`Already connected to an http server`); }
+		if (!prefix) { return; }
+		prefix = ensureSlashesOnFront(prefix);
+		const socksByPath = new Map<string, UserSockets>();
+		for (const socks of this.socksByPath.values()) {
+			socks.path = `${prefix}${socks.path}`;
+			socksByPath.set(socks.path, socks);
+		}
+		this.socksByPath = socksByPath;
+	}
+
+	connectTo(server: HttpServer): void {
+		if (this.wss) { throw new Error(`Already connected to an http server`); }
+
+		this.wss = new WebSocket.Server({
+			server,
+			clientTracking: true,
+			maxPayload: MAX_MSG_PAYLOAD,
+			verifyClient: this.verifyClient.bind(this)
+		} as WebSocket.ServerOptions)
+		.on('connection', this.handleConnection.bind(this))
+		.on('error', (err) => { console.error(err); });
+
+	}
+
+	disconnect(): void {
+		if (!this.wss) { return; }
+		this.wss.close();
+		this.wss = undefined;
+		for (const socks of this.socksByPath.values()) {
+			socks.disconnect();
+		}
+		this.socksByPath.clear();
+	}
+
+	private verifyClient(
+		info: { req: http.IncomingMessage },
+		cb: (res: boolean, code?: number, msg?: string) => void
+	): void {
+		const path = parseUrl(info.req.url!).path!;
+		const socks = this.socksByPath.get(path);
+		if (!socks) {
+			cb(false, 405, `WebSocket upgrade is not provided on ${path}`);
+			return;
+		}
+		socks.checkSession(info.req as HttpRequest<SessionParams>)
+		.then((sessionOK) => {
+			cb(sessionOK);
+		}, (err) => {
+			console.error(err);
+			cb(false, 401, "Required to start new session.");
+		});
+	}
+
+	private handleConnection(
+		client: WebSocket, req: HttpRequest<SessionParams>
+	): void {
+		const userId = req.session.params.userId;
+		const path = parseUrl(req.url!).path!;
+		const socks = this.socksByPath.get(path);
+		if (!socks) {
+			client.close();
+			return;
+		}
+		socks.handleConnection(userId, client);
+	}
+
+	addUserSockets(socks: UserSockets): void {
+		if (this.socksByPath.has(socks.path)) { throw new Error(
+			`Sockets component is already set on path ${socks.path}`); }
+		this.socksByPath.set(socks.path, socks);
+	}
+
+	addUserSocketsFrom(sockServer: UserSocketsServer, path?: string): void {
+		if (path) {
+			sockServer.prefixPathsWith(path);
+		}
+		for (const sock of sockServer.socksByPath.values()) {
+			this.addUserSockets(sock);
+		}
+	}
+
+}
+Object.freeze(UserSocketsServer.prototype);
+Object.freeze(UserSocketsServer);
+
+function ensureSlashesOnFront(path: string): string {
+	while (path.endsWith('/')) {
+		path = path.substring(0, path.length - 1);
+	}
+	if (!path.startsWith('/')) {
+		path = `/${path}`;
+	}
+	return path;
+}
+
+export class UserSockets {
+
+	/**
+	 * Only connections that match this path are accepted.
+	 */
+	public path = '';
+
+	private clients = new MapOfSets<string, WebSocket>();
+	
+	private ipcs: SocketIPCs[] = [];
+
+	constructor(
+		public checkSession: CheckSession<SessionParams>,
+		private readonly pingMillis: number
+	) {}
+
+	disconnect(): void {
+		this.clients.clear();
+	}
+
+	handleConnection(userId: string, client: WebSocket): void {
+		for (const ipc of this.ipcs) {
+			ipc.attachIPC(userId, client);
+		}
+		let pinger = new PingSender(client, this.pingMillis);
+		client.on('close', () => {
+			this.clients.remove(userId, client);
+			pinger.close();
+		});
+		client.on('pong', () => pinger.onPong());
+		this.clients.add(userId, client);
+	}
+
+	addSocketIPC(ipc: SocketIPCs): void {
+		if (this.ipcs.find(existingIPC => (existingIPC.ipcChannel === ipc.ipcChannel))) {
+			throw new Error(`IPC channel ${ipc.ipcChannel} on a web socket is already set.`);
+		}
+		this.ipcs.push(ipc);
+	}
+
+	get socketGetter(): (userId: string) => Set<WebSocket>|undefined {
+		return (userId => this.clients.get(userId));
+	}
+
+}
+Object.freeze(UserSockets.prototype);
+Object.freeze(UserSockets);
+
+class PingSender {
+
+	private outstandingPong = 0;
+	private client: WebSocket|undefined;
+	private fourMinCheck: NodeJS.Timer;
+	private readonly pongTimeoutMillis: number;
+
+	constructor(
+		client: WebSocket,
+		private readonly pingMillis: number
+	) {
+		this.client = client;
+		this.pongTimeoutMillis = Math.round(this.pingMillis/2);
+		this.fourMinCheck = setInterval(() => this.recurrentPing(), this.pingMillis);
+		this.fourMinCheck.unref();
+	}
+
+	private recurrentPing(): void {
+		if (!this.client) { return this.close(); }
+		if (this.outstandingPong === 0) {
+		} else if (this.outstandingPong === 1) {
+			setTimeout(() => this.additionalPing(), this.pongTimeoutMillis).unref();
+		} else {
+			this.client.close();
+			return;
+		}
+		this.client.ping();
+		this.outstandingPong += 1;
+	}
+
+	additionalPing(): void {
+		if (!this.client) { return; }
+		if (this.outstandingPong === 0) { return; }
+		this.client.ping();
+		this.outstandingPong += 1;
+	}
+
+	onPong(): void {
+		this.outstandingPong = 0;
+	}
+	
+	close(): void {
+		if (!this.client) { return; }
+		this.client = undefined;
+		clearInterval(this.fourMinCheck);
+	}
+}
+Object.freeze(PingSender.prototype);
+Object.freeze(PingSender);
+
+export interface SocketIPCs {
+	ipcChannel: string|undefined;
+	attachIPC(userId: string, ws: WebSocket): void;
+}
+
+export class AppWithWSs {
+
+	private server: HttpServer|undefined = undefined;
+	private closingProc: Promise<void>|undefined = undefined;
+	http: express.Express;
+
+	private socks: UserSocketsServer|undefined = undefined;
+	private get sockServer(): UserSocketsServer {
+		if (!this.socks) {
+			this.socks = new UserSocketsServer();
+		}
+		return this.socks;
+	}
+
+	constructor(httpApp?: express.Express) {
+		this.http =  (httpApp ? httpApp : express());
+		Object.seal(this);
+	}
+
+	addWS(path: string, socks: UserSockets): void;
+	addWS(socks: UserSockets): void;
+	addWS(path: string|UserSockets, socks?: UserSockets): void {
+		if (typeof path === 'string') {
+			socks!.path = ensureSlashesOnFront(path);
+		} else {
+			socks = path;
+		}
+		this.sockServer.addUserSockets(socks!);
+	}
+
+	use(path: string, app: AppWithWSs): void;
+	use(app: AppWithWSs): void;
+	use(path: string|AppWithWSs, app?: AppWithWSs): void {
+		if (typeof path === 'string') {
+			if (!app) { throw new TypeError(`App argument is missing`); }
+			this.http.use(path, app.http);
+			if (app.socks) {
+				this.sockServer.addUserSocketsFrom(app.socks, path);
+			}
+		} else {
+			app = path;
+			this.http.use(app.http);
+			if (app.socks) {
+				this.sockServer.addUserSocketsFrom(app.socks);
+			}
+		}
+	}
+
+	start(
+		sslOts: https.ServerOptions|undefined, port: number, hostname?: string
+	): Promise<void> {
+		if (this.server) { throw new Error(`Server is already set`); }
+
+		// setup server
+		this.server = (sslOts ?
+			https.createServer(sslOts, this.http) :
+			http.createServer(this.http));
+		if (this.socks) {
+			this.socks.connectTo(this.server);
+		}
+
+		// start listening
+		this.closingProc = undefined;
+		return new Promise<void>((resolve, reject) => {
+			const cb = (err?) => {
+				if (err) { reject(err); }
+				else { resolve(); }
+			};
+			if (hostname) {
+				this.server!.listen(port, hostname, cb);
+			} else {
+				this.server!.listen(port, cb);
+			}
+		});
+	}
+
+	async stop(): Promise<void> {
+		if (!this.server) { return; }
+		if (!this.closingProc) {
+			if (this.socks) {
+				this.socks.disconnect();
+			}
+			this.closingProc = new Promise<void>((resolve, reject) => {
+				const cb = (err) => {
+					if (err) { reject(err); }
+					else { resolve(); }
+				};
+				this.server!.close(cb);
+				this.server = undefined;
+			});
+		}
+		await this.closingProc;
+	}
+
+}
+Object.freeze(AppWithWSs.prototype);
+Object.freeze(AppWithWSs);
+
+Object.freeze(exports);

package/ts-code/lib-server/web-sockets/server-events.ts

@@ -0,0 +1,63 @@
+/*
+ Copyright (C) 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/>.
+*/
+
+import { EventfulServer, makeEventfulServer, makeJsonCommPoint } from '../../lib-common/ipc/ws-ipc';
+import * as WebSocket from 'ws';
+import { SocketIPCs } from './app';
+
+export type EventsSink<T> = (userId: string, channel: string, event: T) => void;
+
+export class ServerEvents<T> implements SocketIPCs {
+
+	private socketToIPC = new WeakMap<WebSocket, EventfulServer>();
+
+	constructor(
+		public ipcChannel: string|undefined,
+		private eventChannels: string[],
+		private getSocket: (userId: string) => Set<WebSocket>|undefined
+	) {
+		Object.seal(this);
+	}
+
+	attachIPC(userId: string, ws: WebSocket): void {
+		const comm = makeJsonCommPoint(ws);
+		const ipc = makeEventfulServer(this.ipcChannel, comm);
+		for (const channel of this.eventChannels) {
+			ipc.addEventGroup(channel, async () => {});
+		}
+		this.socketToIPC.set(ws, ipc);
+	}
+
+	private sendEvent(userId: string, channel: string, event: T): void {
+		const sockets = this.getSocket(userId);
+		if (!sockets) { return; }
+		for (const ws of sockets) {
+			const ipc = this.socketToIPC.get(ws);
+			if (!ipc) { continue; }
+			ipc.sendEvent(channel, event);
+		}
+	}
+
+	get eventsSink(): EventsSink<T> {
+		return this.sendEvent.bind(this);
+	}
+
+}
+Object.freeze(ServerEvents.prototype);
+Object.freeze(ServerEvents);
+
+Object.freeze(exports);

package/ts-code/lib.ts

@@ -0,0 +1,29 @@
+/*
+ Copyright (C) 2020, 2023 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 { AppWithWSs } from './lib-server/web-sockets/app';
+
+export { Configurations, servicesApp, accountsApp } from './services';
+
+export { addSingleUserSignup } from './config/signup';
+
+export import errors = require('./lib-server/middleware/error-handler');
+
+export * as mock from './mock/run-in-proc';
+
+
+Object.freeze(exports);

package/ts-code/locker/locker-app.ts

@@ -0,0 +1,60 @@
+/*
+ Copyright (C) 2024 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 { Express } from 'express';
+import { json as parseJSON } from '../lib-server/middleware/body-parsers';
+import { ErrLogger, makeErrHandler } from '../lib-server/middleware/error-handler';
+import { AppWithWSs } from '../lib-server/web-sockets/app';
+import { makeSessionFactory } from './resources/sessions';
+import { makeStorageAppForLocker } from '../3nstorage/3nstorage-app';
+import { createLocker } from './routes/create-locker';
+import * as api from '../lib-common/service-api/locker';
+
+
+function addLockerSetupRoutes(app: Express): void {
+
+	app.put('/'+api.createLocker.URL_END,
+		parseJSON('1kb'),
+		// createLocker()
+	);
+
+}
+
+export function makeLockerApp(
+	rootFolder: string, errLogger?: ErrLogger
+): AppWithWSs {
+	const ownersSessions = makeSessionFactory(20*60);
+	const sharingSessions = makeSessionFactory(20*60);
+
+	const app = new AppWithWSs();
+
+	app.http.disable('etag');
+
+	addLockerSetupRoutes(app.http);
+
+	const lockers = undefined as any;
+
+	app.use('/3nstorage', makeStorageAppForLocker(
+		lockers, ownersSessions, sharingSessions, errLogger
+	));
+
+	app.http.use(makeErrHandler(errLogger));
+
+	return app;
+}
+
+Object.freeze(exports);

package/ts-code/locker/resources/lockers.ts

@@ -0,0 +1,17 @@
+/*
+ Copyright (C) 2024 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/>.
+*/
+

package/ts-code/locker/resources/sessions.ts

@@ -0,0 +1,37 @@
+/*
+ Copyright (C) 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/>.
+*/
+
+import { InMemorySessions } from '../../lib-server/resources/mem-backed-sessions-factory';
+import { Request as Req, SessionParams, Factory } from '../../lib-server/resources/sessions';
+
+export type SessionsFactory = Factory<SessionParams>;
+export type Request = Req<SessionParams>;
+
+function makeSessionParams(): SessionParams {
+	return { userId: (undefined as any) };
+}
+
+/**
+ * This returns factory, that works properly in a single process application,
+ * clearing up sessions that past given timeout.
+ * @param timeout is a session timeout in seconds
+ */
+export function makeSessionFactory(timeout: number): SessionsFactory {
+	return InMemorySessions.factory<SessionParams>(timeout, makeSessionParams);
+}
+
+Object.freeze(exports);

package/ts-code/locker/routes/create-locker.ts

@@ -0,0 +1,47 @@
+/*
+ Copyright (C) 2024 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 { RequestHandler } from 'express';
+import { createLocker as api } from '../../lib-common/service-api/locker';
+
+export type LockerCreator = (token: string|undefined) => Promise<api.Reply>;
+
+export function createLocker(
+	createLocker: LockerCreator
+): RequestHandler {
+	
+	if ('function' !== typeof createLocker) {
+		throw new TypeError(
+			"Given argument 'createLocker' must be function, but is not."
+		);
+	}
+
+	return async (req, res, next) => {
+
+		const { token } = req.body as api.Request;
+
+		try{
+			const lockerInfo = await createLocker(token);
+			res.status(api.SC.ok).json(lockerInfo);
+		} catch (err) {
+			next(err);
+		}
+
+	};
+	
+}
+Object.freeze(exports);

package/ts-code/mailerId/mailerId-app.ts

@@ -0,0 +1,107 @@
+/*
+ Copyright (C) 2015 - 2016, 2020, 2024 - 2025 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 gives a function that creates a mountable, or app.use()-able,
+ * express MailerId application.
+ */
+
+import * as express from 'express';
+import { binary as parseBinary } from '../lib-server/middleware/body-parsers';
+import { ComputeDHSharedKey } from '../lib-server/routes/pub-key-login/start-exchange';
+import { certify } from './routes/certify';
+import { Certifier } from './resources/certifier';
+import { makeSessionFactory, SessionsFactory } from './resources/sessions';
+import { makeFactory as makeUserFactory, Factory as UserFactory } from './resources/users';
+import { makeSingleProcCertifier } from './resources/certifier';
+import { calcNaClBoxSharedKey } from '../lib-server/resources/server-key-for-pkl-challenge';
+import { ErrLogger, makeErrHandler } from '../lib-server/middleware/error-handler';
+import * as api from '../lib-common/service-api/mailer-id/provisioning';
+import { addPKLLoginRoutes } from '../lib-server/pkl-access';
+import { OwnMidService } from '../lib-server/resources/mailerid-authorizer';
+import { MailerIdRootRoute } from '../lib-common/service-api/mailer-id/root-route';
+
+// Constant url parts of MailerId provisioning requests
+const PROVISIONING_PATH = '/prov/';
+
+function provisioningApp(
+	sessions: SessionsFactory, users: UserFactory,
+	certifier: Certifier, computeDHSharedKey: ComputeDHSharedKey
+): express.Express {
+
+	const app = express();
+	app.disable('etag');
+
+	// Login
+	addPKLLoginRoutes(
+		app, '/', users.getUserParamsAndKey, sessions, computeDHSharedKey
+	);
+
+	// *** Require authorized session for everything below ***
+	app.use(sessions.ensureAuthorizedSession());
+
+	// MailerId certificate provisioning routes
+	app.post('/' + api.certify.URL_END,
+		parseBinary('16kb'),
+		certify(certifier.certify)
+	);
+
+	return app;
+}
+
+export function makeMailerIdApp(
+	rootFolder: string, domain: string, certFile: string,
+	errLogger?: ErrLogger
+): { app: express.Express; ownService: OwnMidService; } {
+
+	const app = express();
+	const certProvisSessions = makeSessionFactory(2*60);
+	const users = makeUserFactory(rootFolder);
+	const certifier = makeSingleProcCertifier(domain, certFile);
+
+	app.use(PROVISIONING_PATH,
+		provisioningApp(
+			certProvisSessions, users, certifier, calcNaClBoxSharedKey
+		)
+	);
+
+	// MailerId display of service parameters, as per protocol
+	app.get('/', (req: express.Request, res: express.Response) => {
+		let path = req.originalUrl;
+		if (path[path.length-1] !== '/') {
+			path = path+'/';
+		}
+		const json: MailerIdRootRoute = {
+			"current-cert": certifier.getRootCert(),
+			"previous-certs": certifier.getPrevCerts(),
+			provisioning: path+PROVISIONING_PATH.substring(1)
+		};
+		res.status(200).json(json);	// content type application/json
+	});
+
+	app.use(makeErrHandler(errLogger));
+
+	return {
+		app,
+		ownService: {
+			domain,
+			getRoot: () => certifier.getRootCert()
+		}
+	};
+}
+
+Object.freeze(exports);